From 4b4a68322ff53924848f3d84b300a52e8b93ccd1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Fahller?= <bjorn@fahller.se>
Date: Sat, 4 Nov 2023 14:08:40 +0100
Subject: [PATCH 01/20] Split into top level header + sub headers

---
 include/trompeloeil.hpp      | 5885 +--------------------------------
 include/trompeloeil/mock.hpp | 5915 ++++++++++++++++++++++++++++++++++
 2 files changed, 5916 insertions(+), 5884 deletions(-)
 create mode 100644 include/trompeloeil/mock.hpp

diff --git a/include/trompeloeil.hpp b/include/trompeloeil.hpp
index 370f78d0..482c77cd 100644
--- a/include/trompeloeil.hpp
+++ b/include/trompeloeil.hpp
@@ -2,8 +2,6 @@
  * Trompeloeil C++ mocking framework
  *
  * Copyright (C) Björn Fahller 2014-2021
- * Copyright (C) 2017, 2018 Andrew Paxie
- * Copyright Tore Martin Hagen 2019
  *
  *  Use, modification and distribution is subject to the
  *  Boost Software License, Version 1.0. (See accompanying
@@ -28,5887 +26,6 @@
 // * Mocking function templates is not supported
 // * If a macro kills a kitten, this threatens extinction of all felines!
 
-#if defined(TROMPELOEIL_EXPERIMENTAL_COROUTINES)
-#  if defined(__cpp_impl_coroutine)
-#    define TROMPELOEIL_COROUTINES_SUPPORTED 1
-#  else
-#    error "Coroutines are not supported by this compiler"
-#  endif
-#endif
-
-#if defined(_MSC_VER)
-
-#  define TROMPELOEIL_NORETURN __declspec(noreturn)
-
-#  if (!defined(__cplusplus) || _MSC_VER < 1900)
-#    error requires C++ in Visual Studio 2015 RC or later
-#  endif
-
-#else
-
-#  define TROMPELOEIL_NORETURN [[noreturn]]
-
-#  if (!defined(__cplusplus) || __cplusplus < 201103L)
-#    error requires C++11 or higher
-#  endif
-
-#endif
-
-#if defined(__clang__)
-
-#  define TROMPELOEIL_CLANG 1
-#  define TROMPELOEIL_GCC 0
-#  define TROMPELOEIL_MSVC 0
-
-#  define TROMPELOEIL_CLANG_VERSION \
-  (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__)
-
-#  define TROMPELOEIL_GCC_VERSION 0
-
-#  define TROMPELOEIL_CPLUSPLUS __cplusplus
-
-#  define TROMPELOEIL_NOT_IMPLEMENTED(...)                         \
-  _Pragma("clang diagnostic push")                                   \
-  _Pragma("clang diagnostic ignored \"-Wunneeded-member-function\"") \
-  __VA_ARGS__                                                        \
-  _Pragma("clang diagnostic pop")
-
-#elif defined(__GNUC__)
-
-#  define TROMPELOEIL_CLANG 0
-#  define TROMPELOEIL_GCC 1
-#  define TROMPELOEIL_MSVC 0
-
-#  define TROMPELOEIL_CLANG_VERSION 0
-#  define TROMPELOEIL_GCC_VERSION \
-  (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
-
-#  define TROMPELOEIL_CPLUSPLUS __cplusplus
-
-#elif defined(_MSC_VER)
-
-#  define TROMPELOEIL_CLANG 0
-#  define TROMPELOEIL_GCC 0
-#  define TROMPELOEIL_MSVC 1
-
-#  define TROMPELOEIL_CLANG_VERSION 0
-#  define TROMPELOEIL_GCC_VERSION 0
-
-#  if defined(_MSVC_LANG)
-
-    // Compiler is at least Microsoft Visual Studio 2015 Update 3.
-#    define TROMPELOEIL_CPLUSPLUS _MSVC_LANG
-
-#  else /* defined(_MSVC_LANG) */
-
-    /*
-     * This version of Microsoft Visual C++ is released
-     * in a version of Microsoft Visual Studio between
-     * 2015 RC and less than 2015 Update 3.
-     *
-     * It is an amalgam of C++ versions, with no provision
-     * to specify C++11 mode.
-     *
-     * It also has a __cplusplus macro stuck at 199711L with
-     * no way to change it, such as /Zc:__cplusplus.
-     *
-     * Assume the C++14 code path, but don't promise that it is a
-     * fully conforming implementation of C++14 either.
-     * Hence a value of 201401L, which less than 201402L,
-     * the standards conforming value of __cplusplus.
-     */
-#    define TROMPELOEIL_CPLUSPLUS 201401L
-
-#  endif /* !defined(_MSVC_LANG) */
-
-#endif
-
-
-#ifndef TROMPELOEIL_NOT_IMPLEMENTED
-#define TROMPELOEIL_NOT_IMPLEMENTED(...) __VA_ARGS__
-#endif
-
-#include <algorithm>
-#include <tuple>
-#include <iomanip>
-#include <sstream>
-#include <exception>
-#include <functional>
-#include <memory>
-#include <cstring>
-#include <regex>
-#include <mutex>
-#include <atomic>
-#include <array>
-#include <initializer_list>
-#include <type_traits>
-#include <utility>
-
-
-#ifndef TROMPELOEIL_CUSTOM_ATOMIC
-#include <atomic>
-namespace trompeloeil { using std::atomic; }
-#else
-#include <trompeloeil/custom_atomic.hpp>
-#endif
-
-#ifndef TROMPELOEIL_CUSTOM_UNIQUE_LOCK
-namespace trompeloeil { using std::unique_lock; }
-#else
-#include <trompeloeil/custom_unique_lock.hpp>
-#endif
-
-#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
-#include <coroutine>
-#endif
-
-#ifdef TROMPELOEIL_SANITY_CHECKS
-#include <cassert>
-#define TROMPELOEIL_ASSERT(x) assert(x)
-#else
-#define TROMPELOEIL_ASSERT(x) do {} while (false)
-#endif
-
-#define TROMPELOEIL_IDENTITY(...) __VA_ARGS__ // work around stupid MS VS2015 RC bug
-
-#define TROMPELOEIL_ARG16(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15, ...) _15
-
-#define TROMPELOEIL_COUNT(...)                                                 \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_ARG16(__VA_ARGS__,                          \
-                                         15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0))
-
-#if TROMPELOEIL_MSVC
-
-#define TROMPELOEIL_CONCAT_(x, y, ...) x ## y __VA_ARGS__
-#define TROMPELOEIL_CONCAT(x, ...) TROMPELOEIL_CONCAT_(x, __VA_ARGS__)
-
-#else /* TROMPELOEIL_MSVC */
-
-#define TROMPELOEIL_CONCAT_(x, ...) x ## __VA_ARGS__
-#define TROMPELOEIL_CONCAT(x, ...) TROMPELOEIL_CONCAT_(x, __VA_ARGS__)
-
-#endif /* !TROMPELOEIL_MSVC */
-
-#define TROMPELOEIL_SEPARATE1(p1) p1
-#define TROMPELOEIL_SEPARATE2(p1,p2) p1 p2
-#define TROMPELOEIL_SEPARATE3(p1,...) p1 TROMPELOEIL_SEPARATE2(__VA_ARGS__)
-#define TROMPELOEIL_SEPARATE4(p1,...) p1 TROMPELOEIL_SEPARATE3(__VA_ARGS__)
-#define TROMPELOEIL_SEPARATE5(p1,...) p1 TROMPELOEIL_SEPARATE4(__VA_ARGS__)
-#define TROMPELOEIL_SEPARATE6(p1,...) p1 TROMPELOEIL_SEPARATE5(__VA_ARGS__)
-#define TROMPELOEIL_SEPARATE7(p1,...) p1 TROMPELOEIL_SEPARATE6(__VA_ARGS__)
-#define TROMPELOEIL_SEPARATE8(p1,...) p1 TROMPELOEIL_SEPARATE7(__VA_ARGS__)
-#define TROMPELOEIL_SEPARATE9(p1,...) p1 TROMPELOEIL_SEPARATE8(__VA_ARGS__)
-#define TROMPELOEIL_SEPARATE(...) \
-  TROMPELOEIL_CONCAT(TROMPELOEIL_SEPARATE,\
-                     TROMPELOEIL_COUNT(__VA_ARGS__))(__VA_ARGS__)
-
-
-#define TROMPELOEIL_REMOVE_PAREN(...) TROMPELOEIL_CONCAT(TROMPELOEIL_CLEAR_,   \
-  TROMPELOEIL_REMOVE_PAREN_INTERNAL __VA_ARGS__)
-#define TROMPELOEIL_REMOVE_PAREN_INTERNAL(...)                                 \
-  TROMPELOEIL_REMOVE_PAREN_INTERNAL __VA_ARGS__
-#define TROMPELOEIL_CLEAR_TROMPELOEIL_REMOVE_PAREN_INTERNAL
-
-#define TROMPELOEIL_EXPAND(x) x
-
-#define TROMPELOEIL_INIT_WITH_STR15(base, x, ...)                              \
-  base{#x, x}, TROMPELOEIL_EXPAND(TROMPELOEIL_INIT_WITH_STR14(base, __VA_ARGS__))
-
-#define TROMPELOEIL_INIT_WITH_STR14(base, x, ...)                              \
-  base{#x, x}, TROMPELOEIL_EXPAND(TROMPELOEIL_INIT_WITH_STR13(base, __VA_ARGS__))
-
-#define TROMPELOEIL_INIT_WITH_STR13(base, x, ...)                              \
-  base{#x, x}, TROMPELOEIL_EXPAND(TROMPELOEIL_INIT_WITH_STR12(base, __VA_ARGS__))
-
-#define TROMPELOEIL_INIT_WITH_STR12(base, x, ...)                              \
-  base{#x, x}, TROMPELOEIL_EXPAND(TROMPELOEIL_INIT_WITH_STR11(base, __VA_ARGS__))
-
-#define TROMPELOEIL_INIT_WITH_STR11(base, x, ...)                              \
-  base{#x, x}, TROMPELOEIL_EXPAND(TROMPELOEIL_INIT_WITH_STR10(base, __VA_ARGS__))
-
-#define TROMPELOEIL_INIT_WITH_STR10(base, x, ...)                              \
-  base{#x, x}, TROMPELOEIL_EXPAND(TROMPELOEIL_INIT_WITH_STR9(base, __VA_ARGS__))
-
-#define TROMPELOEIL_INIT_WITH_STR9(base, x, ...)                               \
-  base{#x, x}, TROMPELOEIL_EXPAND(TROMPELOEIL_INIT_WITH_STR8(base, __VA_ARGS__))
-
-#define TROMPELOEIL_INIT_WITH_STR8(base, x, ...)                               \
-  base{#x, x}, TROMPELOEIL_EXPAND(TROMPELOEIL_INIT_WITH_STR7(base, __VA_ARGS__))
-
-#define TROMPELOEIL_INIT_WITH_STR7(base, x, ...)                               \
-  base{#x, x}, TROMPELOEIL_EXPAND(TROMPELOEIL_INIT_WITH_STR6(base, __VA_ARGS__))
-
-#define TROMPELOEIL_INIT_WITH_STR6(base, x, ...)                               \
-  base{#x, x}, TROMPELOEIL_EXPAND(TROMPELOEIL_INIT_WITH_STR5(base, __VA_ARGS__))
-
-#define TROMPELOEIL_INIT_WITH_STR5(base, x, ...)                               \
-  base{#x, x}, TROMPELOEIL_EXPAND(TROMPELOEIL_INIT_WITH_STR4(base, __VA_ARGS__))
-
-#define TROMPELOEIL_INIT_WITH_STR4(base, x, ...)                               \
-  base{#x, x}, TROMPELOEIL_EXPAND(TROMPELOEIL_INIT_WITH_STR3(base, __VA_ARGS__))
-
-#define TROMPELOEIL_INIT_WITH_STR3(base, x, ...)                               \
-  base{#x, x}, TROMPELOEIL_EXPAND(TROMPELOEIL_INIT_WITH_STR2(base, __VA_ARGS__))
-
-#define TROMPELOEIL_INIT_WITH_STR2(base, x, ...)                               \
-  base{#x, x}, TROMPELOEIL_EXPAND(TROMPELOEIL_INIT_WITH_STR1(base, __VA_ARGS__))
-
-#define TROMPELOEIL_INIT_WITH_STR1(base, x)                                    \
-  base{#x, x}
-
-#define TROMPELOEIL_INIT_WITH_STR0(base)
-
-#define TROMPELOEIL_INIT_WITH_STR(base, ...)                                   \
-  TROMPELOEIL_CONCAT(TROMPELOEIL_INIT_WITH_STR,                                \
-                     TROMPELOEIL_COUNT(__VA_ARGS__))(base, __VA_ARGS__)
-
-#define TROMPELOEIL_PARAM_LIST15(...)                                          \
-  TROMPELOEIL_PARAM_LIST14(__VA_ARGS__),                                       \
-  ::trompeloeil::param_list_t<__VA_ARGS__, 14> p15
-
-#define TROMPELOEIL_PARAM_LIST14(...)                                          \
-  TROMPELOEIL_PARAM_LIST13(__VA_ARGS__),                                       \
-  ::trompeloeil::param_list_t<__VA_ARGS__, 13> p14
-
-#define TROMPELOEIL_PARAM_LIST13(...)                                          \
-  TROMPELOEIL_PARAM_LIST12(__VA_ARGS__),                                       \
-  ::trompeloeil::param_list_t<__VA_ARGS__, 12> p13
-
-#define TROMPELOEIL_PARAM_LIST12(...)                                          \
-  TROMPELOEIL_PARAM_LIST11(__VA_ARGS__),                                       \
-  ::trompeloeil::param_list_t<__VA_ARGS__, 11> p12
-
-#define TROMPELOEIL_PARAM_LIST11(...)                                          \
-  TROMPELOEIL_PARAM_LIST10(__VA_ARGS__),                                       \
-  ::trompeloeil::param_list_t<__VA_ARGS__, 10> p11
-
-#define TROMPELOEIL_PARAM_LIST10(...)                                          \
-  TROMPELOEIL_PARAM_LIST9(__VA_ARGS__),                                        \
-  ::trompeloeil::param_list_t<__VA_ARGS__, 9> p10
-
-#define TROMPELOEIL_PARAM_LIST9(...)                                           \
-  TROMPELOEIL_PARAM_LIST8(__VA_ARGS__),                                        \
-  ::trompeloeil::param_list_t<__VA_ARGS__, 8> p9
-
-#define TROMPELOEIL_PARAM_LIST8(...)                                           \
-  TROMPELOEIL_PARAM_LIST7(__VA_ARGS__),                                        \
-  ::trompeloeil::param_list_t<__VA_ARGS__, 7> p8
-
-#define TROMPELOEIL_PARAM_LIST7(...)                                           \
-  TROMPELOEIL_PARAM_LIST6(__VA_ARGS__),                                        \
-  ::trompeloeil::param_list_t<__VA_ARGS__, 6> p7
-
-#define TROMPELOEIL_PARAM_LIST6(...)                                           \
-  TROMPELOEIL_PARAM_LIST5(__VA_ARGS__),                                        \
-  ::trompeloeil::param_list_t<__VA_ARGS__, 5> p6
-
-#define TROMPELOEIL_PARAM_LIST5(...)                                           \
-  TROMPELOEIL_PARAM_LIST4(__VA_ARGS__),                                        \
-    ::trompeloeil::param_list_t<__VA_ARGS__, 4> p5
-
-#define TROMPELOEIL_PARAM_LIST4(...)                                           \
-  TROMPELOEIL_PARAM_LIST3(__VA_ARGS__),                                        \
-    ::trompeloeil::param_list_t<__VA_ARGS__, 3> p4
-
-#define TROMPELOEIL_PARAM_LIST3(...)                                           \
-  TROMPELOEIL_PARAM_LIST2(__VA_ARGS__),                                        \
-  ::trompeloeil::param_list_t<__VA_ARGS__, 2> p3
-
-#define TROMPELOEIL_PARAM_LIST2(...)                                           \
-  TROMPELOEIL_PARAM_LIST1(__VA_ARGS__),                                        \
-  ::trompeloeil::param_list_t<__VA_ARGS__, 1> p2
-
-#define TROMPELOEIL_PARAM_LIST1(...)                                           \
-  ::trompeloeil::param_list_t<__VA_ARGS__, 0> p1
-
-#define TROMPELOEIL_PARAM_LIST0(func_type)
-
-#define TROMPELOEIL_PARAM_LIST(num, func_type)                                 \
-  TROMPELOEIL_CONCAT(TROMPELOEIL_PARAM_LIST, num)                              \
-    (TROMPELOEIL_REMOVE_PAREN(func_type))
-
-
-#define TROMPELOEIL_PARAMS15 TROMPELOEIL_PARAMS14, p15
-#define TROMPELOEIL_PARAMS14 TROMPELOEIL_PARAMS13, p14
-#define TROMPELOEIL_PARAMS13 TROMPELOEIL_PARAMS12, p13
-#define TROMPELOEIL_PARAMS12 TROMPELOEIL_PARAMS11, p12
-#define TROMPELOEIL_PARAMS11 TROMPELOEIL_PARAMS10, p11
-#define TROMPELOEIL_PARAMS10 TROMPELOEIL_PARAMS9,  p10
-#define TROMPELOEIL_PARAMS9  TROMPELOEIL_PARAMS8,  p9
-#define TROMPELOEIL_PARAMS8  TROMPELOEIL_PARAMS7,  p8
-#define TROMPELOEIL_PARAMS7  TROMPELOEIL_PARAMS6,  p7
-#define TROMPELOEIL_PARAMS6  TROMPELOEIL_PARAMS5,  p6
-#define TROMPELOEIL_PARAMS5  TROMPELOEIL_PARAMS4,  p5
-#define TROMPELOEIL_PARAMS4  TROMPELOEIL_PARAMS3,  p4
-#define TROMPELOEIL_PARAMS3  TROMPELOEIL_PARAMS2,  p3
-#define TROMPELOEIL_PARAMS2  TROMPELOEIL_PARAMS1,  p2
-#define TROMPELOEIL_PARAMS1  ,                     p1
-#define TROMPELOEIL_PARAMS0
-
-#define TROMPELOEIL_PARAMS(num) TROMPELOEIL_CONCAT(TROMPELOEIL_PARAMS, num)
-
-#if defined(__cxx_rtti) || defined(__GXX_RTTI) || defined(_CPPRTTI)
-#  define TROMPELOEIL_TYPE_ID_NAME(x) typeid(x).name()
-#else
-#  define TROMPELOEIL_TYPE_ID_NAME(x) "object"
-#endif
-
-#if (TROMPELOEIL_CPLUSPLUS == 201103L)
-
-#define TROMPELOEIL_DECLTYPE_AUTO \
-  auto
-
-#define TROMPELOEIL_TRAILING_RETURN_TYPE(return_type) \
-  -> return_type
-
-#else /* (TROMPELOEIL_CPLUSPLUS == 201103L) */
-
-#define TROMPELOEIL_DECLTYPE_AUTO \
-  decltype(auto)
-
-#define TROMPELOEIL_TRAILING_RETURN_TYPE(return_type) \
-  /**/
-
-#endif /* !(TROMPELOEIL_CPLUSPLUS == 201103L) */
-#if TROMPELOEIL_CPLUSPLUS > 201403L && (!TROMPELOEIL_GCC || TROMPELOEIL_GCC_VERSION >= 70000)
-#  define TROMPELOEIL_INLINE_VAR [[maybe_unused]] static inline
-#else
-#  define TROMPELOEIL_INLINE_VAR static
-#endif
-
-static constexpr bool trompeloeil_movable_mock = false;
-
-namespace trompeloeil
-{
-  template <typename T>
-  struct identity_type
-  {
-    using type = T;
-  };
-
-  template <typename R, typename C, typename ... Args>
-  identity_type<R(Args...)>
-  nonconst_member_signature(R (C::*)(Args...))
-  {
-    return {};
-  }
-
-  template <typename R, typename C, typename ... Args>
-  identity_type<R(Args...)>
-  const_member_signature(R (C::*)(Args...) const)
-  {
-    return {};
-  }
-
-  template <typename ...>
-  struct void_t_
-  {
-    using type = void;
-  };
-
-  template <typename ... T>
-  using void_t = typename void_t_<T...>::type;
-
-  template <template <typename ...> class, typename, typename ...>
-  struct is_detected_{
-    using type = std::false_type;
-  };
-
-  template <template <typename ...> class D, typename ... Ts>
-  struct is_detected_<D, void_t<D<Ts...>>, Ts...>
-  {
-    using type = std::true_type;
-  };
-
-  template <template <typename ...> class D, typename ... Ts>
-  using is_detected = typename is_detected_<D, void, Ts...>::type;
-
-# if (TROMPELOEIL_CPLUSPLUS == 201103L)
-
-  namespace detail
-  {
-    template <typename T>
-    struct unwrap_type
-    {
-      using type = T;
-    };
-    template <typename T>
-    struct unwrap_type<std::reference_wrapper<T>>
-    {
-      using type = T&;
-    };
-    template <typename ... Ts>
-    std::tuple<typename unwrap_type<typename std::decay<Ts>::type>::type...>
-    make_tuple(Ts&& ... ts)
-    {
-      return { std::forward<Ts>(ts)... };
-    }
-
-    /* Implement C++14 features using only C++11 entities. */
-
-    /* <memory> */
-
-    /* Implementation of make_unique is from
-     *
-     * Stephan T. Lavavej, "make_unique (Revision 1),"
-     * ISO/IEC JTC1 SC22 WG21 N3656, 18 April 2013.
-     * Available: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3656.htm
-     * Accessed: 14 June 2017
-     *
-     * Renamed types to avoid the use of reserved identifiers.
-     */
-    template <class T>
-    struct unique_if
-    {
-      typedef std::unique_ptr<T> single_object;
-    };
-
-    template <class T>
-    struct unique_if<T[]>
-    {
-      typedef std::unique_ptr<T[]> unknown_bound;
-    };
-
-    template <class T, size_t N>
-    struct unique_if<T[N]>
-    {
-      typedef void known_bound;
-    };
-
-    template <class T, class... Args>
-    typename unique_if<T>::single_object
-    make_unique(Args&&... args)
-    {
-      return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
-    }
-
-    template <class T>
-    typename unique_if<T>::unknown_bound
-    make_unique(size_t n)
-    {
-      typedef typename std::remove_extent<T>::type U;
-      return std::unique_ptr<T>(new U[n]());
-    }
-
-    template <class T, class... Args>
-    typename unique_if<T>::known_bound
-    make_unique(Args&&...) = delete;
-
-    /* <type_traits> */
-
-    /* The implementation of these is from
-     *
-     * Walter E. Brown, "TransformationTraits Redux, v2,"
-     * ISO/IEC JTC1 SC22 WG21 N3655, 18 April 2013.
-     * Available: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3655.pdf
-     * Accessed: 2 November 2017
-     *
-     * Minor changes to capitalize template parameter `bool B` has been made.
-     *
-     * See also:
-     * http://en.cppreference.com/w/cpp/types/conditional
-     * http://en.cppreference.com/w/cpp/types/decay
-     * http://en.cppreference.com/w/cpp/types/enable_if
-     * http://en.cppreference.com/w/cpp/types/remove_pointer
-     * http://en.cppreference.com/w/cpp/types/remove_reference
-     * Accessed: 17 May 2017
-     */
-    template <bool B, typename T, typename F>
-    using conditional_t = typename std::conditional<B, T, F>::type;
-
-    template <typename T>
-    using decay_t = typename std::decay<T>::type;
-
-    template <bool B, typename T = void>
-    using enable_if_t = typename std::enable_if<B, T>::type;
-
-    template <typename T>
-    using remove_pointer_t = typename std::remove_pointer<T>::type;
-
-    template <typename T>
-    using remove_reference_t = typename std::remove_reference<T>::type;
-
-    /* <utility> */
-
-    /* This implementation of exchange is from
-     *
-     * Jeffrey Yasskin, "exchange() utility function, revision 3,"
-     * ISO/IEC JTC1 SC22 WG21 N3688, 19 April 2013.
-     * Available: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3668.html
-     * Accessed: 2 November 2017
-     *
-     * See also:
-     * http://en.cppreference.com/w/cpp/utility/exchange
-     * Accessed: 17 May 2017
-     */
-    template<class T, class U = T>
-    inline
-    T
-    exchange(
-      T& obj,
-      U&& new_value)
-    {
-      T old_value = std::move(obj);
-      obj = std::forward<U>(new_value);
-      return old_value;
-    }
-
-    /* integer_sequence and index_sequence implementations are from
-     *
-     * Jonathan Wakely, "Compile-time integer sequences,"
-     * ISO/IEC JTC1 SC22 WG21 N3658, 18 April 2013.
-     * Available: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3658.html
-     * Accessed: 2 November 2017
-     *
-     * See also:
-     * http://en.cppreference.com/w/cpp/utility/integer_sequence
-     * Accessed: 17 May 2017
-     */
-    template <typename T, T... I>
-    struct integer_sequence
-    {
-      // Replaces a typedef used in the definition found in N3658.
-      using value_type = T;
-
-      static constexpr size_t size() noexcept
-      {
-          return sizeof...(I);
-      }
-    };
-
-    template <size_t... I>
-    using index_sequence = integer_sequence<size_t, I...>;
-
-    /* This implementation of make_integer_sequence is from boost/mp11,
-     *
-     * Copyright 2015, 2017 Peter Dimov
-     *
-     * Distributed under the Boost Software License, Version 1.0.
-     *
-     * Implemented here:
-     *
-     * https://github.com/pdimov/mp11/blob/master/include/boost/
-     *   integer_sequence.hpp
-     * Accessed: 17 May 2017
-     *
-     * (now missing) and here:
-     *
-     * https://github.com/boostorg/mp11/blob/develop/include/boost/
-     *   mp11/integer_sequence.hpp
-     * Accessed: 13 August 2017
-     */
-    namespace impl
-    {
-      // iseq_if_c
-      template <bool C, class T, class E>
-      struct iseq_if_c_impl;
-
-      template <class T, class E>
-      struct iseq_if_c_impl<true, T, E>
-      {
-        using type = T;
-      };
-
-      template <class T, class E>
-      struct iseq_if_c_impl<false, T, E>
-      {
-        using type = E;
-      };
-
-      template <bool C, class T, class E>
-      using iseq_if_c = typename iseq_if_c_impl<C, T, E>::type;
-
-      // iseq_identity
-      template <class T>
-      struct iseq_identity
-      {
-        using type = T;
-      };
-
-      template <class S1, class S2>
-      struct append_integer_sequence;
-
-      template <class T, T... I, T... J>
-      struct append_integer_sequence<integer_sequence<T, I...>, integer_sequence<T, J...>>
-      {
-        using type = integer_sequence<T, I..., ( J + sizeof...(I) )...>;
-      };
-
-      template <class T, T N>
-      struct make_integer_sequence_impl;
-
-      template <class T, T N>
-      struct make_integer_sequence_impl_
-      {
-      private:
-
-        static_assert( N >= 0, "make_integer_sequence<T, N>: N must not be negative" );
-
-        static T const M = N / 2;
-        static T const R = N % 2;
-
-        using S1 = typename make_integer_sequence_impl<T, M>::type;
-        using S2 = typename append_integer_sequence<S1, S1>::type;
-        using S3 = typename make_integer_sequence_impl<T, R>::type;
-        using S4 = typename append_integer_sequence<S2, S3>::type;
-
-      public:
-
-        using type = S4;
-      };
-
-      template <class T, T N>
-      struct make_integer_sequence_impl:
-        iseq_if_c<N == 0,
-          iseq_identity<integer_sequence<T>>,
-          iseq_if_c<N == 1,
-            iseq_identity<integer_sequence<T, 0>>,
-            make_integer_sequence_impl_<T, N>>>
-      {
-      };
-    }
-
-    template<class T, T N>
-    using make_integer_sequence = typename impl::make_integer_sequence_impl<T, N>::type;
-
-    template <size_t N>
-    using make_index_sequence = make_integer_sequence<size_t, N>;
-
-    template <typename... T>
-    using index_sequence_for = make_index_sequence<sizeof...(T)>;
-
-  } /* namespace detail */
-
-# else /* (TROMPELOEIL_CPLUSPLUS == 201103L) */
-
-  /* Only these entities really need to
-   * be available in namespace detail, but
-   * VS 2015 has a problem with this approach.
-   *
-   *  namespace detail {
-   *
-   *  using std::make_unique;
-   *
-   *  using std::conditional_t;
-   *  using std::decay_t;
-   *  using std::enable_if_t;
-   *  using std::remove_pointer_t;
-   *  using std::remove_reference_t;
-   *
-   *  using std::exchange;
-   *  using std::index_sequence;
-   *  using std::index_sequence_for;
-   *  using std::integer_sequence;
-   *  using std::make_index_sequence;
-   *
-   *  }
-   *
-   * Instead, use a namespace alias.
-   */
-  namespace detail = std;
-
-# endif /* !(TROMPELOEIL_CPLUSPLUS == 201103L) */
-
-# if TROMPELOEIL_CPLUSPLUS >= 201703L
-#   if TROMPELOEIL_CLANG && TROMPELOEIL_CLANG_VERSION >= 60000
-
-  // these are mostly added to work around clang++ bugs
-  // https://bugs.llvm.org/show_bug.cgi?id=38033
-  // https://bugs.llvm.org/show_bug.cgi?id=38010
-
-  template <typename T>
-  using move_construct_type = decltype(T(std::declval<T&&>()));
-
-  template <typename T>
-  using copy_construct_type = decltype(T(std::declval<const T&>()));
-
-  template <typename T>
-  using can_move_construct = is_detected<move_construct_type, detail::decay_t<T>>;
-
-  template <typename T>
-  using can_copy_construct = is_detected<copy_construct_type, detail::decay_t<T>>;
-
-#   else
-  template <typename T>
-  using can_move_construct = std::is_move_constructible<T>;
-
-  template <typename T>
-  using can_copy_construct = std::is_copy_constructible<T>;
-#   endif
-
-  template <typename F, typename ... A>
-  using invoke_result_type = decltype(std::declval<F&>()(std::declval<A>()...));
-
-# else
-
-  template <typename T>
-  using can_move_construct = std::is_move_constructible<T>;
-
-  template <typename T>
-  using can_copy_construct = std::is_copy_constructible<T>;
-
-  template <typename F, typename ... A>
-  using invoke_result_type = decltype(std::declval<F&>()(std::declval<A>()...));
-
-# endif
-
-#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
-  template <typename Sig, typename = void>
-  struct is_coroutine : std::false_type {};
-
-  template <typename Sig>
-  struct is_coroutine<Sig, std::void_t<decltype(&std::coroutine_traits<Sig>::promise_type::initial_suspend)>> : std::true_type {};
-
-  template <typename U>
-  struct type_wrapper{
-    template <typename V>
-    static V remove_rvalue_ref(V&&);
-    using type = decltype(remove_rvalue_ref(std::declval<U>()));
-  };
-  template <>
-  struct type_wrapper<void>
-  {
-    using type = void;
-  };
-
-  template <typename T>
-  struct coro_value_type
-  {
-    static auto func()
-    {
-      if constexpr (requires {std::declval<T>().operator co_await();})
-      {
-        return type_wrapper<decltype(std::declval<T>().operator co_await().await_resume())>{};
-      }
-      else
-      {
-        return type_wrapper<decltype(std::declval<T>().await_resume())>{};
-      }
-    }
-    using type = typename decltype(func())::type;
-  };
-
-template <typename T>
-using coro_value_type_t = typename coro_value_type<T>::type;
-
-#endif
-
-  template <typename T>
-  class mini_span
-  {
-  public:
-    mini_span(T* address, size_t size) noexcept : begin_(address), end_(address + size) {}
-    T* begin() const noexcept { return begin_; }
-    T* end() const noexcept { return end_; }
-  private:
-    T* begin_;
-    T* end_;
-  };
-
-  class specialized;
-
-
-#ifndef TROMPELOEIL_CUSTOM_RECURSIVE_MUTEX
-
-  template <typename T = void>
-  unique_lock<std::recursive_mutex> get_lock()
-  {
-    // Ugly hack for lifetime of mutex. The statically allocated
-    // recursive_mutex is intentionally leaked, to ensure that the
-    // mutex is available and valid even if the last use is from
-    // the destructor of a global object in a translation unit
-    // without #include <trompeloeil.hpp>
-
-    alignas(std::recursive_mutex)
-    static char buffer[sizeof(std::recursive_mutex)];
-
-    static auto mutex = new (&buffer) std::recursive_mutex;
-    return unique_lock<std::recursive_mutex>{*mutex};
-  }
-
-#else
-
-  class custom_recursive_mutex {
-  public:
-    virtual ~custom_recursive_mutex() = default;
-    virtual void lock() = 0;
-    virtual void unlock() = 0;
-  };
-
-  // User has to provide an own recursive mutex.
-  std::unique_ptr<custom_recursive_mutex> create_custom_recursive_mutex();
-
-  template <typename T = void>
-  unique_lock<custom_recursive_mutex> get_lock()
-  {
-    static std::unique_ptr<custom_recursive_mutex> mtx =
-        create_custom_recursive_mutex();
-    return unique_lock<custom_recursive_mutex>{*mtx};
-  }
-
-#endif
-
-  template <size_t N, typename T>
-  using conditional_tuple_element
-    = detail::conditional_t<(N < std::tuple_size<T>::value),
-                         typename std::tuple_element<N, T>::type,
-                         int>;
-
-  template <typename T>
-  struct param_list;
-
-  template <typename R, typename ... P>
-  struct param_list<R(P...)>
-  {
-    static size_t constexpr const size = sizeof...(P);
-    template <size_t N>
-    using type = conditional_tuple_element<N, std::tuple<P...>>;
-  };
-
-  template <typename Sig, size_t N>
-  using param_list_t = typename param_list<Sig>::template type<N>;
-
-  class expectation_violation : public std::logic_error
-  {
-  public:
-    using std::logic_error::logic_error;
-  };
-
-  struct location
-  {
-    location()
-    noexcept
-      : file("")
-      , line(0U)
-    {}
-
-    location(
-      char const* file_,
-      unsigned long line_
-    )
-    noexcept
-      : file{file_}
-      , line{line_}
-    {}
-
-    char const *file;
-    unsigned long line;
-
-    friend
-    std::ostream&
-    operator<<(
-      std::ostream& os,
-      const location& loc)
-    {
-      if (loc.line != 0U) os << loc.file << ':' << loc.line;
-      return os;
-    }
-  };
-
-  enum class severity { fatal, nonfatal };
-
-  using reporter_func = std::function<void(severity,
-                                           char const *file,
-                                           unsigned long line,
-                                           std::string const &msg)>;
-
-  using ok_reporter_func = std::function<void(char const *msg)>;
-
-  inline
-  void
-  default_reporter(
-    severity,
-    char const *file,
-    unsigned long line,
-    std::string const &msg)
-  {
-    if (!std::current_exception())
-    {
-      std::stringstream os;
-      os << location{ file, line } << "\n" << msg;
-      throw expectation_violation(os.str());
-    }
-  }
-
-  inline
-  void
-  default_ok_reporter(char const* /*msg*/)
-  {
-    /* OK reporter defaults to doing nothing. */
-  }
-
-  inline
-  reporter_func&
-  reporter_obj()
-  {
-    static reporter_func obj = default_reporter;
-    return obj;
-  }
-
-  inline
-  ok_reporter_func&
-  ok_reporter_obj()
-  {
-    static ok_reporter_func obj = default_ok_reporter;
-    return obj;
-  }
-
-  inline
-  reporter_func
-  set_reporter(
-    reporter_func f)
-  {
-    return detail::exchange(reporter_obj(), std::move(f));
-  }
-
-  inline
-  std::pair<reporter_func, ok_reporter_func>
-  set_reporter(
-    reporter_func rf,
-    ok_reporter_func orf)
-  {
-    return {
-      set_reporter(std::move(rf)),
-      detail::exchange(ok_reporter_obj(), std::move(orf))
-    };
-  }
-
-  class tracer;
-
-  inline
-  tracer*&
-  tracer_obj()
-  noexcept
-  {
-    static tracer* ptr = nullptr;
-    return ptr;
-  }
-
-  inline
-  tracer*
-  set_tracer(
-    tracer* obj)
-  noexcept
-  {
-    // std::exchange would be sane here, but it costs compilation time
-    auto& ptr = tracer_obj();
-    auto rv = ptr;
-    ptr = obj;
-    return rv;
-  }
-
-  class tracer
-  {
-  public:
-    virtual
-    void
-    trace(
-      char const *file,
-      unsigned long line,
-      std::string const &call) = 0;
-  protected:
-    tracer() = default;
-    tracer(tracer const&) = delete;
-    tracer& operator=(tracer const&) = delete;
-    virtual
-    ~tracer()
-    {
-      set_tracer(previous);
-    }
-  private:
-    tracer* previous = set_tracer(this);
-  };
-
-  class stream_tracer : public tracer
-  {
-  public:
-    explicit
-    stream_tracer(
-      std::ostream& stream_)
-      : stream(stream_) {}
-    void
-    trace(
-      char const *file,
-      unsigned long line,
-      std::string const &call)
-      override
-    {
-      stream << location{file, line} << '\n' << call << '\n';
-    }
-  private:
-    std::ostream& stream;
-  };
-
-  class trace_agent;
-
-  template <typename T>
-  struct reporter;
-
-  template <typename T>
-  void
-  send_report(
-    severity s,
-    location loc,
-    std::string const &msg)
-  {
-    reporter<T>::send(s, loc.file, loc.line, msg.c_str());
-  }
-
-  template <typename T>
-  void
-  send_ok_report(
-    std::string const &msg)
-  {
-    reporter<T>::sendOk(msg.c_str());
-  }
-
-  template <typename T>
-  struct reporter
-  {
-    static
-    void
-    send(
-      severity s,
-      char const *file,
-      unsigned long line,
-      char const *msg);
-
-    static
-    void
-    sendOk(
-      char const *msg);
-
-  };
-
-  template <typename T>
-  void reporter<T>::
-    send(
-      severity s,
-      char const *file,
-      unsigned long line,
-      char const *msg)
-    {
-      reporter_obj()(s, file, line, msg);
-    }
-
-  template <typename T>
-  void reporter<T>::
-    sendOk(char const* msg)
-    {
-      ok_reporter_obj()(msg);
-    }
-
-  template <typename ... T>
-  constexpr
-  bool
-  ignore(
-    T const& ...)
-  noexcept
-  {
-    return true;
-  }
-
-  struct illegal_argument
-  {
-    template <bool b = false>
-    constexpr
-    illegal_argument const& operator&() const
-    {
-      static_assert(b, "illegal argument");
-      return *this;
-    }
-
-    template <bool b = false>
-    constexpr
-    illegal_argument const& operator*() const
-    {
-      static_assert(b, "illegal argument");
-      return *this;
-    }
-
-    template <typename T, bool b = false>
-    constexpr
-    illegal_argument const& operator=(T const&) const
-    {
-      static_assert(b, "illegal argument");
-      return *this;
-    }
-
-    template <typename T, bool b = false>
-    constexpr
-    operator T() const
-    {
-      static_assert(b, "illegal argument");
-      return {};
-    }
-  };
-
-  struct matcher { };
-
-  struct wildcard : public matcher
-  {
-    template <typename T>
-    struct wrapper {
-      operator T() {
-        static_assert(std::is_same<T, void>{},
-                      "Getting a value from wildcard is not allowed.\n"
-                      "See https://github.com/rollbear/trompeloeil/issues/270\n"
-                      "and https://github.com/rollbear/trompeloeil/issues/290");
-        return *this;
-      }
-    };
-    template <typename T, typename std::enable_if<!std::is_convertible<wildcard&, T>{}>::type* = nullptr>
-    operator T()
-    {
-      return wrapper<T>{};
-    }
-
-    template <typename T>
-    operator T&&() const
-    {
-#if (!TROMPELOEIL_GCC  || TROMPELOEIL_GCC_VERSION < 60000 || TROMPELOEIL_GCC_VERSION >= 90000) \
-      && (!TROMPELOEIL_CLANG || TROMPELOEIL_CLANG_VERSION >= 40000 || !defined(_LIBCPP_STD_VER) || _LIBCPP_STD_VER != 14)
-      return wrapper<T &&>{};
-#else
-      return *this;
-#endif
-    }
-
-    template <typename T>
-    operator T&() const volatile
-    {
-      return wrapper<T&>{};
-    }
-
-    template <typename T>
-    constexpr
-    bool
-    matches(
-      T const&)
-    const
-    noexcept
-    {
-      return true;
-    }
-  };
-
-  TROMPELOEIL_INLINE_VAR wildcard _{};
-
-template <typename T>
-  using matcher_access = decltype(static_cast<matcher*>(std::declval<typename std::add_pointer<T>::type>()));
-
-  template <typename T>
-  using is_matcher = typename is_detected<matcher_access, T>::type;
-
-  template <typename T>
-  struct typed_matcher : matcher
-  {
-    template <bool b = false>
-    operator T() const {
-        static_assert(b,
-                      "Getting a value from a typed matcher is not allowed.\n"
-                      "See https://github.com/rollbear/trompeloeil/issues/270\n"
-                      "and https://github.com/rollbear/trompeloeil/issues/290");
-        return {};
-    }
-  };
-
-  template <>
-  struct typed_matcher<std::nullptr_t> : matcher
-  {
-    template <typename T,
-              typename = decltype(std::declval<T>() == nullptr)>
-    operator T&&() const
-    {
-      static_assert(std::is_same<T, void>{},
-                    "Getting a value from a typed matcher is not allowed.\n"
-                    "See https://github.com/rollbear/trompeloeil/issues/270\n"
-                    "https://github.com/rollbear/trompeloeil/issues/290");
-      return *this;
-    }
-
-    template <typename T,
-              typename = decltype(std::declval<T>() == nullptr)>
-    operator T&()const volatile
-    {
-      static_assert(std::is_same<T, void>{},
-                    "Getting a value from a typed matcher is not allowed.\n"
-                    "See https://github.com/rollbear/trompeloeil/issues/270\n"
-                    "and https://github.com/rollbear/trompeloeil/issues/290");
-      return *this;
-    }
-
-    template <typename T, typename C>
-    operator T C::*() const
-    {
-      static_assert(std::is_same<C, void>{},
-          "Getting a value from a typed matcher is not allowed.\n"
-          "See https://github.com/rollbear/trompeloeil/issues/270\n"
-          "and https://github.com/rollbear/trompeloeil/issues/290");
-      return *this;
-    }
-  };
-
-  template <typename Pred, typename ... T>
-  class duck_typed_matcher : public matcher
-  {
-  public:
-#if (!TROMPELOEIL_GCC) || \
-    (TROMPELOEIL_GCC && TROMPELOEIL_GCC_VERSION >= 40900)
-
-    // g++ 4.8 gives a "conversion from <T> to <U> is ambiguous" error
-    // if this operator is defined.
-    template <typename V,
-              typename = detail::enable_if_t<!is_matcher<V>{}>,
-              typename = invoke_result_type<Pred, V&&, T...>>
-    operator V&&() const {
-#if !TROMPELOEIL_CLANG || TROMPELOEIL_CLANG_VERSION >= 40000
-      // clang 3.x instantiates the function even when it's only used
-      // for compile time signature checks and never actually called.
-      static_assert(std::is_same<V, void>{},
-                    "Getting a value from a duck typed matcher is not allowed.\n"
-                    "See https://github.com/rollbear/trompeloeil/issues/270\n"
-                    "and https://github.com/rollbear/trompeloeil/issues/290");
-#endif
-      return *this;
-    }
-
-#endif
-
-    template <typename V,
-              typename = detail::enable_if_t<!is_matcher<V>{}>,
-              typename = invoke_result_type<Pred, V&, T...>>
-    operator V&() const volatile
-    {
-      static_assert(std::is_same<V, void>{},
-                    "Getting a value from a duck typed matcher is not allowed.\n"
-                    "See https://github.com/rollbear/trompeloeil/issues/270\n"
-                    "and https://github.com/rollbear/trompeloeil/issues/290");
-
-      return *this;
-    }
-  };
-
-  template <typename T>
-  using ostream_insertion = decltype(std::declval<std::ostream&>() << std::declval<T>());
-
-  template <typename T>
-  using is_output_streamable = std::integral_constant<bool, is_detected<ostream_insertion, T>::value && !std::is_array<T>::value>;
-
-  struct stream_sentry
-  {
-    explicit
-    stream_sentry(
-      std::ostream& os_)
-      : os(os_)
-      , width(os.width(0))
-      , flags(os.flags(std::ios_base::dec | std::ios_base::left))
-      , fill(os.fill(' '))
-      {  }
-      stream_sentry(
-        stream_sentry const&)
-      = delete;
-    ~stream_sentry()
-    {
-      os.flags(flags);
-      os.fill(fill);
-      os.width(width);
-    }
-  private:
-    std::ostream& os;
-    std::streamsize width;
-    std::ios_base::fmtflags flags;
-    char fill;
-  };
-
-  struct indirect_null {
-#if !TROMPELOEIL_CLANG
-    template <
-      typename T,
-      typename = detail::enable_if_t<std::is_convertible<std::nullptr_t, T>::value>
-    >
-    operator T&&() const = delete;
-#endif
-#if TROMPELOEIL_GCC || TROMPELOEIL_MSVC
-
-    template <typename T, typename C, typename ... As>
-    using memfunptr = T (C::*)(As...);
-
-    template <typename T>
-    operator T*() const;
-    template <typename T, typename C>
-    operator T C::*() const;
-    template <typename T, typename C, typename ... As>
-    operator memfunptr<T,C,As...>() const;
-#endif /* TROMPELOEIL_GCC || TROMPELOEIL_MSVC */
-    operator std::nullptr_t() const;
-  };
-
-  template <typename T, typename U>
-  using equality_comparison = decltype((std::declval<T const&>() == std::declval<U const&>())
-                                       ? true
-                                       : false);
-
-  template <typename T, typename U>
-  using is_equal_comparable = is_detected<equality_comparison, T, U>;
-
-#if defined(_MSC_VER) && (_MSC_VER < 1910)
-  template <typename T>
-  using is_null_comparable = is_equal_comparable<T, std::nullptr_t>;
-#else
-  template <typename T>
-  using is_null_comparable = is_equal_comparable<T, indirect_null>;
-#endif
-
-  template <typename T, typename = decltype(std::declval<T const&>() == nullptr)>
-  constexpr
-  auto
-  is_null_redirect(
-    T const &t)
-  noexcept(noexcept(std::declval<T const&>() == nullptr))
-  -> decltype(t == nullptr)
-  {
-    return t == nullptr;
-  }
-
-  template <typename T>
-  constexpr
-  auto
-  is_null(
-    T const &t,
-    std::true_type)
-  noexcept(noexcept(is_null_redirect(t)))
-  -> decltype(is_null_redirect(t))
-  {
-    // Redirect evaluation to suppress wrong non-null warnings in g++ 9 and 10.
-    return is_null_redirect(t);
-  }
-
-  template <typename T, typename V>
-  constexpr
-  bool
-  is_null(
-    T const &,
-    V)
-  noexcept
-  {
-    return false;
-  }
-
-  template <typename T>
-  constexpr
-  bool
-  is_null(
-    T const &,
-    std::false_type)
-  noexcept
-  {
-    return false;
-  }
-
-  template <typename T>
-  constexpr
-  bool
-  is_null(
-    T const &t)
-  {
-    // g++-4.9 uses C++11 rules for constexpr function, so can't
-    // break this up into smaller bits
-    using tag = std::integral_constant<bool, is_null_comparable<T>::value
-                                       && !is_matcher<T>::value
-                                       && !std::is_array<T>::value>;
-
-    return ::trompeloeil::is_null(t, tag{});
-  }
-
-  template <typename T>
-  void
-  print(
-    std::ostream& os,
-    T const &t);
-
-  template <typename T>
-  using iterable = decltype(std::begin(std::declval<T&>()) == std::end(std::declval<T&>()));
-
-  template <typename T>
-  using is_collection = is_detected<iterable, T>;
-
-  template <typename T,
-            bool = is_output_streamable<const T>::value,
-            bool = is_collection<const detail::remove_reference_t<T>>::value>
-  struct streamer
-  {
-    static
-    void
-    print(
-      std::ostream& os,
-      T const &t)
-    {
-      stream_sentry s(os);
-      os << t;
-    }
-  };
-
-  template <typename ... T>
-  struct streamer<std::tuple<T...>, false, false>
-  {
-    static
-    void
-    print(
-      std::ostream& os,
-      std::tuple<T...> const&  t)
-    {
-      print_tuple(os, t, detail::index_sequence_for<T...>{});
-    }
-    template <size_t ... I>
-    static
-    void
-    print_tuple(
-      std::ostream& os,
-      std::tuple<T...> const& t,
-      detail::index_sequence<I...>)
-    {
-      os << "{ ";
-      const char* sep = "";
-      std::initializer_list<const char*> v{((os << sep),
-                                            ::trompeloeil::print(os, std::get<I>(t)),
-                                            (sep = ", "))...};
-      ignore(v);
-      os << " }";
-    }
-  };
-
-  template <typename T, typename U>
-  struct streamer<std::pair<T, U>, false, false>
-  {
-    static
-    void
-    print(
-      std::ostream& os,
-      std::pair<T, U> const& t)
-    {
-      os << "{ ";
-      ::trompeloeil::print(os, t.first);
-      os << ", ";
-      ::trompeloeil::print(os, t.second);
-      os << " }";
-    }
-  };
-
-  template <typename T>
-  struct streamer<T, false, true>
-  {
-    static
-    void
-    print(
-      std::ostream& os,
-      T const& t)
-    {
-      os << "{ ";
-      const char* sep = "";
-      using element_type = decltype(*std::begin(t));
-      std::for_each(std::begin(t), std::end(t),
-                    [&os, &sep](element_type element) {
-                      os << sep;
-                      ::trompeloeil::print(os, element);
-                      sep = ", ";
-                    });
-      os << " }";
-    }
-  };
-
-  inline void hexdump(const void* begin, size_t size, std::ostream& os)
-  {
-    stream_sentry s(os);
-    os << size << "-byte object={";
-    if (size > 8)
-    {
-      os << '\n';
-    }
-    os << std::setfill('0') << std::hex;
-    mini_span<uint8_t const> bytes(static_cast<uint8_t const*>(begin), size);
-    size_t byte_number = 0;
-    std::for_each(bytes.begin(), bytes.end(),  [&os, &byte_number](unsigned byte) {
-      os << " 0x" << std::setw(2) << std::right << byte;
-      if ((byte_number & 0xf) == 0xf) os << '\n';
-      ++byte_number;
-    });
-    os << " }";
-  }
-
-  template <typename T>
-  struct streamer<T, false, false>
-  {
-    static
-    void
-    print(
-      std::ostream& os,
-      T const &t)
-    {
-      hexdump(&t, sizeof(T), os);
-    }
-  };
-
-  template <typename T, typename = void>
-  struct printer
-  {
-    static
-    void
-    print(
-      std::ostream& os,
-      T const & t)
-    {
-      streamer<T>::print(os, t);
-    }
-  };
-
-  template <>
-  struct printer<wildcard>
-  {
-    static
-    void
-    print(
-    std::ostream& os,
-    wildcard const&)
-    {
-      os << " matching _";
-    }
-  };
-  template <typename T>
-  void
-  print(
-    std::ostream& os,
-    T const &t)
-  {
-    if (is_null(t))
-    {
-      os << "nullptr";
-    }
-    else
-    {
-      printer<T>::print(os, t);
-    }
-  }
-
-  inline
-  void
-  print(
-      std::ostream& os,
-      std::nullptr_t)
-  {
-    os << "nullptr";
-  }
-
-  constexpr
-  auto
-  param_compare_operator(
-    void const*)
-  TROMPELOEIL_TRAILING_RETURN_TYPE(const char*)
-  {
-    return " == ";
-  }
-
-  constexpr
-  auto
-  param_compare_operator(
-    matcher const*)
-  TROMPELOEIL_TRAILING_RETURN_TYPE(const char*)
-  {
-    return "";
-  }
-
-  template <typename T>
-  void
-  print_expectation(
-    std::ostream& os,
-    T const& t)
-  {
-    os << param_compare_operator(&t);
-    print(os, t);
-    os << '\n';
-  }
-
-  template <typename T>
-  class list_elem
-  {
-  public:
-    list_elem(
-      const list_elem&)
-    = delete;
-
-    list_elem(
-      list_elem &&r)
-    noexcept
-    {
-      *this = std::move(r);
-    }
-
-    list_elem&
-    operator=(
-      list_elem &&r)
-    noexcept
-    {
-      if (this != &r)
-      {
-        next = r.next;
-        prev = &r;
-        r.invariant_check();
-
-        next->prev = this;
-        r.next = this;
-
-        TROMPELOEIL_ASSERT(next->prev == this);
-        TROMPELOEIL_ASSERT(prev->next == this);
-
-        r.unlink();
-
-        TROMPELOEIL_ASSERT(!r.is_linked());
-        invariant_check();
-      }
-      return *this;
-    }
-
-    list_elem&
-    operator=(
-      const list_elem&)
-    = delete;
-
-    virtual
-    ~list_elem()
-    {
-      unlink();
-    }
-
-    void
-    unlink()
-    noexcept
-    {
-      invariant_check();
-      auto n = next;
-      auto p = prev;
-      n->prev = p;
-      p->next = n;
-      next = this;
-      prev = this;
-      invariant_check();
-    }
-
-    void
-    invariant_check()
-    const
-    noexcept
-    {
-#ifdef TROMPELOEIL_SANITY_CHECKS
-      TROMPELOEIL_ASSERT(next->prev == this);
-      TROMPELOEIL_ASSERT(prev->next == this);
-      TROMPELOEIL_ASSERT((next == this) == (prev == this));
-      TROMPELOEIL_ASSERT((prev->next == next) == (next == this));
-      TROMPELOEIL_ASSERT((next->prev == prev) == (prev == this));
-      auto pp = prev;
-      auto nn = next;
-      do {
-        TROMPELOEIL_ASSERT((nn == this) == (pp == this));
-        TROMPELOEIL_ASSERT(nn->next->prev == nn);
-        TROMPELOEIL_ASSERT(nn->prev->next == nn);
-        TROMPELOEIL_ASSERT(pp->next->prev == pp);
-        TROMPELOEIL_ASSERT(pp->prev->next == pp);
-        TROMPELOEIL_ASSERT((nn->next == nn) == (nn == this));
-        TROMPELOEIL_ASSERT((pp->prev == pp) == (pp == this));
-        nn = nn->next;
-        pp = pp->prev;
-      } while (nn != this);
-#endif
-    }
-
-    bool
-    is_linked()
-    const
-    noexcept
-    {
-      invariant_check();
-      return next != this;
-    }
-  protected:
-    list_elem() noexcept = default;
-  public:
-    list_elem* next = this;
-    list_elem* prev = this;
-  };
-
-  class ignore_disposer
-  {
-  protected:
-    template <typename T>
-    TROMPELOEIL_NORETURN
-    void
-    dispose(
-      T*)
-    const
-    noexcept
-    {
-      std::abort(); // must never be called
-    }
-  };
-
-  class delete_disposer
-  {
-  protected:
-    template <typename T>
-    void
-    dispose(
-      T* t)
-    const
-    {
-      delete t;
-    }
-  };
-
-  template <typename T, typename Disposer = ignore_disposer>
-  class list : private list_elem<T>, private Disposer
-  {
-  public:
-    list() noexcept;
-    list(list&&) noexcept;
-    list(const list&) = delete;
-    list& operator=(list&&) noexcept;
-    list& operator=(const list&) = delete;
-    ~list() override;
-    class iterator;
-    iterator begin() const noexcept;
-    iterator end() const noexcept;
-    iterator push_front(T* t) noexcept;
-    iterator push_back(T* t) noexcept;
-    bool empty() const noexcept { return begin() == end(); }
-  private:
-    using list_elem<T>::invariant_check;
-    using list_elem<T>::next;
-    using list_elem<T>::prev;
-  };
-
-  template <typename T, typename Disposer>
-  class list<T, Disposer>::iterator
-  {
-    friend class list<T, Disposer>;
-    using iterator_category = std::bidirectional_iterator_tag;
-    using value_type = T;
-    using difference_type = std::ptrdiff_t;
-    using pointer = T*;
-    using reference = T&;
-  public:
-    friend
-    bool
-    operator==(
-      iterator const &lh,
-      iterator const &rh)
-    noexcept
-    {
-      return lh.p == rh.p;
-    }
-
-    friend
-    bool
-    operator!=(
-      iterator const &lh,
-      iterator const &rh)
-    noexcept
-    {
-      return !(lh == rh);
-    }
-
-    iterator&
-    operator++()
-    noexcept
-    {
-      p = p->next;
-      return *this;
-    }
-
-    iterator
-    operator++(int)
-    noexcept
-    {
-      auto rv = *this;
-      operator++();
-      return rv;
-    }
-
-    T&
-    operator*()
-    noexcept
-    {
-      return static_cast<T&>(*p);
-    }
-
-    T*
-    operator->()
-    noexcept
-    {
-      return static_cast<T*>(p);
-    }
-
-  private:
-    explicit
-    iterator(
-      list_elem<T> const *t)
-    noexcept
-    : p{const_cast<list_elem<T>*>(t)}
-    {}
-
-    list_elem<T>* p = nullptr;
-  };
-
-  template <typename T, typename Disposer>
-  list<T, Disposer>::list() noexcept = default;
-
-  template <typename T, typename Disposer>
-  list<T, Disposer>::list(list&&) noexcept = default;
-
-  template <typename T, typename Disposer>
-  list<T, Disposer>& list<T, Disposer>::operator=(list&&) noexcept = default;
-
-  template <typename T, typename Disposer>
-  list<T, Disposer>::~list()
-  {
-    auto i = this->begin();
-    while (i != this->end())
-    {
-      auto& elem = *i;
-      ++i; // intrusive list, so advance before destroying
-      Disposer::dispose(&elem);
-    }
-  }
-
-  template <typename T, typename Disposer>
-  auto
-  list<T, Disposer>::begin()
-  const
-  noexcept
-  -> iterator
-  {
-    return iterator{next};
-  }
-
-  template <typename T, typename Disposer>
-  auto
-  list<T, Disposer>::end()
-  const
-  noexcept
-  -> iterator
-  {
-    return iterator{this};
-  }
-
-  template <typename T, typename Disposer>
-  auto
-  list<T, Disposer>::push_front(
-    T* t)
-  noexcept
-  -> iterator
-  {
-    invariant_check();
-    t->next = next;
-    t->prev = this;
-    next->prev = t;
-    next = t;
-    invariant_check();
-    return iterator{t};
-  }
-
-  template <typename T, typename Disposer>
-  auto
-  list<T, Disposer>::push_back(
-    T* t)
-  noexcept
-  -> iterator
-  {
-    invariant_check();
-    t->prev = prev;
-    t->next = this;
-    prev->next = t;
-    prev = t;
-    invariant_check();
-    return iterator{t};
-  }
-
-  class sequence_matcher;
-
-  class sequence_type
-  {
-  public:
-    sequence_type() noexcept = default;
-    sequence_type(sequence_type&&) noexcept = delete;
-    sequence_type(const sequence_type&) = delete;
-    sequence_type& operator=(sequence_type&&) noexcept = delete;
-    sequence_type& operator=(const sequence_type&) = delete;
-    ~sequence_type();
-
-    bool
-    is_completed()
-    const
-    noexcept;
-
-    bool
-    is_first(
-      sequence_matcher const *m)
-    const
-    noexcept;
-
-    unsigned
-    cost(
-      sequence_matcher const *m)
-    const
-    noexcept;
-
-    void
-    retire_until(
-      sequence_matcher const* m)
-    noexcept;
-
-    void
-    add_last(
-      sequence_matcher *m)
-    noexcept;
-
-    void
-    validate_match(
-      severity s,
-      sequence_matcher const *matcher,
-      char const *seq_name,
-      char const *match_name,
-      location loc)
-    const;
-
-  private:
-    list<sequence_matcher> matchers;
-  };
-
-  class sequence
-  {
-  public:
-    sequence_type& operator*() { return *obj; }
-    bool is_completed() const { return obj->is_completed(); }
-  private:
-    std::unique_ptr<sequence_type> obj{detail::make_unique<sequence_type>()};
-  };
-
-  struct sequence_handler_base;
-
-  class sequence_matcher : public list_elem<sequence_matcher>
-  {
-  public:
-    using init_type = std::pair<char const*, sequence&>;
-
-    sequence_matcher(
-      char const *exp,
-      location loc,
-      const sequence_handler_base& handler,
-      init_type i)
-    noexcept
-    : seq_name(i.first)
-    , exp_name(exp)
-    , exp_loc(loc)
-    , sequence_handler(handler)
-    , seq(*i.second)
-    {
-      auto lock = get_lock();
-      seq.add_last(this);
-    }
-
-    void
-    validate_match(
-      severity s,
-      char const *match_name,
-      location loc)
-    const
-    {
-      seq.validate_match(s, this, seq_name, match_name, loc);
-    }
-
-    unsigned
-    cost()
-    const
-    noexcept
-    {
-      return seq.cost(this);
-    }
-
-    bool
-    is_satisfied()
-      const
-      noexcept;
-
-    bool
-    is_optional()
-      const
-      noexcept;
-
-    void
-    retire()
-    noexcept
-    {
-      this->unlink();
-    }
-
-    void
-    retire_predecessors()
-    noexcept
-    {
-      seq.retire_until(this);
-    }
-
-    void
-    print_expectation(std::ostream& os)
-    const
-    {
-      os << exp_name << " at " << exp_loc;
-    }
-
-    char const*
-    sequence_name()
-    const
-    noexcept
-    {
-      return seq_name;
-    }
-  private:
-    char const *seq_name;
-    char const *exp_name;
-    location    exp_loc;
-    const sequence_handler_base& sequence_handler;
-    sequence_type& seq;
-  };
-
-  inline
-  bool
-  sequence_type::is_completed()
-  const
-  noexcept
-  {
-    for (const auto& matcher : matchers)
-    {
-      if (!matcher.is_satisfied())
-      {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  inline
-  bool
-  sequence_type::is_first(
-    sequence_matcher const *m)
-  const
-  noexcept
-  {
-    return !matchers.empty() && &*matchers.begin() == m;
-  }
-
-  inline
-  unsigned
-  sequence_type::cost(
-    sequence_matcher const* m)
-  const
-  noexcept
-  {
-    unsigned sequence_cost = 0U;
-    for (auto const& e : matchers)
-    {
-      if (&e == m) return sequence_cost;
-      if (!e.is_satisfied())
-      {
-        return ~0U;
-      }
-      ++sequence_cost;
-    }
-    return ~0U;
-  }
-
-  inline
-  void
-  sequence_type::retire_until(
-    sequence_matcher const* m)
-  noexcept
-  {
-    while (!matchers.empty())
-    {
-      auto first = &*matchers.begin();
-      if (first == m) return;
-      first->retire();
-    }
-  }
-
-  inline
-  void
-  sequence_type::validate_match(
-    severity s,
-    sequence_matcher const *matcher,
-    char const* seq_name,
-    char const* match_name,
-    location loc)
-  const
-  {
-    if (is_first(matcher)) return;
-    if (matchers.empty())
-    {
-      std::ostringstream os;
-      os << "Sequence mismatch for sequence \"" << seq_name
-         << "\" with matching call of " << match_name
-         << " at " << loc
-         << ". Sequence \"" << seq_name
-         << "\" has no more pending expectations\n";
-      send_report<specialized>(s, loc, os.str());
-    }
-    bool first = true;
-    std::ostringstream os;
-    os << "Sequence mismatch for sequence \"" << seq_name
-       << "\" with matching call of " << match_name
-       << " at " << loc << ".\n";
-    for (auto const& m : matchers)
-    {
-      if (first || !m.is_optional())
-      {
-        if (first)
-        {
-          os << "Sequence \"" << seq_name << "\" has ";
-        }
-        else
-        {
-          os << "and has ";
-        }
-        m.print_expectation(os);
-        if (m.is_optional())
-        {
-          os << " first in line\n";
-        }
-        else
-        {
-          os << " as first required expectation\n";
-          break;
-        }
-      }
-      first = false;
-    }
-    send_report<specialized>(s, loc, os.str());
-  }
-
-  inline
-  sequence_type::~sequence_type()
-  {
-    bool touched = false;
-    std::ostringstream os;
-    while (!matchers.empty())
-    {
-      auto m = matchers.begin();
-      if (!touched)
-      {
-        os << "Sequence expectations not met at destruction of sequence object \""
-           << m->sequence_name() << "\":";
-        touched = true;
-      }
-      os << "\n  missing ";
-      m->print_expectation(os);
-      m->unlink();
-    }
-    if (touched)
-    {
-      os << "\n";
-      send_report<specialized>(severity::nonfatal, location{}, os.str());
-    }
-  }
-
-  inline
-  void
-  sequence_type::add_last(
-    sequence_matcher *m)
-  noexcept
-  {
-    matchers.push_back(m);
-  }
-
-  template <typename T>
-  void can_match_parameter(T&);
-
-  template <typename T>
-  void can_match_parameter(T&&);
-
-  template <typename M>
-  class ptr_deref : public matcher
-  {
-  public:
-    template <typename U,
-              typename = decltype(can_match_parameter<detail::remove_reference_t<decltype(*std::declval<U>())>>(std::declval<M>()))>
-    operator U() const;
-
-    template <typename U>
-    explicit
-    ptr_deref(
-      U&& m_)
-      : m( std::forward<U>(m_) )
-    {}
-
-    template <typename U>
-    bool
-    matches(
-      const U& u)
-    const
-    noexcept(noexcept(std::declval<M>().matches(*u)))
-    {
-      return (u != nullptr) && m.matches(*u);
-    }
-
-    friend
-    std::ostream&
-    operator<<(
-      std::ostream& os,
-      ptr_deref<M> const& p)
-    {
-      return os << p.m;
-    }
-  private:
-    M m;
-  };
-
-  template <typename M>
-  class neg_matcher : public matcher
-  {
-  public:
-    template <typename U,
-              typename = decltype(can_match_parameter<detail::remove_reference_t<decltype(std::declval<U>())>>(std::declval<M>()))>
-    operator U() const { return {}; }
-
-    template <typename U>
-    explicit
-    neg_matcher(
-      U&& m_)
-      : m( std::forward<U>(m_) )
-    {}
-
-    template <typename U>
-    bool
-    matches(
-      const U& u)
-    const
-    noexcept(noexcept(!std::declval<M>().matches(u)))
-    {
-      return !m.matches(u);
-    }
-
-    friend
-    std::ostream&
-    operator<<(
-      std::ostream& os,
-      neg_matcher<M> const& p)
-    {
-      return os << p.m;
-    }
-  private:
-    M m;
-  };
-
-  template <typename MatchType, typename Predicate, typename ... ActualType>
-  struct matcher_kind
-  {
-    using type = typed_matcher<MatchType>;
-  };
-
-  template <typename Predicate, typename ... ActualType>
-  struct matcher_kind<wildcard, Predicate, ActualType...>
-  {
-    using type = duck_typed_matcher<Predicate, ActualType...>;
-  };
-
-  template <typename MatchType, typename Predicate, typename ... ActualType>
-  using matcher_kind_t =
-    typename matcher_kind<MatchType, Predicate, ActualType...>::type;
-
-  template <typename Predicate, typename Printer, typename MatcherType, typename ... T>
-  class predicate_matcher
-    : private Predicate
-    , private Printer
-    , public MatcherType
-  {
-  public:
-    template <typename ... U>
-    constexpr
-    predicate_matcher(
-      Predicate&& pred,
-      Printer&& printer,
-      U&& ... v)
-      noexcept(noexcept(std::tuple<T...>(std::declval<U>()...)) && noexcept(Predicate(std::declval<Predicate&&>())) && noexcept(Printer(std::declval<Printer&&>())))
-      : Predicate(std::move(pred))
-      , Printer(std::move(printer))
-      , value(std::forward<U>(v)...)
-    {}
-
-    template <typename V>
-    constexpr
-    bool
-    matches(
-      V&& v)
-      const
-      noexcept(noexcept(std::declval<Predicate const&>()(std::declval<V&&>(), std::declval<const T&>()...)))
-    {
-      return matches_(std::forward<V>(v), detail::make_index_sequence<sizeof...(T)>{});
-    }
-
-    friend
-    std::ostream&
-    operator<<(
-      std::ostream& os,
-      predicate_matcher const& v)
-    {
-      return v.print_(os, detail::make_index_sequence<sizeof...(T)>{});
-    }
-  private:
-    // The below function call operator must be declared to
-    // work around gcc bug 78446
-    //
-    // For some reason microsoft compiler from VS2015 update 3
-    // requires the function call operator to be private to avoid
-    // ambiguities.
-    template <typename ... U>
-    void operator()(U&&...) const = delete;
-
-    template <typename V, size_t ... I>
-    bool matches_(V&& v, detail::index_sequence<I...>) const
-    {
-      return Predicate::operator()(std::forward<V>(v), std::get<I>(value)...);
-    }
-
-    template <size_t ... I>
-    std::ostream& print_(std::ostream& os_, detail::index_sequence<I...>) const
-    {
-      Printer::operator()(os_, std::get<I>(value)...);
-      return os_;
-    }
-
-    std::tuple<T...> value;
-  };
-
-  template <typename MatchType, typename Predicate, typename Printer, typename ... T>
-  using make_matcher_return =
-    predicate_matcher<Predicate,
-      Printer,
-      matcher_kind_t<MatchType, Predicate, detail::decay_t<T>...>,
-      detail::decay_t<T>...>;
-
-  namespace lambdas {
-
-    struct any_predicate
-    {
-      template <typename T>
-      bool
-      operator()(
-        T&&)
-      const
-      {
-        return true;
-      }
-    };
-
-    // The below must be classes/structs to work with VS 2015 update 3
-    // since it doesn't respect the trailing return type declaration on
-    // the lambdas of template deduction context
-
-#define TROMPELOEIL_MK_PRED_BINOP(name, op)                         \
-    struct name {                                                       \
-      template <typename X, typename Y>                                 \
-      auto operator()(X const& x, Y const& y) const -> decltype(x op y) \
-      {                                                                 \
-        ::trompeloeil::ignore(x,y);                                     \
-        return x op y;                                                  \
-      }                                                                 \
-    }
-    TROMPELOEIL_MK_PRED_BINOP(equal, ==);
-    TROMPELOEIL_MK_PRED_BINOP(not_equal, !=);
-    TROMPELOEIL_MK_PRED_BINOP(less, <);
-    TROMPELOEIL_MK_PRED_BINOP(less_equal, <=);
-    TROMPELOEIL_MK_PRED_BINOP(greater, >);
-    TROMPELOEIL_MK_PRED_BINOP(greater_equal, >=);
-#undef TROMPELOEIL_MK_PRED_BINOP
-
-    // Define `struct` with `operator()` to replace generic lambdas.
-
-    struct any_printer
-    {
-      explicit
-      any_printer(
-        char const* type_name_)
-        : type_name(type_name_)
-      {}
-
-      void
-      operator()(
-        std::ostream& os)
-      const
-      {
-        os << " matching ANY(" << type_name << ")";
-      }
-
-    private:
-      char const* type_name;
-    };
-
-    // These structures replace the `op` printer lambdas.
-
-#define TROMPELOEIL_MK_OP_PRINTER(name, op_string)                  \
-    struct name ## _printer                                             \
-    {                                                                   \
-      template <typename T>                                             \
-      void                                                              \
-      operator()(                                                       \
-        std::ostream& os,                                               \
-        T const& value)                                                 \
-      const                                                             \
-      {                                                                 \
-        os << op_string;                                                \
-        ::trompeloeil::print(os, value);                                \
-      }                                                                 \
-    }
-    TROMPELOEIL_MK_OP_PRINTER(equal, " == ");
-    TROMPELOEIL_MK_OP_PRINTER(not_equal, " != ");
-    TROMPELOEIL_MK_OP_PRINTER(less, " < ");
-    TROMPELOEIL_MK_OP_PRINTER(less_equal, " <= ");
-    TROMPELOEIL_MK_OP_PRINTER(greater, " > ");
-    TROMPELOEIL_MK_OP_PRINTER(greater_equal, " >= ");
-#undef TROMPELOEIL_MK_OP_PRINTER
-
-  }
-
-  template <typename MatchType, typename Predicate, typename Printer, typename ... T>
-  inline
-  make_matcher_return<MatchType, Predicate, Printer, T...>
-  make_matcher(Predicate pred, Printer print, T&& ... t)
-  {
-    return {std::move(pred), std::move(print), std::forward<T>(t)...};
-  }
-
-
-  template <
-    typename T,
-    typename R = make_matcher_return<T, lambdas::any_predicate, lambdas::any_printer>>
-  inline
-  auto
-  any_matcher_impl(char const* type_name, std::false_type)
-  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
-  {
-    return make_matcher<T>(lambdas::any_predicate(), lambdas::any_printer(type_name));
-  }
-
-  template <typename T>
-  wildcard
-  any_matcher_impl(char const*, std::true_type);
-
-  template <typename T>
-  inline
-  auto
-  any_matcher(char const* name)
-  TROMPELOEIL_TRAILING_RETURN_TYPE(decltype(any_matcher_impl<T>(name, std::is_array<T>{})))
-  {
-    static_assert(!std::is_array<T>::value,
-                  "array parameter type decays to pointer type for ANY()"
-                  " matcher. Please rephrase as pointer instead");
-    return any_matcher_impl<T>(name, std::is_array<T>{});
-  }
-  template <
-    typename T = wildcard,
-    typename V,
-    typename R = make_matcher_return<T, lambdas::equal, lambdas::equal_printer, V>>
-  inline
-  auto
-  eq(
-    V&& v)
-  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
-  {
-    return make_matcher<T>(lambdas::equal(),
-                           lambdas::equal_printer(),
-                           std::forward<V>(v));
-  }
-
-  template <
-    typename T = wildcard,
-    typename V,
-    typename R = make_matcher_return<T, lambdas::not_equal, lambdas::not_equal_printer, V>>
-  inline
-  auto
-  ne(
-    V&& v)
-  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
-  {
-    return make_matcher<T>(lambdas::not_equal(),
-                           lambdas::not_equal_printer(),
-                           std::forward<V>(v));
-  }
-
-  template <
-    typename T = wildcard,
-    typename V,
-    typename R = make_matcher_return<T, lambdas::greater_equal, lambdas::greater_equal_printer, V>>
-  inline
-  auto
-  ge(
-    V&& v)
-  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
-  {
-    return make_matcher<T>(lambdas::greater_equal(),
-                           lambdas::greater_equal_printer(),
-                           std::forward<V>(v));
-  }
-
-  template <
-    typename T = wildcard,
-    typename V,
-    typename R = make_matcher_return<T, lambdas::greater, lambdas::greater_printer, V>>
-  inline
-  auto
-  gt(
-    V&& v)
-  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
-  {
-    return make_matcher<T>(lambdas::greater(),
-                           lambdas::greater_printer(),
-                           std::forward<V>(v));
-  }
-
-  template <
-    typename T = wildcard,
-    typename V,
-    typename R = make_matcher_return<T, lambdas::less, lambdas::less_printer, V>>
-  inline
-  auto
-  lt(
-    V&& v)
-  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
-  {
-    return make_matcher<T>(lambdas::less(),
-                           lambdas::less_printer(),
-                           std::forward<V>(v));
-  }
-
-  template <
-    typename T = wildcard,
-    typename V,
-    typename R = make_matcher_return<T, lambdas::less_equal, lambdas::less_equal_printer,  V>>
-  inline
-  auto
-  le(
-    V&& v)
-  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
-  {
-    return make_matcher<T>(lambdas::less_equal(),
-                           lambdas::less_equal_printer(),
-                           std::forward<V>(v));
-  }
-
-  namespace lambdas {
-
-    struct regex_check
-    {
-
-      class string_helper // a vastly simplified string_view type of class
-      {
-      public:
-        template <
-          typename S,
-          typename = decltype(std::declval<const char*&>() = std::declval<S>().data()),
-          typename = decltype(std::declval<S>().length())
-            >
-        string_helper(
-          const S& s)
-        noexcept
-          : begin_(s.data())
-          , end_(begin_ + s.length())
-        {}
-
-        constexpr
-        string_helper(
-          char const* s)
-        noexcept
-          : begin_(s)
-          , end_(s ? begin_ + strlen(s) : nullptr)
-        {
-        }
-
-        constexpr
-        explicit
-        operator bool() const
-        {
-          return begin_;
-        }
-        constexpr
-        char const *
-        begin()
-          const
-        {
-          return begin_;
-        }
-        constexpr
-        char const *
-        end()
-          const
-        {
-          return end_;
-        }
-      private:
-        char const* begin_;
-        char const* end_;
-      };
-
-      regex_check(
-        std::regex&& re_,
-        std::regex_constants::match_flag_type match_type_)
-        : re(std::move(re_)),
-          match_type(match_type_)
-      {}
-
-      template <typename T>
-      bool
-      operator()(
-        string_helper str,
-        T const&)
-      const
-      {
-        return str && std::regex_search(str.begin(), str.end(), re, match_type);
-      }
-
-    private:
-      std::regex re;
-      std::regex_constants::match_flag_type match_type;
-    };
-
-    struct regex_printer
-    {
-      template <typename T>
-      void
-      operator()(
-        std::ostream& os,
-        T const& str)
-      const
-      {
-        os << " matching regular expression /" << str << "/";
-      }
-    };
-  }
-
-  template <
-    typename Kind = wildcard,
-    typename R = make_matcher_return<Kind, lambdas::regex_check, lambdas::regex_printer, std::string&&>>
-  auto
-  re(
-    std::string s,
-    std::regex_constants::syntax_option_type opt = std::regex_constants::ECMAScript,
-    std::regex_constants::match_flag_type match_type = std::regex_constants::match_default)
-  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
-  {
-    return make_matcher<Kind>(lambdas::regex_check(std::regex(s, opt),
-                                                   match_type),
-                              lambdas::regex_printer(),
-                              std::move(s));
-  }
-
-  template <
-    typename Kind = wildcard,
-    typename R = make_matcher_return<Kind, lambdas::regex_check, lambdas::regex_printer, std::string&&>>
-  auto
-  re(
-    std::string s,
-    std::regex_constants::match_flag_type match_type)
-  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
-  {
-    return make_matcher<Kind>(lambdas::regex_check(std::regex(s), match_type),
-                              lambdas::regex_printer(),
-                              std::move(s));
-  }
-
-  inline
-  std::string
-  param_name_prefix(
-    void const*)
-  {
-    return "";
-  }
-
-  template <typename M>
-  std::string
-  param_name_prefix(
-    const ptr_deref<M>*)
-  {
-    return "*" + ::trompeloeil::param_name_prefix(static_cast<M*>(nullptr));
-  }
-
-  template <typename M>
-  std::string
-  param_name_prefix(
-    const neg_matcher<M>*)
-  {
-    return "not " + ::trompeloeil::param_name_prefix(static_cast<M*>(nullptr));
-  }
-
-  template <typename T>
-  struct null_on_move
-  {
-  public:
-    null_on_move()
-    noexcept
-    = default;
-
-    null_on_move(
-      null_on_move&&)
-    noexcept
-    {}
-
-    null_on_move(
-      null_on_move const&)
-    noexcept
-    {}
-
-    ~null_on_move()
-    = default;
-
-    null_on_move&
-    operator=(
-      const null_on_move&)
-    noexcept
-    {
-      p = nullptr;
-      return *this;
-    }
-
-    null_on_move&
-    operator=(
-      null_on_move&&)
-    noexcept
-    {
-      p = nullptr;
-      return *this;
-    }
-
-    null_on_move&
-    operator=(
-      T* t)
-    noexcept
-    {
-      p = t;
-      return *this;
-    }
-
-    T*&
-    leak()
-    noexcept
-    {
-      return p;
-    }
-
-    T&
-    operator*()
-    const
-    noexcept
-    {
-      return *p;
-    }
-
-    T*
-    operator->()
-    const
-    noexcept
-    {
-      return p;
-    }
-
-    explicit
-    operator bool()
-    const
-    noexcept
-    {
-      return p != nullptr;
-    }
-  private:
-    T* p = nullptr;
-  };
-
-  struct sequence_handler_base
-  {
-  private:
-    size_t min_calls{1};
-    size_t max_calls{1};
-    size_t call_count{0};
-  public:
-
-    virtual
-    ~sequence_handler_base()
-    noexcept = default;
-
-    void
-      increment_call()
-      noexcept
-    {
-      ++call_count;
-    }
-    bool
-      is_satisfied()
-      const
-      noexcept
-    {
-      return call_count >= min_calls;
-    }
-
-    bool
-      is_saturated()
-      const
-      noexcept
-    {
-      return call_count == max_calls;
-    }
-
-    bool
-      is_forbidden()
-      const
-      noexcept
-    {
-      return max_calls == 0ULL;
-    }
-
-    void
-    set_limits(size_t L, size_t H)
-      noexcept
-    {
-      min_calls = L;
-      max_calls = H;
-    }
-
-    size_t
-    get_min_calls()
-      const
-      noexcept
-    {
-      return min_calls;
-    }
-
-    size_t
-      get_calls()
-      const
-      noexcept
-    {
-      return call_count;
-    }
-
-    virtual
-    void
-      validate(severity s, char const *, location) = 0;
-
-    virtual
-    bool
-    can_be_called()
-    const
-    noexcept = 0;
-
-    virtual
-    unsigned
-    order()
-    const
-    noexcept = 0;
-
-    virtual
-    void
-      retire()
-      noexcept = 0;
-
-    virtual
-    void
-    retire_predecessors()
-    noexcept = 0;
-  protected:
-    sequence_handler_base() = default;
-    sequence_handler_base(const sequence_handler_base&) = default;
-  };
-
-  inline
-  bool
-  sequence_matcher::is_satisfied()
-  const
-  noexcept
-  {
-    return sequence_handler.is_satisfied();
-  }
-
-  inline
-  bool
-  sequence_matcher::is_optional()
-  const
-  noexcept
-  {
-    return sequence_handler.get_min_calls() == 0;
-  }
-
-  template <size_t N>
-  struct sequence_handler : public sequence_handler_base
-  {
-  public:
-    template <size_t M = N, typename detail::enable_if_t<M == 0>* = nullptr>
-    sequence_handler()
-      noexcept
-    {}
-
-    template <typename ... S>
-    sequence_handler(
-      const sequence_handler_base& base,
-      char const *name,
-      location loc,
-      S&& ... s)
-    noexcept
-      : sequence_handler_base(base)
-      , matchers{{sequence_matcher{name, loc, *this, std::forward<S>(s)}...}}
-    {
-    }
-
-    void
-    validate(
-      severity s,
-      char const *match_name,
-      location loc)
-    override
-    {
-      for (auto& e : matchers)
-      {
-        e.validate_match(s, match_name, loc);
-      }
-    }
-
-    unsigned
-    order()
-    const
-    noexcept
-    override
-    {
-      unsigned highest_order = 0U;
-      for (auto& m : matchers)
-      {
-        auto cost = m.cost();
-        if (cost > highest_order)
-        {
-          highest_order = cost;
-        }
-      }
-      return highest_order;
-    }
-
-    bool
-    can_be_called()
-    const
-    noexcept
-    override
-    {
-      return order() != ~0U;
-    }
-
-    void
-    retire()
-    noexcept
-    override
-    {
-      for (auto& e : matchers)
-      {
-        e.retire();
-      }
-    }
-
-    void
-    retire_predecessors()
-    noexcept
-      override
-    {
-      for (auto& e : matchers)
-      {
-        e.retire_predecessors();
-      }
-    }
-  private:
-    // work around for MS STL issue 942
-    // https://github.com/microsoft/STL/issues/942
-    detail::conditional_t<N == 0,
-                          std::vector<sequence_matcher>,
-                          std::array<sequence_matcher, N>> matchers;
-  };
-
-  struct lifetime_monitor;
-
-  template <typename T>
-  class deathwatched : public T
-  {
-    static_assert(std::has_virtual_destructor<T>::value,
-                  "virtual destructor is a necessity for deathwatched to work");
-  public:
-    template <typename ... U,
-              typename = detail::enable_if_t<std::is_constructible<T,U...>::value>>
-    deathwatched(
-      U&& ...u)
-    noexcept(noexcept(T(std::declval<U>()...)))
-      : T(std::forward<U>(u)...)
-    {}
-
-    ~deathwatched() override;
-
-    trompeloeil::lifetime_monitor*&
-    trompeloeil_expect_death(
-      trompeloeil::lifetime_monitor* monitor)
-    const
-    noexcept
-    {
-      auto lock = get_lock();
-      trompeloeil_lifetime_monitor = monitor;
-      return trompeloeil_lifetime_monitor.leak();
-    }
-  private:
-    mutable null_on_move<trompeloeil::lifetime_monitor> trompeloeil_lifetime_monitor;
-  };
-
-  struct expectation {
-    virtual ~expectation() = default;
-    virtual bool is_satisfied() const noexcept = 0;
-    virtual bool is_saturated() const noexcept = 0;
-  };
-
-  struct lifetime_monitor : public expectation
-  {
-    template <typename T>
-    lifetime_monitor(
-      ::trompeloeil::deathwatched<T> const &obj,
-      char const* obj_name_,
-      char const* invocation_name_,
-      char const* call_name_,
-      location loc_)
-    noexcept
-      : object_monitor(obj.trompeloeil_expect_death(this))
-      , loc(loc_)
-      , object_name(obj_name_)
-      , invocation_name(invocation_name_)
-      , call_name(call_name_)
-    {
-    }
-
-    bool is_satisfied() const noexcept override
-    {
-      return died;
-    }
-
-    bool is_saturated() const noexcept override
-    {
-      return died;
-    }
-
-    lifetime_monitor(lifetime_monitor const&) = delete;
-
-    ~lifetime_monitor() override
-    {
-      auto lock = get_lock();
-      if (!died)
-      {
-        std::ostringstream os;
-        os << "Object " << object_name << " is still alive";
-        send_report<specialized>(severity::nonfatal, loc, os.str());
-        object_monitor = nullptr; // prevent its death poking this cadaver
-      }
-    }
-
-    void
-    notify()
-    noexcept
-    {
-      died = true;
-      sequences->validate(severity::nonfatal, call_name, loc);
-
-      sequences->increment_call();
-      if (sequences->is_satisfied())
-      {
-        sequences->retire_predecessors();
-      }
-    }
-
-    template <typename ... T>
-    void
-    set_sequence(
-      T&& ... t)
-    {
-      using handler = sequence_handler<sizeof...(T)>;
-      auto seq = detail::make_unique<handler>(*sequences,
-                                              invocation_name,
-                                              loc,
-                                              std::forward<T>(t)...);
-      sequences = std::move(seq);
-    }
-  private:
-    atomic<bool>       died{false};
-    lifetime_monitor *&object_monitor;
-    location           loc;
-    char const        *object_name;
-    char const        *invocation_name;
-    char const        *call_name;
-    std::unique_ptr<sequence_handler_base>  sequences = detail::make_unique<sequence_handler<0>>();
-  };
-
-  template <typename T>
-  deathwatched<T>::~deathwatched()
-  {
-    auto lock = get_lock();
-    if (trompeloeil_lifetime_monitor)
-    {
-      trompeloeil_lifetime_monitor->notify();
-      return;
-    }
-    std::ostringstream os;
-    os << "Unexpected destruction of "
-       << TROMPELOEIL_TYPE_ID_NAME(T) << "@" << this << '\n';
-    send_report<specialized>(severity::nonfatal,
-                             location{},
-                             os.str());
-  }
-
-  template <typename T>
-  struct return_of;
-
-  template <typename R, typename ... A>
-  struct return_of<R(A...)>
-  {
-    using type = R;
-  };
-
-  template <typename T>
-  using return_of_t = typename return_of<T>::type;
-
-  template <typename T>
-  struct call_params_type;
-
-  template <typename R, typename ... T>
-  struct call_params_type<R(T...)>
-  {
-    using type = std::tuple<typename std::add_lvalue_reference<T>::type...>;
-  };
-
-  template <typename T>
-  using call_params_type_t = typename call_params_type<T>::type;
-
-
-  template <typename R>
-  struct default_return_t
-  {
-    TROMPELOEIL_NORETURN static R value()
-    {
-      std::abort(); // must never be called
-    }
-  };
-
-#if TROMPELOEIL_MSVC
-#pragma warning(push)
-#pragma warning(disable : 4702)
-#endif
-  template <typename R>
-  inline
-  R
-  default_return()
-  {
-    return default_return_t<R>::value();
-  }
-#if TROMPELOEIL_MSVC
-#pragma warning(pop)
-#endif
-
-
-
-  template <>
-  inline
-  void
-  default_return<void>()
-  {
-    // Implicitly do nothing when returning from function returning void
-  }
-
-  template <typename Sig>
-  struct call_matcher_base;
-
-  template <typename Sig>
-  struct call_matcher_list : public list<call_matcher_base<Sig>>
-  {
-    void decommission()
-    {
-      auto lock = get_lock();
-      auto iter = this->begin();
-      auto const e = this->end();
-      while (iter != e)
-      {
-        auto &m = *iter;
-        ++iter; // intrusive list, so must advance to next before destroying
-        m.mock_destroyed();
-        m.unlink();
-      }
-    }
-  };
-
-  template <typename Sig>
-  struct call_matcher_base : public list_elem<call_matcher_base<Sig>>
-  {
-    using sig = Sig;
-    call_matcher_base(
-      location loc_,
-      char const* name_)
-    : loc{loc_}
-    , name{name_}
-    {
-    }
-
-    call_matcher_base(call_matcher_base&&) = delete;
-
-    ~call_matcher_base() override = default;
-
-    virtual
-    void
-    mock_destroyed() = 0;
-
-    virtual
-    bool
-    matches(
-      call_params_type_t<Sig> const&)
-    const = 0;
-
-    virtual
-    unsigned
-    sequence_cost()
-    const
-    noexcept = 0;
-
-    virtual
-    void
-    run_actions(
-      call_params_type_t<Sig> &,
-      call_matcher_list<Sig> &saturated_list
-    ) = 0;
-
-    virtual
-    std::ostream&
-    report_signature(
-      std::ostream&)
-    const = 0;
-
-    TROMPELOEIL_NORETURN
-    virtual
-    std::ostream&
-    report_mismatch(
-      std::ostream&,
-      call_params_type_t<Sig> const &) = 0;
-
-    virtual
-    return_of_t<Sig>
-    return_value(
-      trace_agent&,
-      call_params_type_t<Sig>& p) = 0;
-
-    location loc;
-    char const *name;
-  };
-
-  template <typename T, typename U>
-  bool
-  param_matches_impl(
-    T const& t,
-    U const& u,
-    matcher const*)
-  noexcept(noexcept(t.matches(u)))
-  {
-    return t.matches(u);
-  }
-
-  template <typename T,
-            typename U,
-            typename = detail::enable_if_t<is_equal_comparable<T, U>::value>>
-  inline
-  U&
-  identity(
-    U& t)
-  noexcept
-  {
-    return t;
-  }
-
-  template <typename T,
-            typename U,
-            typename = detail::enable_if_t<!is_equal_comparable<T, U>::value>>
-  inline
-  T
-  identity(
-    const U& u)
-  noexcept(noexcept(T(u)))
-  {
-    return u;
-  }
-
-  template <typename T, typename U>
-  bool
-  param_matches_impl(
-    T const& t,
-    U const& u,
-    void const*)
-  noexcept(noexcept(::trompeloeil::identity<U>(t) == u))
-  {
-    return ::trompeloeil::identity<U>(t) == u;
-  }
-
-  template <typename T, typename U>
-  bool
-  param_matches(
-    T const& t,
-    U const& u)
-  noexcept(noexcept(param_matches_impl(t, u, &t)))
-  {
-    return ::trompeloeil::param_matches_impl(t, u, &t);
-  }
-
-  template <size_t ... I, typename T, typename U>
-  bool
-  match_parameters(
-    detail::index_sequence<I...>,
-    T const& t,
-    U const& u)
-    noexcept(noexcept(std::initializer_list<bool>{trompeloeil::param_matches(std::get<I>(t),std::get<I>(u))...}))
-  {
-    bool all_true = true;
-    ::trompeloeil::ignore(t, u); // Kills unmotivated VS2015 warning in the empty case
-    ::trompeloeil::ignore(std::initializer_list<bool>{all_true = all_true && ::trompeloeil::param_matches(std::get<I>(t), std::get<I>(u))...});
-    return all_true;
-  }
-
-  template <typename ... T, typename ... U>
-  bool
-  match_parameters(
-    std::tuple<T...> const& t,
-    std::tuple<U...> const& u)
-  noexcept(noexcept(match_parameters(detail::make_index_sequence<sizeof...(T)>{}, t, u)))
-  {
-    return ::trompeloeil::match_parameters(detail::make_index_sequence<sizeof...(T)>{}, t, u);
-  }
-
-  template <typename V, typename P>
-  void print_mismatch(
-    std::ostream& os,
-    size_t num,
-    V const& v,
-    P const& p)
-  {
-    if (!::trompeloeil::param_matches(v, p))
-    {
-      auto prefix = ::trompeloeil::param_name_prefix(&v) + "_";
-      os << "  Expected " << std::setw((num < 9) ? 2 : 1) << prefix << num+1;
-      ::trompeloeil::print_expectation(os, v);
-    }
-  }
-
-  template <typename ... V, typename ... P, size_t ... I>
-  void print_mismatch(
-    std::ostream& os,
-    detail::index_sequence<I...>,
-    std::tuple<V...> const& v,
-    std::tuple<P...> const& p)
-  {
-    ::trompeloeil::ignore(os, v, p);  // Kills unmotivated VS2015 warning in the empty case
-    ::trompeloeil::ignore(std::initializer_list<int>{(print_mismatch(os, I, std::get<I>(v), std::get<I>(p)),0)...});
-  }
-
-  template <typename ... V, typename ... P>
-  void print_mismatch(
-    std::ostream& os,
-    std::tuple<V...> const& v,
-    std::tuple<P...> const& p)
-  {
-    print_mismatch(os, detail::make_index_sequence<sizeof...(V)>{}, v, p);
-  }
-
-  template <typename T>
-  void missed_value(
-    std::ostream& os,
-    int i,
-    T const& t)
-  {
-    auto prefix = ::trompeloeil::param_name_prefix(&t) + "_";
-    os << "  param " << std::setw((i < 9) ? 2 : 1) << prefix << i + 1
-       << ::trompeloeil::param_compare_operator(&t);
-    ::trompeloeil::print(os, t);
-    os << '\n';
-  }
-
-  template <size_t ... I, typename ... T>
-  void stream_params(
-    std::ostream &os,
-    detail::index_sequence<I...>,
-    std::tuple<T...> const &t)
-  {
-    ::trompeloeil::ignore(os, t);  // Kills unmotivated VS2015 warning in the empty case
-    ::trompeloeil::ignore(std::initializer_list<int>{(missed_value(os, I, std::get<I>(t)),0)...});
-  }
-
-  template <typename ... T>
-  void
-  stream_params(
-    std::ostream &os,
-    std::tuple<T...> const &t)
-  {
-    stream_params(os, detail::make_index_sequence<sizeof...(T)>{}, t);
-  }
-
-  template <typename ... T>
-  std::string
-  params_string(
-    std::tuple<T...> const& t)
-  {
-    std::ostringstream os;
-    stream_params(os, t);
-    return os.str();
-  }
-
-  class trace_agent
-  {
-  public:
-    trace_agent(
-      location loc_,
-      char const* name_,
-      tracer* t_)
-    : loc{loc_}
-    , t{t_}
-    {
-      if (t)
-      {
-        os << name_ << " with.\n";
-      }
-    }
-
-    trace_agent(trace_agent const&) = delete;
-
-    trace_agent(trace_agent &&) = delete;
-
-    ~trace_agent()
-    {
-      if (t)
-      {
-        t->trace(loc.file, loc.line, os.str());
-      }
-    }
-
-    trace_agent&
-    operator=(trace_agent const&) = delete;
-
-    trace_agent&
-    operator=(trace_agent &&) = delete;
-
-    template <typename ... T>
-    void
-    trace_params(
-      std::tuple<T...> const& params)
-    {
-      if (t)
-      {
-        stream_params(os, params);
-      }
-    }
-
-    template <typename T>
-    auto
-    trace_return(
-      T&& rv)
-    -> T
-    {
-      if (t)
-      {
-        os << " -> ";
-        print(os, rv);
-        os << '\n';
-      }
-      return std::forward<T>(rv);
-    }
-
-    void
-    trace_exception()
-    {
-      if (t)
-      {
-        try {
-          throw;
-        }
-        catch (std::exception const& e)
-        {
-          os << "threw exception: what() = " << e.what() << '\n';
-        }
-        catch (...)
-        {
-          os << "threw unknown exception\n";
-        }
-      }
-    }
-  private:
-    location loc;
-    tracer* t;
-    std::ostringstream os;
-  };
-
-  template <typename Sig>
-  call_matcher_base <Sig> *
-  find(
-    call_matcher_list <Sig> &list,
-    call_params_type_t <Sig> const &p)
-  noexcept
-  {
-    call_matcher_base<Sig>* first_match = nullptr;
-    unsigned lowest_cost = ~0U;
-    for (auto& i : list)
-    {
-      if (i.matches(p))
-      {
-        unsigned cost = i.sequence_cost();
-        if (cost == 0)
-        {
-          return &i;
-        }
-        if (!first_match || cost < lowest_cost)
-        {
-          first_match = &i;
-          lowest_cost = cost;
-        }
-      }
-    }
-    return first_match;
-  }
-
-  template <typename Sig>
-  TROMPELOEIL_NORETURN
-  void
-  report_mismatch(
-    call_matcher_list <Sig> &matcher_list,
-    call_matcher_list <Sig> &saturated_list,
-    std::string const &name,
-    call_params_type_t <Sig> const &p)
-  {
-    std::ostringstream os;
-    os << "No match for call of " << name << " with.\n";
-    stream_params(os, p);
-    bool saturated_match = false;
-    for (auto& m : saturated_list)
-    {
-      if (m.matches(p))
-      {
-        if (!saturated_match)
-        {
-          os << "\nMatches saturated call requirement\n";
-          saturated_match = true;
-        }
-        os << "  ";
-        m.report_signature(os) << '\n';
-      }
-    }
-    if (!saturated_match)
-    {
-      for (auto& m : matcher_list)
-      {
-        os << "\nTried ";
-        m.report_mismatch(os, p);
-      }
-    }
-    send_report<specialized>(severity::fatal, location{}, os.str());
-    std::abort(); // must never get here.
-  }
-
-  template <typename Sig>
-  void
-  report_match(
-    call_matcher_list <Sig> &matcher_list)
-  {
-    if(! matcher_list.empty())
-    {
-        send_ok_report<specialized>((matcher_list.begin())->name);
-    }
-  }
-
-  template <typename Sig>
-  class return_handler
-  {
-  public:
-    virtual
-    ~return_handler() = default;
-
-    virtual
-    return_of_t<Sig>
-    call(
-      trace_agent&,
-      call_params_type_t<Sig>& params) = 0;
-  };
-
-  template <typename Ret, typename F, typename P, typename = detail::enable_if_t<std::is_void<Ret>::value>>
-  void
-  trace_return(
-    trace_agent const&,
-    F& func,
-    P& params)
-  {
-    func(params);
-  }
-
-  template <typename Ret, typename F, typename P, typename = detail::enable_if_t<!std::is_void<Ret>::value>>
-  Ret
-  trace_return(
-    trace_agent& agent,
-    F& func,
-    P& params)
-  {
-    /* Work around VS 2017 15.7.x C4702 warning by
-     * enclosing the operation in an otherwise
-     * unnecessary try/catch block.
-     */
-    try
-    {
-      return agent.trace_return(func(params));
-    }
-    catch (...)
-    {
-      throw;
-    }
-  }
-
-  template <typename Sig, typename T>
-  class return_handler_t : public return_handler<Sig>
-  {
-  public:
-    template <typename U>
-    explicit
-    return_handler_t(
-      U&& u)
-    : func(std::forward<U>(u))
-    {}
-
-    return_of_t<Sig>
-    call(
-      trace_agent& agent,
-      call_params_type_t<Sig>& params)
-    override
-    {
-      return trace_return<return_of_t<Sig>>(agent, func, params);
-    }
-  private:
-    T func;
-  };
-
-#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
-  template <typename Sig, bool = trompeloeil::is_coroutine<return_of_t<Sig>>::value>
-  struct yield_expr_base : public list_elem<yield_expr_base<Sig, true>>
-  {
-    ~yield_expr_base() override = default;
-
-    using ret_type = coro_value_type_t<return_of_t<Sig>>;
-    virtual
-    ret_type
-    expr(
-      call_params_type_t<Sig>&)
-    const = 0;
-  };
-  template <typename Sig>
-  struct yield_expr_base<Sig, false> : public list_elem<yield_expr_base<Sig, false>>
-  {
-    using ret_type = return_of_t<Sig>;
-    virtual
-    ret_type
-    expr(
-      call_params_type_t<Sig>&)
-    const = 0;
-  };
-
-  template <typename Sig>
-  using yield_expr_list = list<yield_expr_base<Sig>, delete_disposer>;
-
-  template <typename Sig, typename Expr>
-  struct yield_expr : yield_expr_base<Sig>
-  {
-    using ret_type = typename yield_expr_base<Sig>::ret_type;
-    template <typename E>
-    explicit
-    yield_expr(
-      E&& e_)
-      : e(std::forward<E>(e_))
-    {}
-
-    ret_type
-    expr(
-      call_params_type_t<Sig>& t)
-    const
-    override
-    {
-      return e(t);
-    }
-  private:
-    Expr e;
-  };
-
-  template <typename Sig, typename T>
-  class co_return_handler_t : public return_handler<Sig>
-  {
-  public:
-    template <typename U>
-    explicit
-    co_return_handler_t(
-      U&& u,
-      std::shared_ptr<yield_expr_list<Sig>> yields_)
-      : func(std::forward<U>(u))
-      , yields(std::move(yields_))
-    {}
-
-    return_of_t<Sig>
-    call(
-      trace_agent& /*agent*/,
-      call_params_type_t<Sig>& params)
-    override
-    {
-      using coro_type = return_of_t<Sig>;
-      using promise_type = typename std::coroutine_traits<coro_type>::promise_type;
-      using value_type = coro_value_type_t<coro_type>;
-      if constexpr (requires {std::declval<promise_type&>().yield_value(std::declval<value_type>());})
-      {
-        for (auto & e : *yields)
-        {
-          co_yield e.expr(params);
-        }
-      }
-      co_return func(params);
-    }
-  private:
-    T func;
-    std::shared_ptr<yield_expr_list<Sig>> yields;
-  };
-#endif
-
-  template <typename Sig>
-  class condition_base : public list_elem<condition_base<Sig>>
-  {
-  public:
-    explicit
-    condition_base(
-      char const *n)
-    noexcept
-      : id(n)
-    {}
-
-    ~condition_base() override = default;
-
-    virtual
-    bool
-    check(
-      call_params_type_t<Sig> const&)
-    const = 0;
-
-    virtual
-    char const*
-    name()
-    const
-    noexcept
-    {
-      return id;
-    }
-  private:
-    char const *id;
-  };
-
-  template <typename Sig>
-  using condition_list = list<condition_base<Sig>, delete_disposer>;
-
-  template <typename Sig, typename Cond>
-  struct condition : public condition_base<Sig>
-  {
-    condition(
-      char const *str_,
-      Cond c_)
-      : condition_base<Sig>(str_)
-      , c(c_) {}
-
-    bool
-    check(
-      call_params_type_t<Sig> const & t)
-    const
-    override
-    {
-      return c(t);
-    }
-
-  private:
-    Cond c;
-  };
-
-  template <typename Sig>
-  struct side_effect_base : public list_elem<side_effect_base<Sig>>
-  {
-    ~side_effect_base() override = default;
-
-    virtual
-    void
-    action(
-      call_params_type_t<Sig> &)
-    const = 0;
-  };
-
-  template <typename Sig>
-  using side_effect_list = list<side_effect_base<Sig>, delete_disposer>;
-
-  template <typename Sig, typename Action>
-  struct side_effect : public side_effect_base<Sig>
-  {
-    template <typename A>
-    explicit
-    side_effect(
-      A&& a_)
-    : a(std::forward<A>(a_))
-    {}
-
-    void
-    action(
-      call_params_type_t<Sig> &t)
-    const
-    override
-    {
-      a(t);
-    }
-  private:
-    Action a;
-  };
-  template <size_t L, size_t H = L>
-  struct multiplicity { };
-
-  template <typename R, typename Parent>
-  struct co_return_injector : Parent
-  {
-    using co_return_type = R;
-  };
-
-  template <typename R, typename Parent>
-  struct return_injector : Parent
-  {
-    using return_type = R;
-  };
-
-  template <typename Parent>
-  struct throw_injector : Parent
-  {
-    static bool const throws = true;
-  };
-
-  template <typename Parent>
-  struct sideeffect_injector : Parent
-  {
-    static bool const side_effects = true;
-  };
-
-  template <typename Parent, size_t H>
-  struct call_limit_injector : Parent
-  {
-    static bool   const call_limit_set = true;
-    static size_t const upper_call_limit = H;
-  };
-
-  template <typename Parent>
-  struct call_limit_injector<Parent, 0> : Parent
-  {
-    static bool   const call_limit_set = true;
-    static size_t const upper_call_limit = 0;
-  };
-
-  template <typename Parent>
-  struct sequence_injector : Parent
-  {
-    static bool const sequence_set = true;
-  };
-
-  template <typename Matcher, typename modifier_tag, typename Parent>
-  struct call_modifier : public Parent
-  {
-    using typename Parent::signature;
-    using typename Parent::co_return_type;
-    using typename Parent::return_type;
-    using Parent::call_limit_set;
-    using Parent::upper_call_limit;
-    using Parent::sequence_set;
-    using Parent::throws;
-    using Parent::side_effects;
-
-    call_modifier(
-       Matcher* m)
-    noexcept
-      : matcher{m}
-    {}
-
-    template <typename D>
-    call_modifier&&
-    with(
-      char const* str,
-      D&& d)
-    &&
-    {
-      matcher->add_condition(str, std::forward<D>(d));
-      return std::move(*this);
-    }
-
-    template <typename A>
-    call_modifier<Matcher, modifier_tag, sideeffect_injector<Parent>>
-    sideeffect(
-      A&& a)
-    {
-      constexpr bool forbidden = upper_call_limit == 0U;
-      static_assert(!forbidden,
-                    "SIDE_EFFECT for forbidden call does not make sense");
-      matcher->add_side_effect(std::forward<A>(a));
-      return {std::move(matcher)};
-    }
-    template <typename...> struct S;
-#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
-    template <typename E>
-    call_modifier<Matcher, modifier_tag, Parent>
-    handle_co_yield(
-      E&& e)
-    {
-      using params_type = call_params_type_t<signature>&;
-      using sigret = return_of_t<signature>;
-      using ret = std::invoke_result_t<E, params_type>;
-
-      constexpr bool is_void = std::is_same_v<ret, void>;
-      constexpr bool is_coroutine = trompeloeil::is_coroutine<sigret>::value;
-      constexpr bool is_matching_type = std::invoke([]{
-        if constexpr (is_coroutine && !is_void) {
-          using promise = typename std::coroutine_traits<sigret>::promise_type;
-          return requires(promise p, ret r){ p.yield_value(r); };
-        } else {
-          return false;
-        }
-      });
-      static_assert(is_coroutine,
-                    "CO_YIELD when return type is not a coroutine");
-      static_assert(!is_coroutine || !is_void,
-                    "You cannot CO_YIELD void");
-      static_assert(!is_coroutine || is_void || is_matching_type,
-                    "CO_YIELD is incompatible with the promise type");
-      constexpr auto valid = is_coroutine && !is_void && is_matching_type;
-      if constexpr (valid)
-      {
-        matcher->add_yield_expr(std::forward<E>(e));
-      }
-      return {matcher};
-    }
-    template <typename H>
-    call_modifier<Matcher, modifier_tag, co_return_injector<return_of_t<signature>, Parent >>
-    handle_co_return(
-      H&& h)
-    {
-      using params_type = call_params_type_t<signature>&;
-      using sigret = return_of_t<signature>;
-      using ret = std::invoke_result_t<H, params_type>;
-
-      constexpr bool has_return = !std::is_same_v<return_type, void>;
-      constexpr bool has_co_return = !std::is_same_v<co_return_type, void>;
-      constexpr bool is_coroutine = trompeloeil::is_coroutine<sigret>::value;
-      constexpr bool is_matching_type = std::invoke([]{if constexpr (is_coroutine) {
-        using promise = typename std::coroutine_traits<sigret>::promise_type;
-        if constexpr (std::is_same_v<void, ret>) {
-          return requires (promise p){p.return_void();};
-        } else {
-          return requires(promise p) { p.return_value(std::declval<ret>()); };
-        }}
-        return true;});
-
-      static_assert(!has_return,
-                    "CO_RETURN and RETURN cannot be combined");
-      static_assert(has_return || !has_co_return,
-                    "Multiple CO_RETURN does not make sense");
-      static_assert(has_return || is_coroutine, "CO_RETURN when return type is not a coroutine");
-      static_assert(has_return || has_co_return || !is_coroutine || is_matching_type,
-                    "Expression type does not match the coroutine promise type");
-      static_assert(!throws || upper_call_limit == 0,
-                    "CO_THROW and CO_RETURN does not make sense");
-      static_assert(upper_call_limit > 0,
-                    "CO_RETURN for forbidden call does not make sense");
-
-      constexpr bool valid = !has_return && !has_co_return && is_coroutine && is_matching_type && !throws && upper_call_limit > 0;
-      if constexpr (valid)
-      {
-        matcher->set_co_return(std::forward<H>(h));
-      }
-      return {matcher};
-    }
-#endif
-    template <typename H>
-    call_modifier<Matcher, modifier_tag, return_injector<return_of_t<signature>, Parent >>
-    handle_return(
-      H&& h)
-    {
-      using params_type = call_params_type_t<signature>&;
-      using sigret = return_of_t<signature>;
-      using ret = decltype(std::declval<H>()(std::declval<params_type>()));
-      // don't know why MS VS 2015 RC doesn't like std::result_of
-
-#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
-      constexpr bool is_coroutine      = trompeloeil::is_coroutine<sigret>::value;
-#else
-      constexpr bool is_coroutine      = false;
-#endif
-      constexpr bool is_illegal_type   = std::is_same<detail::decay_t<ret>, illegal_argument>::value;
-      constexpr bool has_co_return     = !std::is_same<co_return_type, void>::value;
-      constexpr bool is_first_return   = std::is_same<return_type, void>::value;
-      constexpr bool void_signature    = std::is_same<sigret, void>::value;
-      constexpr bool is_pointer_sigret = std::is_pointer<sigret>::value;
-      constexpr bool is_pointer_ret    = std::is_pointer<detail::decay_t<ret>>::value;
-      constexpr bool ptr_const_mismatch =
-        is_pointer_ret &&
-        is_pointer_sigret &&
-        !std::is_const<detail::remove_pointer_t<sigret>>{} &&
-        std::is_const<detail::remove_pointer_t<detail::decay_t<ret>>>{};
-      constexpr bool is_ref_sigret     = std::is_reference<sigret>::value;
-      constexpr bool is_ref_ret        = std::is_reference<ret>::value;
-      constexpr bool ref_const_mismatch=
-        is_ref_ret &&
-        is_ref_sigret &&
-        !std::is_const<detail::remove_reference_t<sigret>>::value &&
-        std::is_const<detail::remove_reference_t<ret>>::value;
-      constexpr bool matching_ret_type = std::is_constructible<sigret, ret>::value;
-      constexpr bool ref_value_mismatch = !is_ref_ret && is_ref_sigret;
-
-      static_assert(!has_co_return,
-                    "RETURN and CO_RETURN cannot be combined");
-      static_assert(!is_coroutine,
-                    "Do not use RETURN from a coroutine, use CO_RETURN");
-      static_assert(is_coroutine || matching_ret_type || !void_signature,
-                    "RETURN does not make sense for void-function");
-      static_assert(is_coroutine || !is_illegal_type,
-                    "RETURN illegal argument");
-      static_assert(is_coroutine || !ptr_const_mismatch,
-                    "RETURN const* from function returning pointer to non-const");
-      static_assert(is_coroutine || !ref_value_mismatch || matching_ret_type,
-                    "RETURN non-reference from function returning reference");
-      static_assert(is_coroutine || ref_value_mismatch || !ref_const_mismatch,
-                    "RETURN const& from function returning non-const reference");
-
-      static_assert(is_coroutine || ptr_const_mismatch || ref_const_mismatch || is_illegal_type || matching_ret_type || void_signature,
-                    "RETURN value is not convertible to the return type of the function");
-      static_assert(is_coroutine || is_first_return,
-                    "Multiple RETURN does not make sense");
-      static_assert(is_coroutine || !throws || upper_call_limit == 0,
-                    "THROW and RETURN does not make sense");
-      static_assert(is_coroutine || upper_call_limit > 0,
-                    "RETURN for forbidden call does not make sense");
-
-      constexpr bool valid = !is_coroutine && !is_illegal_type && matching_ret_type && is_first_return && !throws && upper_call_limit > 0;
-      using tag = std::integral_constant<bool, valid>;
-      matcher->set_return(tag{}, std::forward<H>(h));
-      return {matcher};
-    }
-
-    call_modifier&&
-    null_modifier()
-    {
-      return std::move(*this);
-    }
-
-#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
-
-    template <typename H>
-    struct co_throw_handler_t
-    {
-      using R = decltype(default_return<return_of_t<signature>>());
-      using promise_value_type = trompeloeil::coro_value_type_t<R>;
-      explicit
-      co_throw_handler_t(H&& h_)
-        : h(std::move(h_))
-      {}
-
-      template <typename T>
-      promise_value_type operator()(T& p)
-      {
-        return ((void)h(p), trompeloeil::default_return<promise_value_type>());
-      }
-
-    private:
-      H h;
-    };
-
-    template <typename H>
-    call_modifier<Matcher, modifier_tag, throw_injector<Parent>>
-    handle_co_throw(
-      H&& h)
-    {
-      using sigret = return_of_t<signature>;
-      constexpr bool is_coroutine      = trompeloeil::is_coroutine<sigret>::value;
-      static_assert(is_coroutine,
-                    "Do not use CO_THROW from a normal function, use THROW");
-      static_assert(!is_coroutine || !throws,
-                    "Multiple CO_THROW does not make sense");
-      constexpr bool has_return = !std::is_same<co_return_type, void>::value;
-      static_assert(!is_coroutine || !has_return,
-                    "CO_THROW and CO_RETURN does not make sense");
-
-      constexpr bool forbidden = upper_call_limit == 0U;
-
-      static_assert(!is_coroutine || !forbidden,
-                    "CO_THROW for forbidden call does not make sense");
-
-      constexpr bool valid = is_coroutine && !throws && !has_return;
-      if constexpr (valid) {
-        auto handler = co_throw_handler_t<H>(std::forward<H>(h));
-        matcher->set_co_return(std::move(handler));
-      }
-      return {matcher};
-    }
-#endif
-    template <typename H>
-    struct throw_handler_t
-    {
-      using R = decltype(default_return<return_of_t<signature>>());
-
-      explicit
-      throw_handler_t(H&& h_)
-        : h(std::move(h_))
-      {}
-
-      template <typename T>
-      R operator()(T& p)
-      {
-        /* Work around VS 2017 15.7.x C4702 warning by
-         * enclosing the operation in an otherwise
-         * unnecessary try/catch block.
-         */
-        try
-        {
-          h(p);
-          abort();
-        }
-        catch (...)
-        {
-          throw;
-        }
-        return default_return<R>(); // unreachable code
-      }
-
-    private:
-      H h;
-    };
-
-    template <typename H>
-    call_modifier<Matcher, modifier_tag, throw_injector<Parent>>
-    handle_throw(
-      H&& h)
-    {
-#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
-      using sigret = return_of_t<signature>;
-      constexpr bool is_coroutine      = trompeloeil::is_coroutine<sigret>::value;
-#else
-      constexpr bool is_coroutine      = false;
-#endif
-      static_assert(!is_coroutine,
-                    "Do not use THROW from a coroutine, use CO_THROW");
-      static_assert(is_coroutine || !throws,
-                    "Multiple THROW does not make sense");
-      constexpr bool has_return = !std::is_same<return_type, void>::value;
-      static_assert(!has_return,
-                    "THROW and RETURN does not make sense");
-
-      constexpr bool forbidden = upper_call_limit == 0U;
-
-      static_assert(is_coroutine || !forbidden,
-                    "THROW for forbidden call does not make sense");
-
-      constexpr bool valid = !is_coroutine && !throws && !has_return;
-      using tag = std::integral_constant<bool, valid>;
-      auto handler = throw_handler_t<H>(std::forward<H>(h));
-      matcher->set_return(tag{}, std::move(handler));
-      return {matcher};
-    }
-
-    template <size_t L,
-              size_t H,
-              bool               times_set = call_limit_set>
-    call_modifier<Matcher, modifier_tag, call_limit_injector<Parent, H>>
-    times(
-      multiplicity<L, H>)
-    {
-      static_assert(!times_set,
-                    "Only one TIMES call limit is allowed, but it can express an interval");
-
-      static_assert(H >= L,
-                    "In TIMES the first value must not exceed the second");
-
-      static_assert(H > 0 || !throws,
-                    "THROW and TIMES(0) does not make sense");
-
-      static_assert(H > 0 || std::is_same<return_type, void>::value,
-                    "RETURN and TIMES(0) does not make sense");
-
-      static_assert(H > 0 || !side_effects,
-                    "SIDE_EFFECT and TIMES(0) does not make sense");
-
-      static_assert(H > 0 || !sequence_set,
-                    "IN_SEQUENCE and TIMES(0) does not make sense");
-
-      matcher->sequences->set_limits(L, H);
-      return {matcher};
-    }
-
-    template <typename ... T,
-              bool b = sequence_set>
-    call_modifier<Matcher, modifier_tag, sequence_injector<Parent>>
-    in_sequence(
-      T&& ... t)
-    {
-      static_assert(!b,
-                    "Multiple IN_SEQUENCE does not make sense."
-                    " You can list several sequence objects at once");
-
-      static_assert(upper_call_limit > 0,
-                    "IN_SEQUENCE for forbidden call does not make sense");
-
-      matcher->set_sequence(std::forward<T>(t)...);
-      return {matcher};
-    }
-    Matcher* matcher;
-  };
-
-  inline
-  void
-  report_unfulfilled(
-    const char* reason,
-    char const        *name,
-    std::string const &values,
-    size_t min_calls,
-    size_t call_count,
-    location           loc)
-  {
-    std::ostringstream os;
-    os << reason
-       << ":\nExpected " << name << " to be called ";
-    if (min_calls == 1)
-      os << "once";
-    else
-      os << min_calls << " times";
-    os << ", actually ";
-    switch (call_count)
-    {
-    case 0:
-      os << "never called\n"; break;
-    case 1:
-      os << "called once\n"; break;
-    default:
-      os << "called " << call_count << " times\n";
-    }
-    os << values;
-    send_report<specialized>(severity::nonfatal, loc, os.str());
-  }
-
-  inline
-  void
-  report_forbidden_call(
-    char const *name,
-    location loc,
-    std::string const& values)
-  {
-    std::ostringstream os;
-    os << "Match of forbidden call of " << name
-       << " at " << loc << '\n' << values;
-    send_report<specialized>(severity::fatal, loc, os.str());
-  }
-
-  template <typename Sig>
-  struct matcher_info
-  {
-    using signature = Sig;
-    using co_return_type = void;
-    using return_type = void;
-    static size_t const upper_call_limit = 1;
-    static bool const throws = false;
-    static bool const call_limit_set = false;
-    static bool const sequence_set = false;
-    static bool const side_effects = false;
-  };
-
-
-  template <typename Sig, typename Value>
-  struct call_matcher : public call_matcher_base<Sig>, expectation
-  {
-    using call_matcher_base<Sig>::name;
-    using call_matcher_base<Sig>::loc;
-
-#if TROMPELOEIL_GCC && TROMPELOEIL_GCC_VERSION >= 70000 && TROMPELOEIL_GCC_VERSION < 80000
-#pragma GCC diagnostic ignored "-Wconversion"
-#pragma GCC diagnostic push
-#endif
-    template <typename ... U>
-    call_matcher(
-      char const *file,
-      unsigned long line,
-      char const *call_string,
-      U &&... u)
-    : call_matcher_base<Sig>(location{file, line}, call_string)
-    , val(std::forward<U>(u)...)
-    {}
-#if TROMPELOEIL_GCC && TROMPELOEIL_GCC_VERSION >= 70000 && TROMPELOEIL_GCC_VERSION < 80000
-#pragma GCC diagnostic pop
-#endif
-
-    call_matcher(call_matcher &&r) = delete;
-
-    ~call_matcher() override
-    {
-      auto lock = get_lock();
-      if (is_unfulfilled())
-      {
-        report_missed("Unfulfilled expectation");
-      }
-      this->unlink();
-    }
-
-    bool
-    is_satisfied()
-      const
-      noexcept
-      override
-    {
-      auto lock = get_lock();
-      return sequences->is_satisfied();
-    }
-
-    bool
-    is_saturated()
-      const
-      noexcept
-      override
-    {
-      auto lock = get_lock();
-      return sequences->is_saturated();
-    }
-    bool
-    is_unfulfilled()
-    const
-    noexcept
-    {
-      return !reported && this->is_linked() && !sequences->is_satisfied();
-    }
-
-    void
-    mock_destroyed()
-    override
-    {
-      if (is_unfulfilled())
-      {
-        report_missed("Pending expectation on destroyed mock object");
-      }
-    }
-
-    call_matcher*
-    hook_last(
-      call_matcher_list<Sig> &list)
-    noexcept
-    {
-      list.push_front(this);
-      return this;
-    }
-
-    bool
-    matches(
-      call_params_type_t<Sig> const& params)
-    const
-    override
-    {
-      return match_parameters(val, params) && match_conditions(params);
-    }
-
-    bool
-    match_conditions(
-      call_params_type_t<Sig> const & params)
-    const
-    {
-      // std::all_of() is almost always preferable. The only reason
-      // for using a hand rolled loop is because it cuts compilation
-      // times quite noticeably (almost 10% with g++5.1)
-      for (auto& c : conditions)
-      {
-        if (!c.check(params)) return false;
-      }
-      return true;
-    }
-
-    unsigned
-    sequence_cost()
-      const
-      noexcept
-      override
-    {
-      return sequences->order();
-    }
-
-    return_of_t<Sig>
-    return_value(
-      trace_agent& agent,
-      call_params_type_t<Sig>& params)
-    override
-    {
-      if (!return_handler_obj) return default_return<return_of_t<Sig>>();
-      return return_handler_obj->call(agent, params);
-    }
-
-    void
-    run_actions(
-      call_params_type_t<Sig>& params,
-      call_matcher_list<Sig> &saturated_list)
-    override
-    {
-      if (sequences->is_forbidden())
-      {
-        reported = true;
-        report_forbidden_call(name, loc, params_string(params));
-      }
-      auto lock = get_lock();
-      {
-        if (!sequences->can_be_called())
-        {
-          sequences->validate(severity::fatal, name, loc);
-        }
-        sequences->increment_call();
-        if (sequences->is_satisfied())
-        {
-          sequences->retire_predecessors();
-        }
-        if (sequences->is_saturated())
-        {
-          sequences->retire();
-          this->unlink();
-          saturated_list.push_back(this);
-        }
-      }
-      for (auto& a : actions) a.action(params);
-    }
-
-    std::ostream&
-    report_signature(
-      std::ostream& os)
-    const override
-    {
-      return os << name << " at " << loc;
-    }
-
-    std::ostream&
-    report_mismatch(
-      std::ostream& os,
-      call_params_type_t<Sig> const & params)
-    override
-    {
-      reported = true;
-      report_signature(os);
-      if (match_parameters(val, params))
-      {
-        for (auto& cond : conditions)
-        {
-          if (!cond.check(params))
-          {
-            os << "\n  Failed WITH(" << cond.name() << ')';
-          }
-        }
-      }
-      else
-      {
-        os << '\n';
-        ::trompeloeil::print_mismatch(os, val, params);
-      }
-      return os;
-    }
-
-    void
-    report_missed(
-      char const *reason)
-    noexcept
-    {
-      reported = true;
-      report_unfulfilled(
-        reason,
-        name,
-        params_string(val),
-        sequences->get_min_calls(),
-        sequences->get_calls(),
-        loc);
-    }
-
-    template <typename C>
-    void
-    add_condition(
-      char const *str,
-      C&& c)
-    {
-      auto cond = new condition<Sig, C>(str, std::forward<C>(c));
-      conditions.push_back(cond);
-    }
-
-    template <typename S>
-    void
-    add_side_effect(
-      S&& s)
-    {
-      auto effect = new side_effect<Sig, S>(std::forward<S>(s));
-      actions.push_back(effect);
-    }
-
-    template <typename ... T>
-    void
-    set_sequence(
-      T&& ... t)
-    {
-      using handler = sequence_handler<sizeof...(T)>;
-      auto seq = detail::make_unique<handler>(*sequences,
-                                              name,
-                                              loc,
-                                              std::forward<T>(t)...);
-      sequences = std::move(seq);
-    }
-#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
-    template <typename E>
-    void
-    add_yield_expr(
-      E&& e)
-    {
-      auto expr = new yield_expr<Sig, E>(std::forward<E>(e));
-      yield_expressions->push_back(expr);
-    }
-#endif
-    template <typename T>
-    inline
-    void
-    set_return(
-      std::true_type,
-      T&& h)
-    {
-      using basic_t = typename std::remove_reference<T>::type;
-      using handler = return_handler_t<Sig, basic_t>;
-      return_handler_obj.reset(new handler(std::forward<T>(h)));
-    }
-
-    template <typename T>            // Never called. Used to limit errmsg
-    static                           // with RETURN of wrong type and after:
-    void                             //   FORBIDDEN_CALL
-    set_return(std::false_type, T&&t)//   RETURN
-      noexcept;                      //   THROW
-
-#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
-    template <typename T>
-    inline
-    void
-    set_co_return(
-      T&& h)
-    {
-      using basic_t = typename std::remove_reference<T>::type;
-      using handler = co_return_handler_t<Sig, basic_t>;
-      return_handler_obj.reset(new handler(std::forward<T>(h), yield_expressions));
-    }
-#endif
-
-    condition_list<Sig>                    conditions;
-    side_effect_list<Sig>                  actions;
-#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
-    std::shared_ptr<yield_expr_list<Sig>>  yield_expressions = std::make_shared<yield_expr_list<Sig>>();
-#endif
-
-    std::unique_ptr<return_handler<Sig>>   return_handler_obj;
-    std::unique_ptr<sequence_handler_base> sequences = detail::make_unique<sequence_handler<0>>();
-    Value                                  val;
-    bool                                   reported = false;
-  };
-
-  /* Clang (all versions) does not like computing the return type R
-   * before determining if the function overload is the best match.
-   */
-  template <
-    int N,
-    typename T,
-    typename = detail::enable_if_t<N <= std::tuple_size<T>::value>,
-    typename R = decltype(std::get<N-1>(std::declval<T>()))
-  >
-  constexpr
-  TROMPELOEIL_DECLTYPE_AUTO
-  arg(
-    T* t,
-    std::true_type)
-  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
-  {
-    return std::get<N-1>(*t);
-  }
-
-  template <int>
-  constexpr
-  illegal_argument
-  arg(
-    void const*,
-    std::false_type)
-  noexcept
-  {
-    return {};
-  }
-
-  template <
-    int N,
-    typename T,
-    typename R = decltype(arg<N>(std::declval<T*>(),
-                                 std::integral_constant<bool, (N <= std::tuple_size<T>::value)>{}))
-  >
-  TROMPELOEIL_DECLTYPE_AUTO
-  mkarg(
-    T& t)
-  noexcept
-  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
-  {
-    return arg<N>(&t, std::integral_constant<bool, (N <= std::tuple_size<T>::value)>{});
-  }
-
-  template <typename Mock>
-  struct call_validator_t
-  {
-    template <typename M, typename Tag, typename Info>
-    auto
-    make_expectation(
-      std::true_type,
-      call_modifier<M, Tag, Info> const& m)
-    const
-    noexcept
-    TROMPELOEIL_TRAILING_RETURN_TYPE(std::unique_ptr<expectation>)
-    {
-      auto lock = get_lock();
-      m.matcher->hook_last(obj.trompeloeil_matcher_list(static_cast<Tag*>(nullptr)));
-
-      return std::unique_ptr<expectation>(m.matcher);
-    }
-
-    template <typename T>
-    static                                           // Never called. Used to
-    std::unique_ptr<expectation>                     // limit errmsg when RETURN
-    make_expectation(std::false_type, T&&) noexcept; // is missing in non-void
-                                                     // function
-
-    template <typename M, typename Tag, typename Info>
-    inline
-    auto
-    operator+(
-      call_modifier<M, Tag, Info>&& t)
-    const
-    TROMPELOEIL_TRAILING_RETURN_TYPE(std::unique_ptr<expectation>)
-    {
-      using call = call_modifier<M, Tag, Info>;
-      using sigret = return_of_t<typename call::signature>;
-      using ret = typename call::return_type;
-      using coret = typename call::co_return_type;
-#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
-      constexpr bool is_coroutine = trompeloeil::is_coroutine<sigret>::value;
-#else
-      constexpr bool is_coroutine = false;
-#endif
-      constexpr bool retmatch = std::is_same<ret, sigret>::value;
-      constexpr bool coretmatch = std::is_same<coret, sigret>::value;
-      constexpr bool forbidden = call::upper_call_limit == 0;
-      constexpr bool valid_return_type = retmatch || coretmatch || forbidden;
-      constexpr bool handles_return = is_coroutine || valid_return_type || call::throws;
-      constexpr bool handles_co_return = !is_coroutine || valid_return_type || call::throws;
-      static_assert(handles_return, "RETURN missing for non-void function");
-      static_assert(handles_co_return, "CO_RETURN missing for coroutine");
-      auto tag = std::integral_constant<bool, handles_return || handles_co_return>{};
-      return make_expectation(tag, std::move(t));
-    }
-    Mock& obj;
-  };
-
-  template <typename T,
-            typename = detail::enable_if_t<std::is_lvalue_reference<T&&>::value>>
-  inline
-  T&&
-  decay_return_type(
-    T&& t)
-  {
-    return std::forward<T>(t);
-  }
-
-  template <typename T,
-            typename = detail::enable_if_t<std::is_rvalue_reference<T&&>::value>>
-  inline
-  T
-  decay_return_type(
-    T&& t)
-  {
-    return std::forward<T>(t);
-  }
-
-  template <typename T, size_t N>
-  inline
-  T*
-  decay_return_type(
-    T (&t)[N])
-  {
-    return t;
-  }
-
-  inline
-  void
-  decay_return_type()
-  {
-  }
-
-  template <bool sequence_set>
-  struct lifetime_monitor_modifier : std::unique_ptr<lifetime_monitor>
-  {
-    explicit
-    lifetime_monitor_modifier(
-      std::unique_ptr<lifetime_monitor>&& p)
-    noexcept
-    : unique_ptr(std::move(p))
-    {}
-
-    template <typename ... T, bool b = sequence_set>
-    auto
-    in_sequence(T&& ... t)
-    -> lifetime_monitor_modifier<true>
-    {
-      static_assert(!b,
-                    "Multiple IN_SEQUENCE does not make sense."
-                      " You can list several sequence objects at once");
-      std::unique_ptr<lifetime_monitor>& m = *this;
-      m->set_sequence(std::forward<T>(t)...);
-      return lifetime_monitor_modifier<true>{std::move(m)};
-    }
-  };
-
-  struct lifetime_monitor_releaser
-  {
-    template <bool b>
-    std::unique_ptr<trompeloeil::lifetime_monitor>
-    operator+(
-      lifetime_monitor_modifier<b>&& m)
-    const
-    {
-      return std::move(m);
-    }
-  };
-
-  template <bool movable, typename Sig>
-  struct expectations
-  {
-    expectations() = default;
-    expectations(expectations&&) noexcept = default;
-    ~expectations() {
-      active.decommission();
-      saturated.decommission();
-    }
-    call_matcher_list<Sig> active{};
-    call_matcher_list<Sig> saturated{};
-  };
-
-  template <typename Sig>
-  struct expectations<false, Sig>
-  {
-    expectations() = default;
-    expectations(expectations&&)
-    noexcept
-    {
-      static_assert(std::is_same<Sig,void>::value,
-        "By default, mock objects are not movable. "
-        "To make a mock object movable, see: "
-        "https://github.com/rollbear/trompeloeil/blob/master/docs/reference.md#movable_mock");
-    }
-    ~expectations() {
-      active.decommission();
-      saturated.decommission();
-    }
-    call_matcher_list<Sig> active{};
-    call_matcher_list<Sig> saturated{};
-  };
-
-  template <typename Sig, typename ... P>
-  return_of_t<Sig> mock_func(std::false_type, P&& ...);
-
-
-  template <bool movable, typename Sig, typename ... P>
-  return_of_t<Sig>
-  mock_func(std::true_type,
-            expectations<movable, Sig>& e,
-            char const *func_name,
-            char const *sig_name,
-            P&& ... p)
-  {
-    auto lock = get_lock();
-
-    call_params_type_t<void(P...)> param_value(std::forward<P>(p)...);
-
-    auto i = find(e.active, param_value);
-    if (!i)
-    {
-      report_mismatch(e.active,
-                      e.saturated,
-                      func_name + std::string(" with signature ") + sig_name,
-                      param_value);
-    }
-    else{
-        report_match(e.active);
-    }
-    trace_agent ta{i->loc, i->name, tracer_obj()};
-    try
-    {
-      ta.trace_params(param_value);
-      i->run_actions(param_value, e.saturated);
-      return i->return_value(ta, param_value);
-    }
-    catch (...)
-    {
-      ta.trace_exception();
-      throw;
-    }
-  }
-
-  template <typename ... U>
-  struct param_helper {
-    using type = decltype(detail::make_tuple(std::declval<U>()...));
-  };
-
-  template <typename ... U>
-  using param_t = typename param_helper<U...>::type;
-
-  template <typename sig, typename tag, typename... U>
-  using modifier_t = call_modifier<call_matcher<sig, param_t<U...>>,
-                                   tag,
-                                   matcher_info<sig>>;
-
-  template <typename M,
-            typename = detail::enable_if_t<::trompeloeil::is_matcher<M>::value>>
-  inline
-  ::trompeloeil::ptr_deref<detail::decay_t<M>>
-  operator*(
-    M&& m)
-  {
-    return ::trompeloeil::ptr_deref<detail::decay_t<M>>{std::forward<M>(m)};
-  }
-
-  template <typename M,
-            typename = detail::enable_if_t<::trompeloeil::is_matcher<M>::value>>
-  inline
-  ::trompeloeil::neg_matcher<detail::decay_t<M>>
-  operator!(
-    M&& m)
-  {
-    return ::trompeloeil::neg_matcher<detail::decay_t<M>>{std::forward<M>(m)};
-  }
-
-  /*
-   * Convert the signature S of a mock function to the signature of
-   * a member function of class T that takes the same parameters P
-   * but returns R.
-   *
-   * The member function has the same constness as the mock function.
-   */
-  template <typename T, typename R, typename S>
-  struct signature_to_member_function;
-
-  template <typename T, typename R, typename R_of_S, typename... P>
-  struct signature_to_member_function<T, R, R_of_S(P...)>
-  {
-    using type = detail::conditional_t<
-      std::is_const<T>::value,
-      R (T::*)(P...) const,
-      R (T::*)(P...)>;
-  };
-
-  template <typename T>
-  struct mock_interface : public T
-  {
-    using trompeloeil_interface_name = T;
-    using T::T;
- };
-
-#if defined(TROMPELOEIL_USER_DEFINED_COMPILE_TIME_REPORTER)
- extern template struct reporter<specialized>;
-#endif // TROMPELOEIL_USER_DEFINED_COMPILE_TIME_REPORTER
-}
-
-#define TROMPELOEIL_LINE_ID(name)                                        \
-  TROMPELOEIL_CONCAT(trompeloeil_l_ ## name ## _, __LINE__)
-
-#define TROMPELOEIL_COUNT_ID(name)                                       \
-  TROMPELOEIL_CONCAT(trompeloeil_c_ ## name ## _, __COUNTER__)
-
-#if TROMPELOEIL_MSVC
-#define TROMPELOEIL_MAKE_MOCK0(name, sig, ...)                           \
-  TROMPELOEIL_MAKE_MOCK_(name,,0, sig, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_MOCK1(name, sig, ...)                           \
-  TROMPELOEIL_MAKE_MOCK_(name,,1, sig, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_MOCK2(name, sig, ...)                           \
-  TROMPELOEIL_MAKE_MOCK_(name,,2, sig, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_MOCK3(name, sig, ...)                           \
-  TROMPELOEIL_MAKE_MOCK_(name,,3, sig, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_MOCK4(name, sig, ...)                           \
-  TROMPELOEIL_MAKE_MOCK_(name,,4, sig, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_MOCK5(name, sig, ...)                           \
-  TROMPELOEIL_MAKE_MOCK_(name,,5, sig, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_MOCK6(name, sig, ...)                           \
-  TROMPELOEIL_MAKE_MOCK_(name,,6, sig, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_MOCK7(name, sig, ...)                           \
-  TROMPELOEIL_MAKE_MOCK_(name,,7, sig, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_MOCK8(name, sig, ...)                           \
-  TROMPELOEIL_MAKE_MOCK_(name,,8, sig, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_MOCK9(name, sig, ...)                           \
-  TROMPELOEIL_MAKE_MOCK_(name,,9, sig, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_MOCK10(name, sig, ...)                          \
-  TROMPELOEIL_MAKE_MOCK_(name,,10, sig, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_MOCK11(name, sig, ...)                          \
-  TROMPELOEIL_MAKE_MOCK_(name,,11, sig, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_MOCK12(name, sig, ...)                          \
-  TROMPELOEIL_MAKE_MOCK_(name,,12, sig, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_MOCK13(name, sig, ...)                          \
-  TROMPELOEIL_MAKE_MOCK_(name,,13, sig, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_MOCK14(name, sig, ...)                          \
-  TROMPELOEIL_MAKE_MOCK_(name,,14, sig, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_MOCK15(name, sig, ...)                          \
-  TROMPELOEIL_MAKE_MOCK_(name,,15, sig, __VA_ARGS__,,)
-
-#define TROMPELOEIL_MAKE_CONST_MOCK0(name, sig, ...)                     \
-  TROMPELOEIL_MAKE_MOCK_(name,const,0, sig, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_CONST_MOCK1(name, sig, ...)                     \
-  TROMPELOEIL_MAKE_MOCK_(name,const,1, sig, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_CONST_MOCK2(name, sig, ...)                     \
-  TROMPELOEIL_MAKE_MOCK_(name,const,2, sig, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_CONST_MOCK3(name, sig, ...)                     \
-  TROMPELOEIL_MAKE_MOCK_(name,const,3, sig, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_CONST_MOCK4(name, sig, ...)                     \
-  TROMPELOEIL_MAKE_MOCK_(name,const,4, sig, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_CONST_MOCK5(name, sig, ...)                     \
-  TROMPELOEIL_MAKE_MOCK_(name,const,5, sig, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_CONST_MOCK6(name, sig, ...)                     \
-  TROMPELOEIL_MAKE_MOCK_(name,const,6, sig, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_CONST_MOCK7(name, sig, ...)                     \
-  TROMPELOEIL_MAKE_MOCK_(name,const,7, sig, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_CONST_MOCK8(name, sig, ...)                     \
-  TROMPELOEIL_MAKE_MOCK_(name,const,8, sig, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_CONST_MOCK9(name, sig, ...)                     \
-  TROMPELOEIL_MAKE_MOCK_(name,const,9, sig, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_CONST_MOCK10(name, sig, ...)                    \
-  TROMPELOEIL_MAKE_MOCK_(name,const,10, sig, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_CONST_MOCK11(name, sig, ...)                    \
-  TROMPELOEIL_MAKE_MOCK_(name,const,11, sig, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_CONST_MOCK12(name, sig, ...)                    \
-  TROMPELOEIL_MAKE_MOCK_(name,const,12, sig, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_CONST_MOCK13(name, sig, ...)                    \
-  TROMPELOEIL_MAKE_MOCK_(name,const,13, sig, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_CONST_MOCK14(name, sig, ...)                    \
-  TROMPELOEIL_MAKE_MOCK_(name,const,14, sig, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_CONST_MOCK15(name, sig, ...)                    \
-  TROMPELOEIL_MAKE_MOCK_(name,const,15, sig, __VA_ARGS__,,)
-
-
-#else
-// sane standards compliant preprocessor
-
-#define TROMPELOEIL_MAKE_MOCK0(name, ...)                                \
-  TROMPELOEIL_MAKE_MOCK_(name,,0, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_MOCK1(name, ...)                                \
-  TROMPELOEIL_MAKE_MOCK_(name,,1, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_MOCK2(name, ...)                                \
-  TROMPELOEIL_MAKE_MOCK_(name,,2, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_MOCK3(name, ...)                                \
-  TROMPELOEIL_MAKE_MOCK_(name,,3, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_MOCK4(name, ...)                                \
-  TROMPELOEIL_MAKE_MOCK_(name,,4, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_MOCK5(name, ...)                                \
-  TROMPELOEIL_MAKE_MOCK_(name,,5, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_MOCK6(name, ...)                                \
-  TROMPELOEIL_MAKE_MOCK_(name,,6, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_MOCK7(name, ...)                                \
-  TROMPELOEIL_MAKE_MOCK_(name,,7, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_MOCK8(name, ...)                                \
-  TROMPELOEIL_MAKE_MOCK_(name,,8, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_MOCK9(name, ...)                                \
-  TROMPELOEIL_MAKE_MOCK_(name,,9, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_MOCK10(name, ...)                               \
-  TROMPELOEIL_MAKE_MOCK_(name,,10, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_MOCK11(name, ...)                               \
-  TROMPELOEIL_MAKE_MOCK_(name,,11, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_MOCK12(name, ...)                               \
-  TROMPELOEIL_MAKE_MOCK_(name,,12, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_MOCK13(name, ...)                               \
-  TROMPELOEIL_MAKE_MOCK_(name,,13, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_MOCK14(name, ...)                               \
-  TROMPELOEIL_MAKE_MOCK_(name,,14,__VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_MOCK15(name, ...)                               \
-  TROMPELOEIL_MAKE_MOCK_(name,,15, __VA_ARGS__,,)
-
-#define TROMPELOEIL_MAKE_CONST_MOCK0(name, ...)                          \
-  TROMPELOEIL_MAKE_MOCK_(name,const,0, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_CONST_MOCK1(name, ...)                          \
-  TROMPELOEIL_MAKE_MOCK_(name,const,1, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_CONST_MOCK2(name, ...)                          \
-  TROMPELOEIL_MAKE_MOCK_(name,const,2, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_CONST_MOCK3(name, ...)                          \
-  TROMPELOEIL_MAKE_MOCK_(name,const,3, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_CONST_MOCK4(name, ...)                          \
-  TROMPELOEIL_MAKE_MOCK_(name,const,4, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_CONST_MOCK5(name, ...)                          \
-  TROMPELOEIL_MAKE_MOCK_(name,const,5, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_CONST_MOCK6(name, ...)                          \
-  TROMPELOEIL_MAKE_MOCK_(name,const,6, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_CONST_MOCK7(name, ...)                          \
-  TROMPELOEIL_MAKE_MOCK_(name,const,7, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_CONST_MOCK8(name, ...)                          \
-  TROMPELOEIL_MAKE_MOCK_(name,const,8, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_CONST_MOCK9(name, ...)                          \
-  TROMPELOEIL_MAKE_MOCK_(name,const,9, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_CONST_MOCK10(name, ...)                         \
-  TROMPELOEIL_MAKE_MOCK_(name,const,10, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_CONST_MOCK11(name, ...)                         \
-  TROMPELOEIL_MAKE_MOCK_(name,const,11, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_CONST_MOCK12(name, ...)                         \
-  TROMPELOEIL_MAKE_MOCK_(name,const,12, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_CONST_MOCK13(name, ...)                         \
-  TROMPELOEIL_MAKE_MOCK_(name,const,13, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_CONST_MOCK14(name, ...)                         \
-  TROMPELOEIL_MAKE_MOCK_(name,const,14, __VA_ARGS__,,)
-#define TROMPELOEIL_MAKE_CONST_MOCK15(name, ...)                         \
-  TROMPELOEIL_MAKE_MOCK_(name,const,15, __VA_ARGS__,,)
-
-#endif
-
-#define TROMPELOEIL_IMPLEMENT_MOCK0(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(0, __VA_ARGS__,override))
-#define TROMPELOEIL_IMPLEMENT_MOCK1(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(1, __VA_ARGS__,override))
-#define TROMPELOEIL_IMPLEMENT_MOCK2(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(2, __VA_ARGS__,override))
-#define TROMPELOEIL_IMPLEMENT_MOCK3(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(3, __VA_ARGS__,override))
-#define TROMPELOEIL_IMPLEMENT_MOCK4(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(4, __VA_ARGS__,override))
-#define TROMPELOEIL_IMPLEMENT_MOCK5(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(5, __VA_ARGS__,override))
-#define TROMPELOEIL_IMPLEMENT_MOCK6(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(6, __VA_ARGS__,override))
-#define TROMPELOEIL_IMPLEMENT_MOCK7(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(7, __VA_ARGS__,override))
-#define TROMPELOEIL_IMPLEMENT_MOCK8(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(8, __VA_ARGS__,override))
-#define TROMPELOEIL_IMPLEMENT_MOCK9(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(9, __VA_ARGS__,override))
-#define TROMPELOEIL_IMPLEMENT_MOCK10(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(10, __VA_ARGS__,override))
-#define TROMPELOEIL_IMPLEMENT_MOCK11(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(11, __VA_ARGS__,override))
-#define TROMPELOEIL_IMPLEMENT_MOCK12(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(12, __VA_ARGS__,override))
-#define TROMPELOEIL_IMPLEMENT_MOCK13(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(13, __VA_ARGS__,override))
-#define TROMPELOEIL_IMPLEMENT_MOCK14(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(14, __VA_ARGS__,override))
-#define TROMPELOEIL_IMPLEMENT_MOCK15(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(15, __VA_ARGS__,override))
-
-#define TROMPELOEIL_IMPLEMENT_CONST_MOCK0(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(0, __VA_ARGS__,override))
-#define TROMPELOEIL_IMPLEMENT_CONST_MOCK1(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(1, __VA_ARGS__,override))
-#define TROMPELOEIL_IMPLEMENT_CONST_MOCK2(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(2, __VA_ARGS__,override))
-#define TROMPELOEIL_IMPLEMENT_CONST_MOCK3(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(3, __VA_ARGS__,override))
-#define TROMPELOEIL_IMPLEMENT_CONST_MOCK4(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(4, __VA_ARGS__,override))
-#define TROMPELOEIL_IMPLEMENT_CONST_MOCK5(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(5, __VA_ARGS__,override))
-#define TROMPELOEIL_IMPLEMENT_CONST_MOCK6(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(6, __VA_ARGS__,override))
-#define TROMPELOEIL_IMPLEMENT_CONST_MOCK7(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(7, __VA_ARGS__,override))
-#define TROMPELOEIL_IMPLEMENT_CONST_MOCK8(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(8, __VA_ARGS__,override))
-#define TROMPELOEIL_IMPLEMENT_CONST_MOCK9(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(9, __VA_ARGS__,override))
-#define TROMPELOEIL_IMPLEMENT_CONST_MOCK10(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(10, __VA_ARGS__,override))
-#define TROMPELOEIL_IMPLEMENT_CONST_MOCK11(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(11, __VA_ARGS__,override))
-#define TROMPELOEIL_IMPLEMENT_CONST_MOCK12(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(12, __VA_ARGS__,override))
-#define TROMPELOEIL_IMPLEMENT_CONST_MOCK13(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(13, __VA_ARGS__,override))
-#define TROMPELOEIL_IMPLEMENT_CONST_MOCK14(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(14, __VA_ARGS__,override))
-#define TROMPELOEIL_IMPLEMENT_CONST_MOCK15(...) \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(15, __VA_ARGS__,override))
-
-
-#define TROMPELOEIL_IMPLEMENT_MOCK_(num, name, ...) \
-  TROMPELOEIL_MAKE_MOCK_(name,\
-                         ,\
-                         num,\
-                         decltype(::trompeloeil::nonconst_member_signature(&trompeloeil_interface_name::name))::type,\
-                         TROMPELOEIL_SEPARATE(__VA_ARGS__),)
-#define TROMPELOEIL_IMPLEMENT_CONST_MOCK_(num, name, ...) \
-  TROMPELOEIL_MAKE_MOCK_(name,\
-                         const,\
-                         num,\
-                         decltype(::trompeloeil::const_member_signature(&trompeloeil_interface_name::name))::type,\
-                         TROMPELOEIL_SEPARATE(__VA_ARGS__),)
-
-#define TROMPELOEIL_MAKE_MOCK_(name, constness, num, sig, spec, ...)           \
-  private:                                                                     \
-  using TROMPELOEIL_LINE_ID(cardinality_match) =                               \
-    std::integral_constant<bool, num ==                                        \
-      ::trompeloeil::param_list<TROMPELOEIL_REMOVE_PAREN(sig)>::size>;         \
-  static_assert(TROMPELOEIL_LINE_ID(cardinality_match)::value,                 \
-                "Function signature does not have " #num " parameters");       \
-  using TROMPELOEIL_LINE_ID(matcher_list_t) =                                  \
-  ::trompeloeil::call_matcher_list<TROMPELOEIL_REMOVE_PAREN(sig)>;             \
-  using TROMPELOEIL_LINE_ID(expectation_list_t) =                              \
-    ::trompeloeil::expectations<trompeloeil_movable_mock,                      \
-                                TROMPELOEIL_REMOVE_PAREN(sig)>;                \
-                                                                               \
-  struct TROMPELOEIL_LINE_ID(tag_type_trompeloeil)                             \
-  {                                                                            \
-    const char* trompeloeil_expectation_file;                                  \
-    unsigned long trompeloeil_expectation_line;                                \
-    const char *trompeloeil_expectation_string;                                \
-                                                                               \
-    /* Work around parsing bug in VS 2015 when a "complex" */                  \
-    /* decltype() appears in a trailing return type. */                        \
-    /* Further, work around C2066 defect in VS 2017 15.7.1. */                 \
-    using trompeloeil_sig_t = typename                                         \
-    ::trompeloeil::identity_type<TROMPELOEIL_REMOVE_PAREN(sig)>::type;         \
-                                                                               \
-    using trompeloeil_call_params_type_t =                                     \
-      ::trompeloeil::call_params_type_t<TROMPELOEIL_REMOVE_PAREN(sig)>;        \
-                                                                               \
-    using trompeloeil_return_of_t =                                            \
-      ::trompeloeil::return_of_t<TROMPELOEIL_REMOVE_PAREN(sig)>;               \
-                                                                               \
-    template <typename ... trompeloeil_param_type>                             \
-    auto name(                                                                 \
-      trompeloeil_param_type&& ... trompeloeil_param)                          \
-      -> ::trompeloeil::modifier_t<trompeloeil_sig_t,                          \
-                                   TROMPELOEIL_LINE_ID(tag_type_trompeloeil),  \
-                                   trompeloeil_param_type...>                  \
-    {                                                                          \
-      using matcher = ::trompeloeil::call_matcher<                             \
-                          TROMPELOEIL_REMOVE_PAREN(sig),                       \
-                          ::trompeloeil::param_t<trompeloeil_param_type...>>;  \
-      return {                                                                 \
-          new matcher {                                                        \
-                trompeloeil_expectation_file,                                  \
-                trompeloeil_expectation_line,                                  \
-                trompeloeil_expectation_string,                                \
-                std::forward<trompeloeil_param_type>(trompeloeil_param)...     \
-              }                                                                \
-      };                                                                       \
-    }                                                                          \
-  };                                                                           \
-                                                                               \
-  public:                                                                      \
-  TROMPELOEIL_LINE_ID(matcher_list_t)&                                         \
-  trompeloeil_matcher_list(                                                    \
-    TROMPELOEIL_LINE_ID(tag_type_trompeloeil)*)                                \
-  constness                                                                    \
-  noexcept                                                                     \
-  {                                                                            \
-    return TROMPELOEIL_LINE_ID(expectations).active;                           \
-  }                                                                            \
-                                                                               \
-  ::trompeloeil::return_of_t<TROMPELOEIL_REMOVE_PAREN(sig)>                    \
-  name(TROMPELOEIL_PARAM_LIST(num, sig))                                       \
-  constness                                                                    \
-  spec                                                                         \
-  {                                                                            \
-    return ::trompeloeil::mock_func<trompeloeil_movable_mock, TROMPELOEIL_REMOVE_PAREN(sig)>( \
-                                    TROMPELOEIL_LINE_ID(cardinality_match){},  \
-                                    TROMPELOEIL_LINE_ID(expectations),         \
-#name,                                     \
-#sig                                       \
-                                    TROMPELOEIL_PARAMS(num));                  \
-  }                                                                            \
-                                                                               \
-  TROMPELOEIL_NOT_IMPLEMENTED(                                                 \
-  auto                                                                         \
-  trompeloeil_self_ ## name(TROMPELOEIL_PARAM_LIST(num, sig)) constness        \
-  -> decltype(*this));                                                         \
-                                                                               \
-  TROMPELOEIL_NOT_IMPLEMENTED(TROMPELOEIL_LINE_ID(tag_type_trompeloeil)        \
-  trompeloeil_tag_ ## name(TROMPELOEIL_PARAM_LIST(num, sig)) constness);       \
-                                                                               \
-  private:                                                                     \
-  mutable                                                                      \
-  TROMPELOEIL_LINE_ID(expectation_list_t) TROMPELOEIL_LINE_ID(expectations){}; \
-                                                                               \
-  public:                                                                      \
-  /* An unused alias declaration to make trailing semicolon acceptable. */     \
-  using TROMPELOEIL_LINE_ID(unused_alias) = void
-
-
-#define TROMPELOEIL_LPAREN (
-
-#define TROMPELOEIL_MORE_THAN_TWO_ARGS(...)                                    \
-  TROMPELOEIL_IDENTITY(                                                        \
-    TROMPELOEIL_ARG16(__VA_ARGS__,                                             \
-                      T, T, T, T, T, T, T, T, T, T, T, T, T, F, F, F))
-
-
-#define TROMPELOEIL_REQUIRE_CALL_V(...)                                        \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_REQUIRE_CALL_IMPL TROMPELOEIL_LPAREN        \
-      TROMPELOEIL_MORE_THAN_TWO_ARGS(__VA_ARGS__), __VA_ARGS__))
-
-// Dispatch to _F (0, 1, or 2 arguments) or _T (> 2 arguments) macro
-#define TROMPELOEIL_REQUIRE_CALL_IMPL(N, ...)                                  \
-    TROMPELOEIL_IDENTITY(                                                      \
-      TROMPELOEIL_REQUIRE_CALL_ ## N TROMPELOEIL_LPAREN __VA_ARGS__))
-
-// Accept only two arguments
-#define TROMPELOEIL_REQUIRE_CALL_F(obj, func)                                  \
-  auto TROMPELOEIL_COUNT_ID(call_obj) =                                        \
-    TROMPELOEIL_REQUIRE_CALL_V_LAMBDA(obj, func, #obj, #func, .null_modifier())
-
-// Accept three or more arguments.
-#define TROMPELOEIL_REQUIRE_CALL_T(obj, func, ...)                             \
-  auto TROMPELOEIL_COUNT_ID(call_obj) =                                        \
-    TROMPELOEIL_REQUIRE_CALL_V_LAMBDA(obj, func, #obj, #func, __VA_ARGS__)
-
-#if TROMPELOEIL_GCC
-// This is highly unfortunate. Conversion warnings are desired here, but there
-// are situations when the wildcard _ uses conversion when creating an
-// expectation. It would be much better if the warning could be suppressed only
-// for that type. See https://github.com/rollbear/trompeloeil/issues/293
-#pragma GCC diagnostic ignored "-Wconversion"
-#pragma GCC diagnostic push
-#endif
-#define TROMPELOEIL_REQUIRE_CALL_V_LAMBDA(obj, func, obj_s, func_s, ...)       \
-  [&]                                                                          \
-  {                                                                            \
-    using trompeloeil_s_t = decltype((obj)                                     \
-                              .TROMPELOEIL_CONCAT(trompeloeil_self_, func));   \
-    using trompeloeil_e_t = decltype((obj)                                     \
-                              .TROMPELOEIL_CONCAT(trompeloeil_tag_,func));     \
-                                                                               \
-    return TROMPELOEIL_REQUIRE_CALL_LAMBDA_OBJ(obj, func, obj_s, func_s)       \
-      __VA_ARGS__                                                              \
-      ;                                                                        \
-  }()
-#if TROMPELOEIL_GCC
-#pragma GCC diagnostic pop
-#endif
-#define TROMPELOEIL_REQUIRE_CALL_LAMBDA_OBJ(obj, func, obj_s, func_s)          \
-  ::trompeloeil::call_validator_t<trompeloeil_s_t>{(obj)} +                    \
-      ::trompeloeil::detail::conditional_t<false,                              \
-                                           decltype((obj).func),               \
-                                           trompeloeil_e_t>                    \
-    {__FILE__, static_cast<unsigned long>(__LINE__), obj_s "." func_s}.func
-
-#define TROMPELOEIL_NAMED_REQUIRE_CALL_V(...)                                  \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_NAMED_REQUIRE_CALL_IMPL TROMPELOEIL_LPAREN  \
-    TROMPELOEIL_MORE_THAN_TWO_ARGS(__VA_ARGS__), __VA_ARGS__))
-
-// Dispatch to _F (0, 1, or 2 arguments) or _T (> 2 arguments) macro
-#define TROMPELOEIL_NAMED_REQUIRE_CALL_IMPL(N, ...)                            \
-  TROMPELOEIL_IDENTITY(                                                        \
-    TROMPELOEIL_NAMED_REQUIRE_CALL_ ## N TROMPELOEIL_LPAREN __VA_ARGS__))
-
-// Accept only two arguments
-#define TROMPELOEIL_NAMED_REQUIRE_CALL_F(obj, func)                            \
-  TROMPELOEIL_REQUIRE_CALL_V_LAMBDA(obj, func, #obj, #func, .null_modifier())
-
-// Accept three or more arguments.
-#define TROMPELOEIL_NAMED_REQUIRE_CALL_T(obj, func, ...)                       \
-  TROMPELOEIL_REQUIRE_CALL_V_LAMBDA(obj, func, #obj, #func, __VA_ARGS__)
-
-
-#define TROMPELOEIL_ALLOW_CALL_V(...)                                          \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_ALLOW_CALL_IMPL TROMPELOEIL_LPAREN          \
-    TROMPELOEIL_MORE_THAN_TWO_ARGS(__VA_ARGS__), __VA_ARGS__))
-
-// Dispatch to _F (0, 1, or 2 arguments) or _T (> 2 arguments) macro
-#define TROMPELOEIL_ALLOW_CALL_IMPL(N, ...)                                    \
-  TROMPELOEIL_IDENTITY(                                                        \
-    TROMPELOEIL_ALLOW_CALL_ ## N TROMPELOEIL_LPAREN __VA_ARGS__))
-
-// Accept only two arguments
-#define TROMPELOEIL_ALLOW_CALL_F(obj, func)                                    \
-  TROMPELOEIL_REQUIRE_CALL_T(obj, func, .TROMPELOEIL_INFINITY_TIMES())
-
-// Accept three or more arguments.
-#define TROMPELOEIL_ALLOW_CALL_T(obj, func, ...)                               \
-  TROMPELOEIL_REQUIRE_CALL_T(obj,                                              \
-                             func,                                             \
-                             .TROMPELOEIL_INFINITY_TIMES() __VA_ARGS__)
-
-
-#define TROMPELOEIL_NAMED_ALLOW_CALL_V(...)                                    \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_NAMED_ALLOW_CALL_IMPL TROMPELOEIL_LPAREN    \
-    TROMPELOEIL_MORE_THAN_TWO_ARGS(__VA_ARGS__), __VA_ARGS__))
-
-// Dispatch to _F (0, 1, or 2 arguments) or _T (> 2 arguments) macro
-#define TROMPELOEIL_NAMED_ALLOW_CALL_IMPL(N, ...)                              \
-  TROMPELOEIL_IDENTITY(                                                        \
-    TROMPELOEIL_NAMED_ALLOW_CALL_ ## N TROMPELOEIL_LPAREN __VA_ARGS__))
-
-// Accept only two arguments
-#define TROMPELOEIL_NAMED_ALLOW_CALL_F(obj, func)                              \
-  TROMPELOEIL_NAMED_REQUIRE_CALL_T(obj, func, .TROMPELOEIL_INFINITY_TIMES())
-
-// Accept three or more arguments.
-#define TROMPELOEIL_NAMED_ALLOW_CALL_T(obj, func, ...)                         \
-  TROMPELOEIL_NAMED_REQUIRE_CALL_T(obj,                                        \
-                                   func,                                       \
-                                   .TROMPELOEIL_INFINITY_TIMES()               \
-                                   __VA_ARGS__)
-
-
-#define TROMPELOEIL_FORBID_CALL_V(...)                                         \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_FORBID_CALL_IMPL TROMPELOEIL_LPAREN         \
-    TROMPELOEIL_MORE_THAN_TWO_ARGS(__VA_ARGS__), __VA_ARGS__))
-
-// Dispatch to _F (0, 1, or 2 arguments) or _T (> 2 arguments) macro
-#define TROMPELOEIL_FORBID_CALL_IMPL(N, ...)                                   \
-  TROMPELOEIL_IDENTITY(                                                        \
-    TROMPELOEIL_FORBID_CALL_ ## N TROMPELOEIL_LPAREN __VA_ARGS__))
-
-// Accept only two arguments
-#define TROMPELOEIL_FORBID_CALL_F(obj, func)                                   \
-  TROMPELOEIL_REQUIRE_CALL_T(obj, func, .TROMPELOEIL_TIMES(0))
-
-// Accept three or more arguments.
-#define TROMPELOEIL_FORBID_CALL_T(obj, func, ...)                              \
-  TROMPELOEIL_REQUIRE_CALL_T(obj,                                              \
-                             func,                                             \
-                             .TROMPELOEIL_TIMES(0) __VA_ARGS__)
-
-
-#define TROMPELOEIL_NAMED_FORBID_CALL_V(...)                                   \
-  TROMPELOEIL_IDENTITY(TROMPELOEIL_NAMED_FORBID_CALL_IMPL TROMPELOEIL_LPAREN   \
-    TROMPELOEIL_MORE_THAN_TWO_ARGS(__VA_ARGS__), __VA_ARGS__))
-
-// Dispatch to _F (0, 1, or 2 arguments) or _T (> 2 arguments) macro
-#define TROMPELOEIL_NAMED_FORBID_CALL_IMPL(N, ...)                             \
-  TROMPELOEIL_IDENTITY(                                                        \
-    TROMPELOEIL_NAMED_FORBID_CALL_ ## N TROMPELOEIL_LPAREN __VA_ARGS__))
-
-// Accept only two arguments
-#define TROMPELOEIL_NAMED_FORBID_CALL_F(obj, func)                             \
-  TROMPELOEIL_NAMED_REQUIRE_CALL_T(obj, func, .TROMPELOEIL_TIMES(0))
-
-// Accept three or more arguments.
-#define TROMPELOEIL_NAMED_FORBID_CALL_T(obj, func, ...)                        \
-  TROMPELOEIL_NAMED_REQUIRE_CALL_T(obj,                                        \
-                                   func,                                       \
-                                   .TROMPELOEIL_TIMES(0) __VA_ARGS__)
-
-
-#if (TROMPELOEIL_CPLUSPLUS > 201103L)
-
-#define TROMPELOEIL_REQUIRE_CALL(obj, func)                                    \
-  TROMPELOEIL_REQUIRE_CALL_(obj, func, #obj, #func)
-
-#define TROMPELOEIL_REQUIRE_CALL_(obj, func, obj_s, func_s)                    \
-  auto TROMPELOEIL_COUNT_ID(call_obj) = TROMPELOEIL_REQUIRE_CALL_OBJ(obj, func,\
-                                                               obj_s, func_s)
-
-#define TROMPELOEIL_NAMED_REQUIRE_CALL(obj, func)                              \
-  TROMPELOEIL_NAMED_REQUIRE_CALL_(obj, func, #obj, #func)
-
-#define TROMPELOEIL_NAMED_REQUIRE_CALL_(obj, func, obj_s, func_s)              \
-  TROMPELOEIL_REQUIRE_CALL_OBJ(obj, func, obj_s, func_s)
-
-
-#define TROMPELOEIL_REQUIRE_CALL_OBJ(obj, func, obj_s, func_s)                 \
-  ::trompeloeil::call_validator_t<decltype((obj).TROMPELOEIL_CONCAT(trompeloeil_self_, func))>{(obj)} + \
-    ::trompeloeil::detail::conditional_t<false,                                \
-                       decltype((obj).func),                                   \
-                       decltype((obj).TROMPELOEIL_CONCAT(trompeloeil_tag_,func))>\
-    {__FILE__, static_cast<unsigned long>(__LINE__), obj_s "." func_s}.func
-
-
-#define TROMPELOEIL_ALLOW_CALL(obj, func)                                      \
-  TROMPELOEIL_ALLOW_CALL_(obj, func, #obj, #func)
-
-#define TROMPELOEIL_ALLOW_CALL_(obj, func, obj_s, func_s)                      \
-  TROMPELOEIL_REQUIRE_CALL_(obj, func, obj_s, func_s)                          \
-    .TROMPELOEIL_INFINITY_TIMES()
-
-
-#define TROMPELOEIL_NAMED_ALLOW_CALL(obj, func)                                \
-  TROMPELOEIL_NAMED_ALLOW_CALL_(obj, func, #obj, #func)
-
-#define TROMPELOEIL_NAMED_ALLOW_CALL_(obj, func, obj_s, func_s)                \
-  TROMPELOEIL_NAMED_REQUIRE_CALL_(obj, func, obj_s, func_s)                    \
-    .TROMPELOEIL_INFINITY_TIMES()
-
-
-#define TROMPELOEIL_FORBID_CALL(obj, func)                                     \
-  TROMPELOEIL_FORBID_CALL_(obj, func, #obj, #func)
-
-#define TROMPELOEIL_FORBID_CALL_(obj, func, obj_s, func_s)                     \
-  TROMPELOEIL_REQUIRE_CALL_(obj, func, obj_s, func_s)                          \
-    .TROMPELOEIL_TIMES(0)
-
-
-#define TROMPELOEIL_NAMED_FORBID_CALL(obj, func)                               \
-  TROMPELOEIL_NAMED_FORBID_CALL_(obj, func, #obj, #func)
-
-#define TROMPELOEIL_NAMED_FORBID_CALL_(obj, func, obj_s, func_s)               \
-  TROMPELOEIL_NAMED_REQUIRE_CALL_(obj, func, obj_s, func_s)                    \
-    .TROMPELOEIL_TIMES(0)
-
-#endif /* (TROMPELOEIL_CPLUSPLUS > 201103L) */
-
-
-#define TROMPELOEIL_WITH(...)    TROMPELOEIL_WITH_(=,#__VA_ARGS__, __VA_ARGS__)
-#define TROMPELOEIL_LR_WITH(...) TROMPELOEIL_WITH_(&,#__VA_ARGS__, __VA_ARGS__)
-
-
-#if (TROMPELOEIL_CPLUSPLUS == 201103L)
-
-#define TROMPELOEIL_WITH_(capture, arg_s, ...)                                 \
-  with(                                                                        \
-    arg_s,                                                                     \
-    [capture]                                                                  \
-    (typename trompeloeil_e_t::trompeloeil_call_params_type_t const& trompeloeil_x)\
-    {                                                                          \
-      auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                      \
-      auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                      \
-      auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                      \
-      auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                      \
-      auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                      \
-      auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                      \
-      auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                      \
-      auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                      \
-      auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                      \
-      auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                     \
-      auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                     \
-      auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                     \
-      auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                     \
-      auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                     \
-      auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                     \
-      ::trompeloeil::ignore(                                                   \
-        _1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15);                   \
-      return __VA_ARGS__;                                                      \
-    })
-
-#else /* (TROMPELOEIL_CPLUSPLUS == 201103L) */
-
-#define TROMPELOEIL_WITH_(capture, arg_s, ...)                                 \
-  with(arg_s, [capture](auto const& trompeloeil_x) {                           \
-    auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                        \
-    auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                        \
-    auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                        \
-    auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                        \
-    auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                        \
-    auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                        \
-    auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                        \
-    auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                        \
-    auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                        \
-    auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                       \
-    auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                       \
-    auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                       \
-    auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                       \
-    auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                       \
-    auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                       \
-    ::trompeloeil::ignore(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15); \
-    return __VA_ARGS__;                                                        \
-  })
-
-#endif /* !(TROMPELOEIL_CPLUSPLUS == 201103L) */
-
-
-#define TROMPELOEIL_SIDE_EFFECT(...)    TROMPELOEIL_SIDE_EFFECT_(=, __VA_ARGS__)
-#define TROMPELOEIL_LR_SIDE_EFFECT(...) TROMPELOEIL_SIDE_EFFECT_(&, __VA_ARGS__)
-
-
-#if (TROMPELOEIL_CPLUSPLUS == 201103L)
-
-#define TROMPELOEIL_SIDE_EFFECT_(capture, ...)                                 \
-  sideeffect(                                                                  \
-    [capture]                                                                  \
-    (typename trompeloeil_e_t::trompeloeil_call_params_type_t& trompeloeil_x)  \
-    {                                                                          \
-      auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                      \
-      auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                      \
-      auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                      \
-      auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                      \
-      auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                      \
-      auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                      \
-      auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                      \
-      auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                      \
-      auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                      \
-      auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                     \
-      auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                     \
-      auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                     \
-      auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                     \
-      auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                     \
-      auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                     \
-      ::trompeloeil::ignore(                                                   \
-        _1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15);                   \
-      __VA_ARGS__;                                                             \
-    })
-
-#else /* (TROMPELOEIL_CPLUSPLUS == 201103L) */
-
-#define TROMPELOEIL_SIDE_EFFECT_(capture, ...)                                 \
-  sideeffect([capture](auto& trompeloeil_x) {                                  \
-    auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                        \
-    auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                        \
-    auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                        \
-    auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                        \
-    auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                        \
-    auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                        \
-    auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                        \
-    auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                        \
-    auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                        \
-    auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                       \
-    auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                       \
-    auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                       \
-    auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                       \
-    auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                       \
-    auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                       \
-    ::trompeloeil::ignore(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15); \
-    __VA_ARGS__;                                                               \
-  })
-
-#endif /* !(TROMPELOEIL_CPLUSPLUS == 201103L) */
-
-
-#define TROMPELOEIL_RETURN(...)    TROMPELOEIL_RETURN_(=, __VA_ARGS__)
-#define TROMPELOEIL_LR_RETURN(...) TROMPELOEIL_RETURN_(&, __VA_ARGS__)
-
-
-#if (TROMPELOEIL_CPLUSPLUS == 201103L)
-
-#define TROMPELOEIL_RETURN_(capture, ...)                                      \
-  handle_return(                                                               \
-    [capture]                                                                  \
-    (typename trompeloeil_e_t::trompeloeil_call_params_type_t& trompeloeil_x)  \
-      -> typename trompeloeil_e_t::trompeloeil_return_of_t                     \
-    {                                                                          \
-      auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                      \
-      auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                      \
-      auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                      \
-      auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                      \
-      auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                      \
-      auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                      \
-      auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                      \
-      auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                      \
-      auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                      \
-      auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                     \
-      auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                     \
-      auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                     \
-      auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                     \
-      auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                     \
-      auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                     \
-      ::trompeloeil::ignore(                                                   \
-        _1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15);                   \
-      return ::trompeloeil::decay_return_type(__VA_ARGS__);                    \
-    })
-
-#else /* (TROMPELOEIL_CPLUSPLUS == 201103L) */
-
-#define TROMPELOEIL_RETURN_(capture, ...)                                      \
-  handle_return([capture](auto& trompeloeil_x) -> decltype(auto) {             \
-    auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                        \
-    auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                        \
-    auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                        \
-    auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                        \
-    auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                        \
-    auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                        \
-    auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                        \
-    auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                        \
-    auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                        \
-    auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                       \
-    auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                       \
-    auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                       \
-    auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                       \
-    auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                       \
-    auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                       \
-    ::trompeloeil::ignore(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15); \
-    return ::trompeloeil::decay_return_type(__VA_ARGS__);                      \
-  })
-
-#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
-
-#define TROMPELOEIL_CO_RETURN(...)    TROMPELOEIL_CO_RETURN_(=, __VA_ARGS__)
-#define TROMPELOEIL_LR_CO_RETURN(...) TROMPELOEIL_CO_RETURN_(&, __VA_ARGS__)
-
-#define TROMPELOEIL_CO_RETURN_(capture, ...) \
-  handle_co_return([capture](auto& trompeloeil_x) -> decltype(auto) { \
-    auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                        \
-    auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                        \
-    auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                        \
-    auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                        \
-    auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                        \
-    auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                        \
-    auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                        \
-    auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                        \
-    auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                        \
-    auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                       \
-    auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                       \
-    auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                       \
-    auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                       \
-    auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                       \
-    auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                       \
-    ::trompeloeil::ignore(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15); \
-    return ::trompeloeil::decay_return_type(__VA_ARGS__);                      \
-  })
-
-#endif
-
-#endif /* !(TROMPELOEIL_CPLUSPLUS == 201103L) */
-
-
-#define TROMPELOEIL_THROW(...)    TROMPELOEIL_THROW_(=, __VA_ARGS__)
-#define TROMPELOEIL_LR_THROW(...) TROMPELOEIL_THROW_(&, __VA_ARGS__)
-
-
-#if (TROMPELOEIL_CPLUSPLUS == 201103L)
-
-#define TROMPELOEIL_THROW_(capture, ...)                                       \
-  handle_throw(                                                                \
-    [capture]                                                                  \
-    (typename trompeloeil_e_t::trompeloeil_call_params_type_t& trompeloeil_x)  \
-    {                                                                          \
-      auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                      \
-      auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                      \
-      auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                      \
-      auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                      \
-      auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                      \
-      auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                      \
-      auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                      \
-      auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                      \
-      auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                      \
-      auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                     \
-      auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                     \
-      auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                     \
-      auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                     \
-      auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                     \
-      auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                     \
-      ::trompeloeil::ignore(                                                   \
-        _1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15);                   \
-      throw __VA_ARGS__;                                                       \
-    })
-
-#else /* (TROMPELOEIL_CPLUSPLUS == 201103L) */
-
-#define TROMPELOEIL_THROW_(capture, ...)                                       \
-  handle_throw([capture](auto& trompeloeil_x)  {                               \
-    auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                        \
-    auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                        \
-    auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                        \
-    auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                        \
-    auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                        \
-    auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                        \
-    auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                        \
-    auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                        \
-    auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                        \
-    auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                       \
-    auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                       \
-    auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                       \
-    auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                       \
-    auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                       \
-    auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                       \
-    ::trompeloeil::ignore(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15); \
-    throw __VA_ARGS__;                                                         \
- })
-
-#endif /* !(TROMPELOEIL_CPLUSPLUS == 201103L) */
-
-#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
-
-#define TROMPELOEIL_CO_THROW(...)    TROMPELOEIL_CO_THROW_(=, __VA_ARGS__)
-#define TROMPELOEIL_LR_CO_THROW(...) TROMPELOEIL_CO_THROW_(&, __VA_ARGS__)
-
-#define TROMPELOEIL_CO_THROW_(capture, ...)                                    \
-  handle_co_throw([capture](auto& trompeloeil_x)  {                            \
-    auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                        \
-    auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                        \
-    auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                        \
-    auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                        \
-    auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                        \
-    auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                        \
-    auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                        \
-    auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                        \
-    auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                        \
-    auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                       \
-    auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                       \
-    auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                       \
-    auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                       \
-    auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                       \
-    auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                       \
-    ::trompeloeil::ignore(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15); \
-    throw __VA_ARGS__;                                                         \
- })
-
-#define TROMPELOEIL_CO_YIELD(...)    TROMPELOEIL_CO_YIELD_(=, __VA_ARGS__)
-#define TROMPELOEIL_LR_CO_YIELD(...) TROMPELOEIL_CO_YIELD_(&, __VA_ARGS__)
-
-
-#define TROMPELOEIL_CO_YIELD_(capture, ...)                                   \
-  handle_co_yield([capture](auto& trompeloeil_x)  {                            \
-    auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                        \
-    auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                        \
-    auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                        \
-    auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                        \
-    auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                        \
-    auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                        \
-    auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                        \
-    auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                        \
-    auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                        \
-    auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                       \
-    auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                       \
-    auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                       \
-    auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                       \
-    auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                       \
-    auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                       \
-    ::trompeloeil::ignore(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15); \
-    return __VA_ARGS__;                                                         \
- })
-#endif
-
-
-#define TROMPELOEIL_TIMES(...) times(::trompeloeil::multiplicity<__VA_ARGS__>{})
-#define TROMPELOEIL_INFINITY_TIMES() TROMPELOEIL_TIMES(0, ~static_cast<size_t>(0))
-
-#define TROMPELOEIL_IN_SEQUENCE(...)                                           \
-  in_sequence(TROMPELOEIL_INIT_WITH_STR(::trompeloeil::sequence_matcher::init_type, __VA_ARGS__))
-
-#define TROMPELOEIL_ANY(type) ::trompeloeil::any_matcher<type>(#type)
-
-#define TROMPELOEIL_AT_LEAST(num) num, ~static_cast<size_t>(0)
-#define TROMPELOEIL_AT_MOST(num) 0, num
-
-#define TROMPELOEIL_REQUIRE_DESTRUCTION(obj)                                   \
-  TROMPELOEIL_REQUIRE_DESTRUCTION_(obj, #obj)
-
-#define TROMPELOEIL_REQUIRE_DESTRUCTION_(obj, obj_s)                           \
-  std::unique_ptr<trompeloeil::expectation>                                    \
-    TROMPELOEIL_CONCAT(trompeloeil_death_monitor_, __LINE__)                   \
-    = TROMPELOEIL_NAMED_REQUIRE_DESTRUCTION_(,obj, obj_s)
-
-#define TROMPELOEIL_NAMED_REQUIRE_DESTRUCTION(obj)                             \
-  TROMPELOEIL_NAMED_REQUIRE_DESTRUCTION_("NAMED_", obj, #obj)
-
-#define TROMPELOEIL_NAMED_REQUIRE_DESTRUCTION_(prefix, obj, obj_s)             \
-  trompeloeil::lifetime_monitor_releaser{} +                                   \
-  trompeloeil::lifetime_monitor_modifier<false>{                               \
-    ::trompeloeil::detail::make_unique<trompeloeil::lifetime_monitor>(         \
-      obj,                                                                     \
-      obj_s,                                                                   \
-      prefix "REQUIRE_DESTRUCTION(" obj_s ")",                                 \
-      "destructor for " obj_s,                                                 \
-      ::trompeloeil::location{__FILE__,                                        \
-                              static_cast<unsigned long>(__LINE__)})           \
-  }
-
-#ifndef TROMPELOEIL_LONG_MACROS
-#define MAKE_MOCK0                TROMPELOEIL_MAKE_MOCK0
-#define MAKE_MOCK1                TROMPELOEIL_MAKE_MOCK1
-#define MAKE_MOCK2                TROMPELOEIL_MAKE_MOCK2
-#define MAKE_MOCK3                TROMPELOEIL_MAKE_MOCK3
-#define MAKE_MOCK4                TROMPELOEIL_MAKE_MOCK4
-#define MAKE_MOCK5                TROMPELOEIL_MAKE_MOCK5
-#define MAKE_MOCK6                TROMPELOEIL_MAKE_MOCK6
-#define MAKE_MOCK7                TROMPELOEIL_MAKE_MOCK7
-#define MAKE_MOCK8                TROMPELOEIL_MAKE_MOCK8
-#define MAKE_MOCK9                TROMPELOEIL_MAKE_MOCK9
-#define MAKE_MOCK10               TROMPELOEIL_MAKE_MOCK10
-#define MAKE_MOCK11               TROMPELOEIL_MAKE_MOCK11
-#define MAKE_MOCK12               TROMPELOEIL_MAKE_MOCK12
-#define MAKE_MOCK13               TROMPELOEIL_MAKE_MOCK13
-#define MAKE_MOCK14               TROMPELOEIL_MAKE_MOCK14
-#define MAKE_MOCK15               TROMPELOEIL_MAKE_MOCK15
-
-#define MAKE_CONST_MOCK0          TROMPELOEIL_MAKE_CONST_MOCK0
-#define MAKE_CONST_MOCK1          TROMPELOEIL_MAKE_CONST_MOCK1
-#define MAKE_CONST_MOCK2          TROMPELOEIL_MAKE_CONST_MOCK2
-#define MAKE_CONST_MOCK3          TROMPELOEIL_MAKE_CONST_MOCK3
-#define MAKE_CONST_MOCK4          TROMPELOEIL_MAKE_CONST_MOCK4
-#define MAKE_CONST_MOCK5          TROMPELOEIL_MAKE_CONST_MOCK5
-#define MAKE_CONST_MOCK6          TROMPELOEIL_MAKE_CONST_MOCK6
-#define MAKE_CONST_MOCK7          TROMPELOEIL_MAKE_CONST_MOCK7
-#define MAKE_CONST_MOCK8          TROMPELOEIL_MAKE_CONST_MOCK8
-#define MAKE_CONST_MOCK9          TROMPELOEIL_MAKE_CONST_MOCK9
-#define MAKE_CONST_MOCK10         TROMPELOEIL_MAKE_CONST_MOCK10
-#define MAKE_CONST_MOCK11         TROMPELOEIL_MAKE_CONST_MOCK11
-#define MAKE_CONST_MOCK12         TROMPELOEIL_MAKE_CONST_MOCK12
-#define MAKE_CONST_MOCK13         TROMPELOEIL_MAKE_CONST_MOCK13
-#define MAKE_CONST_MOCK14         TROMPELOEIL_MAKE_CONST_MOCK14
-#define MAKE_CONST_MOCK15         TROMPELOEIL_MAKE_CONST_MOCK15
-
-#define IMPLEMENT_MOCK0           TROMPELOEIL_IMPLEMENT_MOCK0
-#define IMPLEMENT_MOCK1           TROMPELOEIL_IMPLEMENT_MOCK1
-#define IMPLEMENT_MOCK2           TROMPELOEIL_IMPLEMENT_MOCK2
-#define IMPLEMENT_MOCK3           TROMPELOEIL_IMPLEMENT_MOCK3
-#define IMPLEMENT_MOCK4           TROMPELOEIL_IMPLEMENT_MOCK4
-#define IMPLEMENT_MOCK5           TROMPELOEIL_IMPLEMENT_MOCK5
-#define IMPLEMENT_MOCK6           TROMPELOEIL_IMPLEMENT_MOCK6
-#define IMPLEMENT_MOCK7           TROMPELOEIL_IMPLEMENT_MOCK7
-#define IMPLEMENT_MOCK8           TROMPELOEIL_IMPLEMENT_MOCK8
-#define IMPLEMENT_MOCK9           TROMPELOEIL_IMPLEMENT_MOCK9
-#define IMPLEMENT_MOCK10          TROMPELOEIL_IMPLEMENT_MOCK10
-#define IMPLEMENT_MOCK11          TROMPELOEIL_IMPLEMENT_MOCK11
-#define IMPLEMENT_MOCK12          TROMPELOEIL_IMPLEMENT_MOCK12
-#define IMPLEMENT_MOCK13          TROMPELOEIL_IMPLEMENT_MOCK13
-#define IMPLEMENT_MOCK14          TROMPELOEIL_IMPLEMENT_MOCK14
-#define IMPLEMENT_MOCK15          TROMPELOEIL_IMPLEMENT_MOCK15
-
-#define IMPLEMENT_CONST_MOCK0     TROMPELOEIL_IMPLEMENT_CONST_MOCK0
-#define IMPLEMENT_CONST_MOCK1     TROMPELOEIL_IMPLEMENT_CONST_MOCK1
-#define IMPLEMENT_CONST_MOCK2     TROMPELOEIL_IMPLEMENT_CONST_MOCK2
-#define IMPLEMENT_CONST_MOCK3     TROMPELOEIL_IMPLEMENT_CONST_MOCK3
-#define IMPLEMENT_CONST_MOCK4     TROMPELOEIL_IMPLEMENT_CONST_MOCK4
-#define IMPLEMENT_CONST_MOCK5     TROMPELOEIL_IMPLEMENT_CONST_MOCK5
-#define IMPLEMENT_CONST_MOCK6     TROMPELOEIL_IMPLEMENT_CONST_MOCK6
-#define IMPLEMENT_CONST_MOCK7     TROMPELOEIL_IMPLEMENT_CONST_MOCK7
-#define IMPLEMENT_CONST_MOCK8     TROMPELOEIL_IMPLEMENT_CONST_MOCK8
-#define IMPLEMENT_CONST_MOCK9     TROMPELOEIL_IMPLEMENT_CONST_MOCK9
-#define IMPLEMENT_CONST_MOCK10    TROMPELOEIL_IMPLEMENT_CONST_MOCK10
-#define IMPLEMENT_CONST_MOCK11    TROMPELOEIL_IMPLEMENT_CONST_MOCK11
-#define IMPLEMENT_CONST_MOCK12    TROMPELOEIL_IMPLEMENT_CONST_MOCK12
-#define IMPLEMENT_CONST_MOCK13    TROMPELOEIL_IMPLEMENT_CONST_MOCK13
-#define IMPLEMENT_CONST_MOCK14    TROMPELOEIL_IMPLEMENT_CONST_MOCK14
-#define IMPLEMENT_CONST_MOCK15    TROMPELOEIL_IMPLEMENT_CONST_MOCK15
-
-#define REQUIRE_CALL_V            TROMPELOEIL_REQUIRE_CALL_V
-#define NAMED_REQUIRE_CALL_V      TROMPELOEIL_NAMED_REQUIRE_CALL_V
-#define ALLOW_CALL_V              TROMPELOEIL_ALLOW_CALL_V
-#define NAMED_ALLOW_CALL_V        TROMPELOEIL_NAMED_ALLOW_CALL_V
-#define FORBID_CALL_V             TROMPELOEIL_FORBID_CALL_V
-#define NAMED_FORBID_CALL_V       TROMPELOEIL_NAMED_FORBID_CALL_V
-
-#if (TROMPELOEIL_CPLUSPLUS > 201103L)
-
-#define REQUIRE_CALL              TROMPELOEIL_REQUIRE_CALL
-#define NAMED_REQUIRE_CALL        TROMPELOEIL_NAMED_REQUIRE_CALL
-#define ALLOW_CALL                TROMPELOEIL_ALLOW_CALL
-#define NAMED_ALLOW_CALL          TROMPELOEIL_NAMED_ALLOW_CALL
-#define FORBID_CALL               TROMPELOEIL_FORBID_CALL
-#define NAMED_FORBID_CALL         TROMPELOEIL_NAMED_FORBID_CALL
-
-#endif /* (TROMPELOEIL_CPLUSPLUS > 201103L) */
-
-#define WITH                      TROMPELOEIL_WITH
-#define LR_WITH                   TROMPELOEIL_LR_WITH
-#define SIDE_EFFECT               TROMPELOEIL_SIDE_EFFECT
-#define LR_SIDE_EFFECT            TROMPELOEIL_LR_SIDE_EFFECT
-#define RETURN                    TROMPELOEIL_RETURN
-#define LR_RETURN                 TROMPELOEIL_LR_RETURN
-#define THROW                     TROMPELOEIL_THROW
-#define LR_THROW                  TROMPELOEIL_LR_THROW
-#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
-#define CO_RETURN                 TROMPELOEIL_CO_RETURN
-#define LR_CO_RETURN              TROMPELOEIL_LR_CO_RETURN
-#define CO_THROW                  TROMPELOEIL_CO_THROW
-#define LR_CO_THROW               TROMPELOEIL_LR_CO_THROW
-#define CO_YIELD                  TROMPELOEIL_CO_YIELD
-#define LR_CO_YIELD               TROMPELOEIL_LR_CO_YIELD
-#endif
-#define TIMES                     TROMPELOEIL_TIMES
-#define IN_SEQUENCE               TROMPELOEIL_IN_SEQUENCE
-#define ANY                       TROMPELOEIL_ANY
-#define AT_LEAST                  TROMPELOEIL_AT_LEAST
-#define AT_MOST                   TROMPELOEIL_AT_MOST
-#define REQUIRE_DESTRUCTION       TROMPELOEIL_REQUIRE_DESTRUCTION
-#define NAMED_REQUIRE_DESTRUCTION TROMPELOEIL_NAMED_REQUIRE_DESTRUCTION
-
-#endif // TROMPELOEIL_LONG_MACROS
+#include "trompeloeil/mock.hpp"
 
 #endif // include guard
diff --git a/include/trompeloeil/mock.hpp b/include/trompeloeil/mock.hpp
new file mode 100644
index 00000000..f33c7aa8
--- /dev/null
+++ b/include/trompeloeil/mock.hpp
@@ -0,0 +1,5915 @@
+/*
+ * Trompeloeil C++ mocking framework
+ *
+ * Copyright (C) Björn Fahller
+ * Copyright (C) 2017, 2018 Andrew Paxie
+ * Copyright Tore Martin Hagen 2019
+ *
+ *  Use, modification and distribution is subject to the
+ *  Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy atl
+ *  http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * Project home: https://github.com/rollbear/trompeloeil
+ */
+
+
+#ifndef TROMPELOEIL_MOCK_HPP_
+#define TROMPELOEIL_MOCK_HPP_
+
+
+// trompe l'oeil noun    (Concise Encyclopedia)
+// Style of representation in which a painted object is intended
+// to deceive the viewer into believing it is the object itself...
+
+// project home: https://github.com/rollbear/trompeloeil
+
+
+// Deficiencies and missing features
+// * Mocking function templates is not supported
+// * If a macro kills a kitten, this threatens extinction of all felines!
+
+#if defined(TROMPELOEIL_EXPERIMENTAL_COROUTINES)
+#  if defined(__cpp_impl_coroutine)
+#    define TROMPELOEIL_COROUTINES_SUPPORTED 1
+#  else
+#    error "Coroutines are not supported by this compiler"
+#  endif
+#endif
+
+#if defined(_MSC_VER)
+
+#  define TROMPELOEIL_NORETURN __declspec(noreturn)
+
+#  if (!defined(__cplusplus) || _MSC_VER < 1900)
+#    error requires C++ in Visual Studio 2015 RC or later
+#  endif
+
+#else
+
+#  define TROMPELOEIL_NORETURN [[noreturn]]
+
+#  if (!defined(__cplusplus) || __cplusplus < 201103L)
+#    error requires C++11 or higher
+#  endif
+
+#endif
+
+#if defined(__clang__)
+
+#  define TROMPELOEIL_CLANG 1
+#  define TROMPELOEIL_GCC 0
+#  define TROMPELOEIL_MSVC 0
+
+#  define TROMPELOEIL_CLANG_VERSION \
+  (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__)
+
+#  define TROMPELOEIL_GCC_VERSION 0
+
+#  define TROMPELOEIL_CPLUSPLUS __cplusplus
+
+#  define TROMPELOEIL_NOT_IMPLEMENTED(...)                         \
+  _Pragma("clang diagnostic push")                                   \
+  _Pragma("clang diagnostic ignored \"-Wunneeded-member-function\"") \
+  __VA_ARGS__                                                        \
+  _Pragma("clang diagnostic pop")
+
+#elif defined(__GNUC__)
+
+#  define TROMPELOEIL_CLANG 0
+#  define TROMPELOEIL_GCC 1
+#  define TROMPELOEIL_MSVC 0
+
+#  define TROMPELOEIL_CLANG_VERSION 0
+#  define TROMPELOEIL_GCC_VERSION \
+  (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
+
+#  define TROMPELOEIL_CPLUSPLUS __cplusplus
+
+#elif defined(_MSC_VER)
+
+#  define TROMPELOEIL_CLANG 0
+#  define TROMPELOEIL_GCC 0
+#  define TROMPELOEIL_MSVC 1
+
+#  define TROMPELOEIL_CLANG_VERSION 0
+#  define TROMPELOEIL_GCC_VERSION 0
+
+#  if defined(_MSVC_LANG)
+
+    // Compiler is at least Microsoft Visual Studio 2015 Update 3.
+#    define TROMPELOEIL_CPLUSPLUS _MSVC_LANG
+
+#  else /* defined(_MSVC_LANG) */
+
+    /*
+     * This version of Microsoft Visual C++ is released
+     * in a version of Microsoft Visual Studio between
+     * 2015 RC and less than 2015 Update 3.
+     *
+     * It is an amalgam of C++ versions, with no provision
+     * to specify C++11 mode.
+     *
+     * It also has a __cplusplus macro stuck at 199711L with
+     * no way to change it, such as /Zc:__cplusplus.
+     *
+     * Assume the C++14 code path, but don't promise that it is a
+     * fully conforming implementation of C++14 either.
+     * Hence a value of 201401L, which less than 201402L,
+     * the standards conforming value of __cplusplus.
+     */
+#    define TROMPELOEIL_CPLUSPLUS 201401L
+
+#  endif /* !defined(_MSVC_LANG) */
+
+#endif
+
+
+#ifndef TROMPELOEIL_NOT_IMPLEMENTED
+#define TROMPELOEIL_NOT_IMPLEMENTED(...) __VA_ARGS__
+#endif
+
+#include <algorithm>
+#include <tuple>
+#include <iomanip>
+#include <sstream>
+#include <exception>
+#include <functional>
+#include <memory>
+#include <cstring>
+#include <regex>
+#include <mutex>
+#include <atomic>
+#include <array>
+#include <initializer_list>
+#include <type_traits>
+#include <utility>
+
+
+#ifndef TROMPELOEIL_CUSTOM_ATOMIC
+#include <atomic>
+namespace trompeloeil { using std::atomic; }
+#else
+#include <trompeloeil/custom_atomic.hpp>
+#endif
+
+#ifndef TROMPELOEIL_CUSTOM_UNIQUE_LOCK
+namespace trompeloeil { using std::unique_lock; }
+#else
+#include <trompeloeil/custom_unique_lock.hpp>
+#endif
+
+#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
+#include <coroutine>
+#endif
+
+#ifdef TROMPELOEIL_SANITY_CHECKS
+#include <cassert>
+#define TROMPELOEIL_ASSERT(x) assert(x)
+#else
+#define TROMPELOEIL_ASSERT(x) do {} while (false)
+#endif
+
+#define TROMPELOEIL_IDENTITY(...) __VA_ARGS__ // work around stupid MS VS2015 RC bug
+
+#define TROMPELOEIL_ARG16(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15, ...) _15
+
+#define TROMPELOEIL_COUNT(...)                                                 \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_ARG16(__VA_ARGS__,                          \
+                                         15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0))
+
+#if TROMPELOEIL_MSVC
+
+#define TROMPELOEIL_CONCAT_(x, y, ...) x ## y __VA_ARGS__
+#define TROMPELOEIL_CONCAT(x, ...) TROMPELOEIL_CONCAT_(x, __VA_ARGS__)
+
+#else /* TROMPELOEIL_MSVC */
+
+#define TROMPELOEIL_CONCAT_(x, ...) x ## __VA_ARGS__
+#define TROMPELOEIL_CONCAT(x, ...) TROMPELOEIL_CONCAT_(x, __VA_ARGS__)
+
+#endif /* !TROMPELOEIL_MSVC */
+
+#define TROMPELOEIL_SEPARATE1(p1) p1
+#define TROMPELOEIL_SEPARATE2(p1,p2) p1 p2
+#define TROMPELOEIL_SEPARATE3(p1,...) p1 TROMPELOEIL_SEPARATE2(__VA_ARGS__)
+#define TROMPELOEIL_SEPARATE4(p1,...) p1 TROMPELOEIL_SEPARATE3(__VA_ARGS__)
+#define TROMPELOEIL_SEPARATE5(p1,...) p1 TROMPELOEIL_SEPARATE4(__VA_ARGS__)
+#define TROMPELOEIL_SEPARATE6(p1,...) p1 TROMPELOEIL_SEPARATE5(__VA_ARGS__)
+#define TROMPELOEIL_SEPARATE7(p1,...) p1 TROMPELOEIL_SEPARATE6(__VA_ARGS__)
+#define TROMPELOEIL_SEPARATE8(p1,...) p1 TROMPELOEIL_SEPARATE7(__VA_ARGS__)
+#define TROMPELOEIL_SEPARATE9(p1,...) p1 TROMPELOEIL_SEPARATE8(__VA_ARGS__)
+#define TROMPELOEIL_SEPARATE(...) \
+  TROMPELOEIL_CONCAT(TROMPELOEIL_SEPARATE,\
+                     TROMPELOEIL_COUNT(__VA_ARGS__))(__VA_ARGS__)
+
+
+#define TROMPELOEIL_REMOVE_PAREN(...) TROMPELOEIL_CONCAT(TROMPELOEIL_CLEAR_,   \
+  TROMPELOEIL_REMOVE_PAREN_INTERNAL __VA_ARGS__)
+#define TROMPELOEIL_REMOVE_PAREN_INTERNAL(...)                                 \
+  TROMPELOEIL_REMOVE_PAREN_INTERNAL __VA_ARGS__
+#define TROMPELOEIL_CLEAR_TROMPELOEIL_REMOVE_PAREN_INTERNAL
+
+#define TROMPELOEIL_EXPAND(x) x
+
+#define TROMPELOEIL_INIT_WITH_STR15(base, x, ...)                              \
+  base{#x, x}, TROMPELOEIL_EXPAND(TROMPELOEIL_INIT_WITH_STR14(base, __VA_ARGS__))
+
+#define TROMPELOEIL_INIT_WITH_STR14(base, x, ...)                              \
+  base{#x, x}, TROMPELOEIL_EXPAND(TROMPELOEIL_INIT_WITH_STR13(base, __VA_ARGS__))
+
+#define TROMPELOEIL_INIT_WITH_STR13(base, x, ...)                              \
+  base{#x, x}, TROMPELOEIL_EXPAND(TROMPELOEIL_INIT_WITH_STR12(base, __VA_ARGS__))
+
+#define TROMPELOEIL_INIT_WITH_STR12(base, x, ...)                              \
+  base{#x, x}, TROMPELOEIL_EXPAND(TROMPELOEIL_INIT_WITH_STR11(base, __VA_ARGS__))
+
+#define TROMPELOEIL_INIT_WITH_STR11(base, x, ...)                              \
+  base{#x, x}, TROMPELOEIL_EXPAND(TROMPELOEIL_INIT_WITH_STR10(base, __VA_ARGS__))
+
+#define TROMPELOEIL_INIT_WITH_STR10(base, x, ...)                              \
+  base{#x, x}, TROMPELOEIL_EXPAND(TROMPELOEIL_INIT_WITH_STR9(base, __VA_ARGS__))
+
+#define TROMPELOEIL_INIT_WITH_STR9(base, x, ...)                               \
+  base{#x, x}, TROMPELOEIL_EXPAND(TROMPELOEIL_INIT_WITH_STR8(base, __VA_ARGS__))
+
+#define TROMPELOEIL_INIT_WITH_STR8(base, x, ...)                               \
+  base{#x, x}, TROMPELOEIL_EXPAND(TROMPELOEIL_INIT_WITH_STR7(base, __VA_ARGS__))
+
+#define TROMPELOEIL_INIT_WITH_STR7(base, x, ...)                               \
+  base{#x, x}, TROMPELOEIL_EXPAND(TROMPELOEIL_INIT_WITH_STR6(base, __VA_ARGS__))
+
+#define TROMPELOEIL_INIT_WITH_STR6(base, x, ...)                               \
+  base{#x, x}, TROMPELOEIL_EXPAND(TROMPELOEIL_INIT_WITH_STR5(base, __VA_ARGS__))
+
+#define TROMPELOEIL_INIT_WITH_STR5(base, x, ...)                               \
+  base{#x, x}, TROMPELOEIL_EXPAND(TROMPELOEIL_INIT_WITH_STR4(base, __VA_ARGS__))
+
+#define TROMPELOEIL_INIT_WITH_STR4(base, x, ...)                               \
+  base{#x, x}, TROMPELOEIL_EXPAND(TROMPELOEIL_INIT_WITH_STR3(base, __VA_ARGS__))
+
+#define TROMPELOEIL_INIT_WITH_STR3(base, x, ...)                               \
+  base{#x, x}, TROMPELOEIL_EXPAND(TROMPELOEIL_INIT_WITH_STR2(base, __VA_ARGS__))
+
+#define TROMPELOEIL_INIT_WITH_STR2(base, x, ...)                               \
+  base{#x, x}, TROMPELOEIL_EXPAND(TROMPELOEIL_INIT_WITH_STR1(base, __VA_ARGS__))
+
+#define TROMPELOEIL_INIT_WITH_STR1(base, x)                                    \
+  base{#x, x}
+
+#define TROMPELOEIL_INIT_WITH_STR0(base)
+
+#define TROMPELOEIL_INIT_WITH_STR(base, ...)                                   \
+  TROMPELOEIL_CONCAT(TROMPELOEIL_INIT_WITH_STR,                                \
+                     TROMPELOEIL_COUNT(__VA_ARGS__))(base, __VA_ARGS__)
+
+#define TROMPELOEIL_PARAM_LIST15(...)                                          \
+  TROMPELOEIL_PARAM_LIST14(__VA_ARGS__),                                       \
+  ::trompeloeil::param_list_t<__VA_ARGS__, 14> p15
+
+#define TROMPELOEIL_PARAM_LIST14(...)                                          \
+  TROMPELOEIL_PARAM_LIST13(__VA_ARGS__),                                       \
+  ::trompeloeil::param_list_t<__VA_ARGS__, 13> p14
+
+#define TROMPELOEIL_PARAM_LIST13(...)                                          \
+  TROMPELOEIL_PARAM_LIST12(__VA_ARGS__),                                       \
+  ::trompeloeil::param_list_t<__VA_ARGS__, 12> p13
+
+#define TROMPELOEIL_PARAM_LIST12(...)                                          \
+  TROMPELOEIL_PARAM_LIST11(__VA_ARGS__),                                       \
+  ::trompeloeil::param_list_t<__VA_ARGS__, 11> p12
+
+#define TROMPELOEIL_PARAM_LIST11(...)                                          \
+  TROMPELOEIL_PARAM_LIST10(__VA_ARGS__),                                       \
+  ::trompeloeil::param_list_t<__VA_ARGS__, 10> p11
+
+#define TROMPELOEIL_PARAM_LIST10(...)                                          \
+  TROMPELOEIL_PARAM_LIST9(__VA_ARGS__),                                        \
+  ::trompeloeil::param_list_t<__VA_ARGS__, 9> p10
+
+#define TROMPELOEIL_PARAM_LIST9(...)                                           \
+  TROMPELOEIL_PARAM_LIST8(__VA_ARGS__),                                        \
+  ::trompeloeil::param_list_t<__VA_ARGS__, 8> p9
+
+#define TROMPELOEIL_PARAM_LIST8(...)                                           \
+  TROMPELOEIL_PARAM_LIST7(__VA_ARGS__),                                        \
+  ::trompeloeil::param_list_t<__VA_ARGS__, 7> p8
+
+#define TROMPELOEIL_PARAM_LIST7(...)                                           \
+  TROMPELOEIL_PARAM_LIST6(__VA_ARGS__),                                        \
+  ::trompeloeil::param_list_t<__VA_ARGS__, 6> p7
+
+#define TROMPELOEIL_PARAM_LIST6(...)                                           \
+  TROMPELOEIL_PARAM_LIST5(__VA_ARGS__),                                        \
+  ::trompeloeil::param_list_t<__VA_ARGS__, 5> p6
+
+#define TROMPELOEIL_PARAM_LIST5(...)                                           \
+  TROMPELOEIL_PARAM_LIST4(__VA_ARGS__),                                        \
+    ::trompeloeil::param_list_t<__VA_ARGS__, 4> p5
+
+#define TROMPELOEIL_PARAM_LIST4(...)                                           \
+  TROMPELOEIL_PARAM_LIST3(__VA_ARGS__),                                        \
+    ::trompeloeil::param_list_t<__VA_ARGS__, 3> p4
+
+#define TROMPELOEIL_PARAM_LIST3(...)                                           \
+  TROMPELOEIL_PARAM_LIST2(__VA_ARGS__),                                        \
+  ::trompeloeil::param_list_t<__VA_ARGS__, 2> p3
+
+#define TROMPELOEIL_PARAM_LIST2(...)                                           \
+  TROMPELOEIL_PARAM_LIST1(__VA_ARGS__),                                        \
+  ::trompeloeil::param_list_t<__VA_ARGS__, 1> p2
+
+#define TROMPELOEIL_PARAM_LIST1(...)                                           \
+  ::trompeloeil::param_list_t<__VA_ARGS__, 0> p1
+
+#define TROMPELOEIL_PARAM_LIST0(func_type)
+
+#define TROMPELOEIL_PARAM_LIST(num, func_type)                                 \
+  TROMPELOEIL_CONCAT(TROMPELOEIL_PARAM_LIST, num)                              \
+    (TROMPELOEIL_REMOVE_PAREN(func_type))
+
+
+#define TROMPELOEIL_PARAMS15 TROMPELOEIL_PARAMS14, p15
+#define TROMPELOEIL_PARAMS14 TROMPELOEIL_PARAMS13, p14
+#define TROMPELOEIL_PARAMS13 TROMPELOEIL_PARAMS12, p13
+#define TROMPELOEIL_PARAMS12 TROMPELOEIL_PARAMS11, p12
+#define TROMPELOEIL_PARAMS11 TROMPELOEIL_PARAMS10, p11
+#define TROMPELOEIL_PARAMS10 TROMPELOEIL_PARAMS9,  p10
+#define TROMPELOEIL_PARAMS9  TROMPELOEIL_PARAMS8,  p9
+#define TROMPELOEIL_PARAMS8  TROMPELOEIL_PARAMS7,  p8
+#define TROMPELOEIL_PARAMS7  TROMPELOEIL_PARAMS6,  p7
+#define TROMPELOEIL_PARAMS6  TROMPELOEIL_PARAMS5,  p6
+#define TROMPELOEIL_PARAMS5  TROMPELOEIL_PARAMS4,  p5
+#define TROMPELOEIL_PARAMS4  TROMPELOEIL_PARAMS3,  p4
+#define TROMPELOEIL_PARAMS3  TROMPELOEIL_PARAMS2,  p3
+#define TROMPELOEIL_PARAMS2  TROMPELOEIL_PARAMS1,  p2
+#define TROMPELOEIL_PARAMS1  ,                     p1
+#define TROMPELOEIL_PARAMS0
+
+#define TROMPELOEIL_PARAMS(num) TROMPELOEIL_CONCAT(TROMPELOEIL_PARAMS, num)
+
+#if defined(__cxx_rtti) || defined(__GXX_RTTI) || defined(_CPPRTTI)
+#  define TROMPELOEIL_TYPE_ID_NAME(x) typeid(x).name()
+#else
+#  define TROMPELOEIL_TYPE_ID_NAME(x) "object"
+#endif
+
+#if (TROMPELOEIL_CPLUSPLUS == 201103L)
+
+#define TROMPELOEIL_DECLTYPE_AUTO \
+  auto
+
+#define TROMPELOEIL_TRAILING_RETURN_TYPE(return_type) \
+  -> return_type
+
+#else /* (TROMPELOEIL_CPLUSPLUS == 201103L) */
+
+#define TROMPELOEIL_DECLTYPE_AUTO \
+  decltype(auto)
+
+#define TROMPELOEIL_TRAILING_RETURN_TYPE(return_type) \
+  /**/
+
+#endif /* !(TROMPELOEIL_CPLUSPLUS == 201103L) */
+#if TROMPELOEIL_CPLUSPLUS > 201403L && (!TROMPELOEIL_GCC || TROMPELOEIL_GCC_VERSION >= 70000)
+#  define TROMPELOEIL_INLINE_VAR [[maybe_unused]] static inline
+#else
+#  define TROMPELOEIL_INLINE_VAR static
+#endif
+
+static constexpr bool trompeloeil_movable_mock = false;
+
+namespace trompeloeil
+{
+  template <typename T>
+  struct identity_type
+  {
+    using type = T;
+  };
+
+  template <typename R, typename C, typename ... Args>
+  identity_type<R(Args...)>
+  nonconst_member_signature(R (C::*)(Args...))
+  {
+    return {};
+  }
+
+  template <typename R, typename C, typename ... Args>
+  identity_type<R(Args...)>
+  const_member_signature(R (C::*)(Args...) const)
+  {
+    return {};
+  }
+
+  template <typename ...>
+  struct void_t_
+  {
+    using type = void;
+  };
+
+  template <typename ... T>
+  using void_t = typename void_t_<T...>::type;
+
+  template <template <typename ...> class, typename, typename ...>
+  struct is_detected_{
+    using type = std::false_type;
+  };
+
+  template <template <typename ...> class D, typename ... Ts>
+  struct is_detected_<D, void_t<D<Ts...>>, Ts...>
+  {
+    using type = std::true_type;
+  };
+
+  template <template <typename ...> class D, typename ... Ts>
+  using is_detected = typename is_detected_<D, void, Ts...>::type;
+
+# if (TROMPELOEIL_CPLUSPLUS == 201103L)
+
+  namespace detail
+  {
+    template <typename T>
+    struct unwrap_type
+    {
+      using type = T;
+    };
+    template <typename T>
+    struct unwrap_type<std::reference_wrapper<T>>
+    {
+      using type = T&;
+    };
+    template <typename ... Ts>
+    std::tuple<typename unwrap_type<typename std::decay<Ts>::type>::type...>
+    make_tuple(Ts&& ... ts)
+    {
+      return { std::forward<Ts>(ts)... };
+    }
+
+    /* Implement C++14 features using only C++11 entities. */
+
+    /* <memory> */
+
+    /* Implementation of make_unique is from
+     *
+     * Stephan T. Lavavej, "make_unique (Revision 1),"
+     * ISO/IEC JTC1 SC22 WG21 N3656, 18 April 2013.
+     * Available: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3656.htm
+     * Accessed: 14 June 2017
+     *
+     * Renamed types to avoid the use of reserved identifiers.
+     */
+    template <class T>
+    struct unique_if
+    {
+      typedef std::unique_ptr<T> single_object;
+    };
+
+    template <class T>
+    struct unique_if<T[]>
+    {
+      typedef std::unique_ptr<T[]> unknown_bound;
+    };
+
+    template <class T, size_t N>
+    struct unique_if<T[N]>
+    {
+      typedef void known_bound;
+    };
+
+    template <class T, class... Args>
+    typename unique_if<T>::single_object
+    make_unique(Args&&... args)
+    {
+      return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+    }
+
+    template <class T>
+    typename unique_if<T>::unknown_bound
+    make_unique(size_t n)
+    {
+      typedef typename std::remove_extent<T>::type U;
+      return std::unique_ptr<T>(new U[n]());
+    }
+
+    template <class T, class... Args>
+    typename unique_if<T>::known_bound
+    make_unique(Args&&...) = delete;
+
+    /* <type_traits> */
+
+    /* The implementation of these is from
+     *
+     * Walter E. Brown, "TransformationTraits Redux, v2,"
+     * ISO/IEC JTC1 SC22 WG21 N3655, 18 April 2013.
+     * Available: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3655.pdf
+     * Accessed: 2 November 2017
+     *
+     * Minor changes to capitalize template parameter `bool B` has been made.
+     *
+     * See also:
+     * http://en.cppreference.com/w/cpp/types/conditional
+     * http://en.cppreference.com/w/cpp/types/decay
+     * http://en.cppreference.com/w/cpp/types/enable_if
+     * http://en.cppreference.com/w/cpp/types/remove_pointer
+     * http://en.cppreference.com/w/cpp/types/remove_reference
+     * Accessed: 17 May 2017
+     */
+    template <bool B, typename T, typename F>
+    using conditional_t = typename std::conditional<B, T, F>::type;
+
+    template <typename T>
+    using decay_t = typename std::decay<T>::type;
+
+    template <bool B, typename T = void>
+    using enable_if_t = typename std::enable_if<B, T>::type;
+
+    template <typename T>
+    using remove_pointer_t = typename std::remove_pointer<T>::type;
+
+    template <typename T>
+    using remove_reference_t = typename std::remove_reference<T>::type;
+
+    /* <utility> */
+
+    /* This implementation of exchange is from
+     *
+     * Jeffrey Yasskin, "exchange() utility function, revision 3,"
+     * ISO/IEC JTC1 SC22 WG21 N3688, 19 April 2013.
+     * Available: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3668.html
+     * Accessed: 2 November 2017
+     *
+     * See also:
+     * http://en.cppreference.com/w/cpp/utility/exchange
+     * Accessed: 17 May 2017
+     */
+    template<class T, class U = T>
+    inline
+    T
+    exchange(
+      T& obj,
+      U&& new_value)
+    {
+      T old_value = std::move(obj);
+      obj = std::forward<U>(new_value);
+      return old_value;
+    }
+
+    /* integer_sequence and index_sequence implementations are from
+     *
+     * Jonathan Wakely, "Compile-time integer sequences,"
+     * ISO/IEC JTC1 SC22 WG21 N3658, 18 April 2013.
+     * Available: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3658.html
+     * Accessed: 2 November 2017
+     *
+     * See also:
+     * http://en.cppreference.com/w/cpp/utility/integer_sequence
+     * Accessed: 17 May 2017
+     */
+    template <typename T, T... I>
+    struct integer_sequence
+    {
+      // Replaces a typedef used in the definition found in N3658.
+      using value_type = T;
+
+      static constexpr size_t size() noexcept
+      {
+          return sizeof...(I);
+      }
+    };
+
+    template <size_t... I>
+    using index_sequence = integer_sequence<size_t, I...>;
+
+    /* This implementation of make_integer_sequence is from boost/mp11,
+     *
+     * Copyright 2015, 2017 Peter Dimov
+     *
+     * Distributed under the Boost Software License, Version 1.0.
+     *
+     * Implemented here:
+     *
+     * https://github.com/pdimov/mp11/blob/master/include/boost/
+     *   integer_sequence.hpp
+     * Accessed: 17 May 2017
+     *
+     * (now missing) and here:
+     *
+     * https://github.com/boostorg/mp11/blob/develop/include/boost/
+     *   mp11/integer_sequence.hpp
+     * Accessed: 13 August 2017
+     */
+    namespace impl
+    {
+      // iseq_if_c
+      template <bool C, class T, class E>
+      struct iseq_if_c_impl;
+
+      template <class T, class E>
+      struct iseq_if_c_impl<true, T, E>
+      {
+        using type = T;
+      };
+
+      template <class T, class E>
+      struct iseq_if_c_impl<false, T, E>
+      {
+        using type = E;
+      };
+
+      template <bool C, class T, class E>
+      using iseq_if_c = typename iseq_if_c_impl<C, T, E>::type;
+
+      // iseq_identity
+      template <class T>
+      struct iseq_identity
+      {
+        using type = T;
+      };
+
+      template <class S1, class S2>
+      struct append_integer_sequence;
+
+      template <class T, T... I, T... J>
+      struct append_integer_sequence<integer_sequence<T, I...>, integer_sequence<T, J...>>
+      {
+        using type = integer_sequence<T, I..., ( J + sizeof...(I) )...>;
+      };
+
+      template <class T, T N>
+      struct make_integer_sequence_impl;
+
+      template <class T, T N>
+      struct make_integer_sequence_impl_
+      {
+      private:
+
+        static_assert( N >= 0, "make_integer_sequence<T, N>: N must not be negative" );
+
+        static T const M = N / 2;
+        static T const R = N % 2;
+
+        using S1 = typename make_integer_sequence_impl<T, M>::type;
+        using S2 = typename append_integer_sequence<S1, S1>::type;
+        using S3 = typename make_integer_sequence_impl<T, R>::type;
+        using S4 = typename append_integer_sequence<S2, S3>::type;
+
+      public:
+
+        using type = S4;
+      };
+
+      template <class T, T N>
+      struct make_integer_sequence_impl:
+        iseq_if_c<N == 0,
+          iseq_identity<integer_sequence<T>>,
+          iseq_if_c<N == 1,
+            iseq_identity<integer_sequence<T, 0>>,
+            make_integer_sequence_impl_<T, N>>>
+      {
+      };
+    }
+
+    template<class T, T N>
+    using make_integer_sequence = typename impl::make_integer_sequence_impl<T, N>::type;
+
+    template <size_t N>
+    using make_index_sequence = make_integer_sequence<size_t, N>;
+
+    template <typename... T>
+    using index_sequence_for = make_index_sequence<sizeof...(T)>;
+
+  } /* namespace detail */
+
+# else /* (TROMPELOEIL_CPLUSPLUS == 201103L) */
+
+  /* Only these entities really need to
+   * be available in namespace detail, but
+   * VS 2015 has a problem with this approach.
+   *
+   *  namespace detail {
+   *
+   *  using std::make_unique;
+   *
+   *  using std::conditional_t;
+   *  using std::decay_t;
+   *  using std::enable_if_t;
+   *  using std::remove_pointer_t;
+   *  using std::remove_reference_t;
+   *
+   *  using std::exchange;
+   *  using std::index_sequence;
+   *  using std::index_sequence_for;
+   *  using std::integer_sequence;
+   *  using std::make_index_sequence;
+   *
+   *  }
+   *
+   * Instead, use a namespace alias.
+   */
+  namespace detail = std;
+
+# endif /* !(TROMPELOEIL_CPLUSPLUS == 201103L) */
+
+# if TROMPELOEIL_CPLUSPLUS >= 201703L
+#   if TROMPELOEIL_CLANG && TROMPELOEIL_CLANG_VERSION >= 60000
+
+  // these are mostly added to work around clang++ bugs
+  // https://bugs.llvm.org/show_bug.cgi?id=38033
+  // https://bugs.llvm.org/show_bug.cgi?id=38010
+
+  template <typename T>
+  using move_construct_type = decltype(T(std::declval<T&&>()));
+
+  template <typename T>
+  using copy_construct_type = decltype(T(std::declval<const T&>()));
+
+  template <typename T>
+  using can_move_construct = is_detected<move_construct_type, detail::decay_t<T>>;
+
+  template <typename T>
+  using can_copy_construct = is_detected<copy_construct_type, detail::decay_t<T>>;
+
+#   else
+  template <typename T>
+  using can_move_construct = std::is_move_constructible<T>;
+
+  template <typename T>
+  using can_copy_construct = std::is_copy_constructible<T>;
+#   endif
+
+  template <typename F, typename ... A>
+  using invoke_result_type = decltype(std::declval<F&>()(std::declval<A>()...));
+
+# else
+
+  template <typename T>
+  using can_move_construct = std::is_move_constructible<T>;
+
+  template <typename T>
+  using can_copy_construct = std::is_copy_constructible<T>;
+
+  template <typename F, typename ... A>
+  using invoke_result_type = decltype(std::declval<F&>()(std::declval<A>()...));
+
+# endif
+
+#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
+  template <typename Sig, typename = void>
+  struct is_coroutine : std::false_type {};
+
+  template <typename Sig>
+  struct is_coroutine<Sig, std::void_t<decltype(&std::coroutine_traits<Sig>::promise_type::initial_suspend)>> : std::true_type {};
+
+  template <typename U>
+  struct type_wrapper{
+    template <typename V>
+    static V remove_rvalue_ref(V&&);
+    using type = decltype(remove_rvalue_ref(std::declval<U>()));
+  };
+  template <>
+  struct type_wrapper<void>
+  {
+    using type = void;
+  };
+
+  template <typename T>
+  struct coro_value_type
+  {
+    static auto func()
+    {
+      if constexpr (requires {std::declval<T>().operator co_await();})
+      {
+        return type_wrapper<decltype(std::declval<T>().operator co_await().await_resume())>{};
+      }
+      else
+      {
+        return type_wrapper<decltype(std::declval<T>().await_resume())>{};
+      }
+    }
+    using type = typename decltype(func())::type;
+  };
+
+template <typename T>
+using coro_value_type_t = typename coro_value_type<T>::type;
+
+#endif
+
+  template <typename T>
+  class mini_span
+  {
+  public:
+    mini_span(T* address, size_t size) noexcept : begin_(address), end_(address + size) {}
+    T* begin() const noexcept { return begin_; }
+    T* end() const noexcept { return end_; }
+  private:
+    T* begin_;
+    T* end_;
+  };
+
+  class specialized;
+
+
+#ifndef TROMPELOEIL_CUSTOM_RECURSIVE_MUTEX
+
+  template <typename T = void>
+  unique_lock<std::recursive_mutex> get_lock()
+  {
+    // Ugly hack for lifetime of mutex. The statically allocated
+    // recursive_mutex is intentionally leaked, to ensure that the
+    // mutex is available and valid even if the last use is from
+    // the destructor of a global object in a translation unit
+    // without #include <trompeloeil.hpp>
+
+    alignas(std::recursive_mutex)
+    static char buffer[sizeof(std::recursive_mutex)];
+
+    static auto mutex = new (&buffer) std::recursive_mutex;
+    return unique_lock<std::recursive_mutex>{*mutex};
+  }
+
+#else
+
+  class custom_recursive_mutex {
+  public:
+    virtual ~custom_recursive_mutex() = default;
+    virtual void lock() = 0;
+    virtual void unlock() = 0;
+  };
+
+  // User has to provide an own recursive mutex.
+  std::unique_ptr<custom_recursive_mutex> create_custom_recursive_mutex();
+
+  template <typename T = void>
+  unique_lock<custom_recursive_mutex> get_lock()
+  {
+    static std::unique_ptr<custom_recursive_mutex> mtx =
+        create_custom_recursive_mutex();
+    return unique_lock<custom_recursive_mutex>{*mtx};
+  }
+
+#endif
+
+  template <size_t N, typename T>
+  using conditional_tuple_element
+    = detail::conditional_t<(N < std::tuple_size<T>::value),
+                         typename std::tuple_element<N, T>::type,
+                         int>;
+
+  template <typename T>
+  struct param_list;
+
+  template <typename R, typename ... P>
+  struct param_list<R(P...)>
+  {
+    static size_t constexpr const size = sizeof...(P);
+    template <size_t N>
+    using type = conditional_tuple_element<N, std::tuple<P...>>;
+  };
+
+  template <typename Sig, size_t N>
+  using param_list_t = typename param_list<Sig>::template type<N>;
+
+  class expectation_violation : public std::logic_error
+  {
+  public:
+    using std::logic_error::logic_error;
+  };
+
+  struct location
+  {
+    location()
+    noexcept
+      : file("")
+      , line(0U)
+    {}
+
+    location(
+      char const* file_,
+      unsigned long line_
+    )
+    noexcept
+      : file{file_}
+      , line{line_}
+    {}
+
+    char const *file;
+    unsigned long line;
+
+    friend
+    std::ostream&
+    operator<<(
+      std::ostream& os,
+      const location& loc)
+    {
+      if (loc.line != 0U) os << loc.file << ':' << loc.line;
+      return os;
+    }
+  };
+
+  enum class severity { fatal, nonfatal };
+
+  using reporter_func = std::function<void(severity,
+                                           char const *file,
+                                           unsigned long line,
+                                           std::string const &msg)>;
+
+  using ok_reporter_func = std::function<void(char const *msg)>;
+
+  inline
+  void
+  default_reporter(
+    severity,
+    char const *file,
+    unsigned long line,
+    std::string const &msg)
+  {
+    if (!std::current_exception())
+    {
+      std::stringstream os;
+      os << location{ file, line } << "\n" << msg;
+      throw expectation_violation(os.str());
+    }
+  }
+
+  inline
+  void
+  default_ok_reporter(char const* /*msg*/)
+  {
+    /* OK reporter defaults to doing nothing. */
+  }
+
+  inline
+  reporter_func&
+  reporter_obj()
+  {
+    static reporter_func obj = default_reporter;
+    return obj;
+  }
+
+  inline
+  ok_reporter_func&
+  ok_reporter_obj()
+  {
+    static ok_reporter_func obj = default_ok_reporter;
+    return obj;
+  }
+
+  inline
+  reporter_func
+  set_reporter(
+    reporter_func f)
+  {
+    return detail::exchange(reporter_obj(), std::move(f));
+  }
+
+  inline
+  std::pair<reporter_func, ok_reporter_func>
+  set_reporter(
+    reporter_func rf,
+    ok_reporter_func orf)
+  {
+    return {
+      set_reporter(std::move(rf)),
+      detail::exchange(ok_reporter_obj(), std::move(orf))
+    };
+  }
+
+  class tracer;
+
+  inline
+  tracer*&
+  tracer_obj()
+  noexcept
+  {
+    static tracer* ptr = nullptr;
+    return ptr;
+  }
+
+  inline
+  tracer*
+  set_tracer(
+    tracer* obj)
+  noexcept
+  {
+    // std::exchange would be sane here, but it costs compilation time
+    auto& ptr = tracer_obj();
+    auto rv = ptr;
+    ptr = obj;
+    return rv;
+  }
+
+  class tracer
+  {
+  public:
+    virtual
+    void
+    trace(
+      char const *file,
+      unsigned long line,
+      std::string const &call) = 0;
+  protected:
+    tracer() = default;
+    tracer(tracer const&) = delete;
+    tracer& operator=(tracer const&) = delete;
+    virtual
+    ~tracer()
+    {
+      set_tracer(previous);
+    }
+  private:
+    tracer* previous = set_tracer(this);
+  };
+
+  class stream_tracer : public tracer
+  {
+  public:
+    explicit
+    stream_tracer(
+      std::ostream& stream_)
+      : stream(stream_) {}
+    void
+    trace(
+      char const *file,
+      unsigned long line,
+      std::string const &call)
+      override
+    {
+      stream << location{file, line} << '\n' << call << '\n';
+    }
+  private:
+    std::ostream& stream;
+  };
+
+  class trace_agent;
+
+  template <typename T>
+  struct reporter;
+
+  template <typename T>
+  void
+  send_report(
+    severity s,
+    location loc,
+    std::string const &msg)
+  {
+    reporter<T>::send(s, loc.file, loc.line, msg.c_str());
+  }
+
+  template <typename T>
+  void
+  send_ok_report(
+    std::string const &msg)
+  {
+    reporter<T>::sendOk(msg.c_str());
+  }
+
+  template <typename T>
+  struct reporter
+  {
+    static
+    void
+    send(
+      severity s,
+      char const *file,
+      unsigned long line,
+      char const *msg);
+
+    static
+    void
+    sendOk(
+      char const *msg);
+
+  };
+
+  template <typename T>
+  void reporter<T>::
+    send(
+      severity s,
+      char const *file,
+      unsigned long line,
+      char const *msg)
+    {
+      reporter_obj()(s, file, line, msg);
+    }
+
+  template <typename T>
+  void reporter<T>::
+    sendOk(char const* msg)
+    {
+      ok_reporter_obj()(msg);
+    }
+
+  template <typename ... T>
+  constexpr
+  bool
+  ignore(
+    T const& ...)
+  noexcept
+  {
+    return true;
+  }
+
+  struct illegal_argument
+  {
+    template <bool b = false>
+    constexpr
+    illegal_argument const& operator&() const
+    {
+      static_assert(b, "illegal argument");
+      return *this;
+    }
+
+    template <bool b = false>
+    constexpr
+    illegal_argument const& operator*() const
+    {
+      static_assert(b, "illegal argument");
+      return *this;
+    }
+
+    template <typename T, bool b = false>
+    constexpr
+    illegal_argument const& operator=(T const&) const
+    {
+      static_assert(b, "illegal argument");
+      return *this;
+    }
+
+    template <typename T, bool b = false>
+    constexpr
+    operator T() const
+    {
+      static_assert(b, "illegal argument");
+      return {};
+    }
+  };
+
+  struct matcher { };
+
+  struct wildcard : public matcher
+  {
+    template <typename T>
+    struct wrapper {
+      operator T() {
+        static_assert(std::is_same<T, void>{},
+                      "Getting a value from wildcard is not allowed.\n"
+                      "See https://github.com/rollbear/trompeloeil/issues/270\n"
+                      "and https://github.com/rollbear/trompeloeil/issues/290");
+        return *this;
+      }
+    };
+    template <typename T, typename std::enable_if<!std::is_convertible<wildcard&, T>{}>::type* = nullptr>
+    operator T()
+    {
+      return wrapper<T>{};
+    }
+
+    template <typename T>
+    operator T&&() const
+    {
+#if (!TROMPELOEIL_GCC  || TROMPELOEIL_GCC_VERSION < 60000 || TROMPELOEIL_GCC_VERSION >= 90000) \
+      && (!TROMPELOEIL_CLANG || TROMPELOEIL_CLANG_VERSION >= 40000 || !defined(_LIBCPP_STD_VER) || _LIBCPP_STD_VER != 14)
+      return wrapper<T &&>{};
+#else
+      return *this;
+#endif
+    }
+
+    template <typename T>
+    operator T&() const volatile
+    {
+      return wrapper<T&>{};
+    }
+
+    template <typename T>
+    constexpr
+    bool
+    matches(
+      T const&)
+    const
+    noexcept
+    {
+      return true;
+    }
+  };
+
+  TROMPELOEIL_INLINE_VAR wildcard _{};
+
+template <typename T>
+  using matcher_access = decltype(static_cast<matcher*>(std::declval<typename std::add_pointer<T>::type>()));
+
+  template <typename T>
+  using is_matcher = typename is_detected<matcher_access, T>::type;
+
+  template <typename T>
+  struct typed_matcher : matcher
+  {
+    template <bool b = false>
+    operator T() const {
+        static_assert(b,
+                      "Getting a value from a typed matcher is not allowed.\n"
+                      "See https://github.com/rollbear/trompeloeil/issues/270\n"
+                      "and https://github.com/rollbear/trompeloeil/issues/290");
+        return {};
+    }
+  };
+
+  template <>
+  struct typed_matcher<std::nullptr_t> : matcher
+  {
+    template <typename T,
+              typename = decltype(std::declval<T>() == nullptr)>
+    operator T&&() const
+    {
+      static_assert(std::is_same<T, void>{},
+                    "Getting a value from a typed matcher is not allowed.\n"
+                    "See https://github.com/rollbear/trompeloeil/issues/270\n"
+                    "https://github.com/rollbear/trompeloeil/issues/290");
+      return *this;
+    }
+
+    template <typename T,
+              typename = decltype(std::declval<T>() == nullptr)>
+    operator T&()const volatile
+    {
+      static_assert(std::is_same<T, void>{},
+                    "Getting a value from a typed matcher is not allowed.\n"
+                    "See https://github.com/rollbear/trompeloeil/issues/270\n"
+                    "and https://github.com/rollbear/trompeloeil/issues/290");
+      return *this;
+    }
+
+    template <typename T, typename C>
+    operator T C::*() const
+    {
+      static_assert(std::is_same<C, void>{},
+          "Getting a value from a typed matcher is not allowed.\n"
+          "See https://github.com/rollbear/trompeloeil/issues/270\n"
+          "and https://github.com/rollbear/trompeloeil/issues/290");
+      return *this;
+    }
+  };
+
+  template <typename Pred, typename ... T>
+  class duck_typed_matcher : public matcher
+  {
+  public:
+#if (!TROMPELOEIL_GCC) || \
+    (TROMPELOEIL_GCC && TROMPELOEIL_GCC_VERSION >= 40900)
+
+    // g++ 4.8 gives a "conversion from <T> to <U> is ambiguous" error
+    // if this operator is defined.
+    template <typename V,
+              typename = detail::enable_if_t<!is_matcher<V>{}>,
+              typename = invoke_result_type<Pred, V&&, T...>>
+    operator V&&() const {
+#if !TROMPELOEIL_CLANG || TROMPELOEIL_CLANG_VERSION >= 40000
+      // clang 3.x instantiates the function even when it's only used
+      // for compile time signature checks and never actually called.
+      static_assert(std::is_same<V, void>{},
+                    "Getting a value from a duck typed matcher is not allowed.\n"
+                    "See https://github.com/rollbear/trompeloeil/issues/270\n"
+                    "and https://github.com/rollbear/trompeloeil/issues/290");
+#endif
+      return *this;
+    }
+
+#endif
+
+    template <typename V,
+              typename = detail::enable_if_t<!is_matcher<V>{}>,
+              typename = invoke_result_type<Pred, V&, T...>>
+    operator V&() const volatile
+    {
+      static_assert(std::is_same<V, void>{},
+                    "Getting a value from a duck typed matcher is not allowed.\n"
+                    "See https://github.com/rollbear/trompeloeil/issues/270\n"
+                    "and https://github.com/rollbear/trompeloeil/issues/290");
+
+      return *this;
+    }
+  };
+
+  template <typename T>
+  using ostream_insertion = decltype(std::declval<std::ostream&>() << std::declval<T>());
+
+  template <typename T>
+  using is_output_streamable = std::integral_constant<bool, is_detected<ostream_insertion, T>::value && !std::is_array<T>::value>;
+
+  struct stream_sentry
+  {
+    explicit
+    stream_sentry(
+      std::ostream& os_)
+      : os(os_)
+      , width(os.width(0))
+      , flags(os.flags(std::ios_base::dec | std::ios_base::left))
+      , fill(os.fill(' '))
+      {  }
+      stream_sentry(
+        stream_sentry const&)
+      = delete;
+    ~stream_sentry()
+    {
+      os.flags(flags);
+      os.fill(fill);
+      os.width(width);
+    }
+  private:
+    std::ostream& os;
+    std::streamsize width;
+    std::ios_base::fmtflags flags;
+    char fill;
+  };
+
+  struct indirect_null {
+#if !TROMPELOEIL_CLANG
+    template <
+      typename T,
+      typename = detail::enable_if_t<std::is_convertible<std::nullptr_t, T>::value>
+    >
+    operator T&&() const = delete;
+#endif
+#if TROMPELOEIL_GCC || TROMPELOEIL_MSVC
+
+    template <typename T, typename C, typename ... As>
+    using memfunptr = T (C::*)(As...);
+
+    template <typename T>
+    operator T*() const;
+    template <typename T, typename C>
+    operator T C::*() const;
+    template <typename T, typename C, typename ... As>
+    operator memfunptr<T,C,As...>() const;
+#endif /* TROMPELOEIL_GCC || TROMPELOEIL_MSVC */
+    operator std::nullptr_t() const;
+  };
+
+  template <typename T, typename U>
+  using equality_comparison = decltype((std::declval<T const&>() == std::declval<U const&>())
+                                       ? true
+                                       : false);
+
+  template <typename T, typename U>
+  using is_equal_comparable = is_detected<equality_comparison, T, U>;
+
+#if defined(_MSC_VER) && (_MSC_VER < 1910)
+  template <typename T>
+  using is_null_comparable = is_equal_comparable<T, std::nullptr_t>;
+#else
+  template <typename T>
+  using is_null_comparable = is_equal_comparable<T, indirect_null>;
+#endif
+
+  template <typename T, typename = decltype(std::declval<T const&>() == nullptr)>
+  constexpr
+  auto
+  is_null_redirect(
+    T const &t)
+  noexcept(noexcept(std::declval<T const&>() == nullptr))
+  -> decltype(t == nullptr)
+  {
+    return t == nullptr;
+  }
+
+  template <typename T>
+  constexpr
+  auto
+  is_null(
+    T const &t,
+    std::true_type)
+  noexcept(noexcept(is_null_redirect(t)))
+  -> decltype(is_null_redirect(t))
+  {
+    // Redirect evaluation to suppress wrong non-null warnings in g++ 9 and 10.
+    return is_null_redirect(t);
+  }
+
+  template <typename T, typename V>
+  constexpr
+  bool
+  is_null(
+    T const &,
+    V)
+  noexcept
+  {
+    return false;
+  }
+
+  template <typename T>
+  constexpr
+  bool
+  is_null(
+    T const &,
+    std::false_type)
+  noexcept
+  {
+    return false;
+  }
+
+  template <typename T>
+  constexpr
+  bool
+  is_null(
+    T const &t)
+  {
+    // g++-4.9 uses C++11 rules for constexpr function, so can't
+    // break this up into smaller bits
+    using tag = std::integral_constant<bool, is_null_comparable<T>::value
+                                       && !is_matcher<T>::value
+                                       && !std::is_array<T>::value>;
+
+    return ::trompeloeil::is_null(t, tag{});
+  }
+
+  template <typename T>
+  void
+  print(
+    std::ostream& os,
+    T const &t);
+
+  template <typename T>
+  using iterable = decltype(std::begin(std::declval<T&>()) == std::end(std::declval<T&>()));
+
+  template <typename T>
+  using is_collection = is_detected<iterable, T>;
+
+  template <typename T,
+            bool = is_output_streamable<const T>::value,
+            bool = is_collection<const detail::remove_reference_t<T>>::value>
+  struct streamer
+  {
+    static
+    void
+    print(
+      std::ostream& os,
+      T const &t)
+    {
+      stream_sentry s(os);
+      os << t;
+    }
+  };
+
+  template <typename ... T>
+  struct streamer<std::tuple<T...>, false, false>
+  {
+    static
+    void
+    print(
+      std::ostream& os,
+      std::tuple<T...> const&  t)
+    {
+      print_tuple(os, t, detail::index_sequence_for<T...>{});
+    }
+    template <size_t ... I>
+    static
+    void
+    print_tuple(
+      std::ostream& os,
+      std::tuple<T...> const& t,
+      detail::index_sequence<I...>)
+    {
+      os << "{ ";
+      const char* sep = "";
+      std::initializer_list<const char*> v{((os << sep),
+                                            ::trompeloeil::print(os, std::get<I>(t)),
+                                            (sep = ", "))...};
+      ignore(v);
+      os << " }";
+    }
+  };
+
+  template <typename T, typename U>
+  struct streamer<std::pair<T, U>, false, false>
+  {
+    static
+    void
+    print(
+      std::ostream& os,
+      std::pair<T, U> const& t)
+    {
+      os << "{ ";
+      ::trompeloeil::print(os, t.first);
+      os << ", ";
+      ::trompeloeil::print(os, t.second);
+      os << " }";
+    }
+  };
+
+  template <typename T>
+  struct streamer<T, false, true>
+  {
+    static
+    void
+    print(
+      std::ostream& os,
+      T const& t)
+    {
+      os << "{ ";
+      const char* sep = "";
+      using element_type = decltype(*std::begin(t));
+      std::for_each(std::begin(t), std::end(t),
+                    [&os, &sep](element_type element) {
+                      os << sep;
+                      ::trompeloeil::print(os, element);
+                      sep = ", ";
+                    });
+      os << " }";
+    }
+  };
+
+  inline void hexdump(const void* begin, size_t size, std::ostream& os)
+  {
+    stream_sentry s(os);
+    os << size << "-byte object={";
+    if (size > 8)
+    {
+      os << '\n';
+    }
+    os << std::setfill('0') << std::hex;
+    mini_span<uint8_t const> bytes(static_cast<uint8_t const*>(begin), size);
+    size_t byte_number = 0;
+    std::for_each(bytes.begin(), bytes.end(),  [&os, &byte_number](unsigned byte) {
+      os << " 0x" << std::setw(2) << std::right << byte;
+      if ((byte_number & 0xf) == 0xf) os << '\n';
+      ++byte_number;
+    });
+    os << " }";
+  }
+
+  template <typename T>
+  struct streamer<T, false, false>
+  {
+    static
+    void
+    print(
+      std::ostream& os,
+      T const &t)
+    {
+      hexdump(&t, sizeof(T), os);
+    }
+  };
+
+  template <typename T, typename = void>
+  struct printer
+  {
+    static
+    void
+    print(
+      std::ostream& os,
+      T const & t)
+    {
+      streamer<T>::print(os, t);
+    }
+  };
+
+  template <>
+  struct printer<wildcard>
+  {
+    static
+    void
+    print(
+    std::ostream& os,
+    wildcard const&)
+    {
+      os << " matching _";
+    }
+  };
+  template <typename T>
+  void
+  print(
+    std::ostream& os,
+    T const &t)
+  {
+    if (is_null(t))
+    {
+      os << "nullptr";
+    }
+    else
+    {
+      printer<T>::print(os, t);
+    }
+  }
+
+  inline
+  void
+  print(
+      std::ostream& os,
+      std::nullptr_t)
+  {
+    os << "nullptr";
+  }
+
+  constexpr
+  auto
+  param_compare_operator(
+    void const*)
+  TROMPELOEIL_TRAILING_RETURN_TYPE(const char*)
+  {
+    return " == ";
+  }
+
+  constexpr
+  auto
+  param_compare_operator(
+    matcher const*)
+  TROMPELOEIL_TRAILING_RETURN_TYPE(const char*)
+  {
+    return "";
+  }
+
+  template <typename T>
+  void
+  print_expectation(
+    std::ostream& os,
+    T const& t)
+  {
+    os << param_compare_operator(&t);
+    print(os, t);
+    os << '\n';
+  }
+
+  template <typename T>
+  class list_elem
+  {
+  public:
+    list_elem(
+      const list_elem&)
+    = delete;
+
+    list_elem(
+      list_elem &&r)
+    noexcept
+    {
+      *this = std::move(r);
+    }
+
+    list_elem&
+    operator=(
+      list_elem &&r)
+    noexcept
+    {
+      if (this != &r)
+      {
+        next = r.next;
+        prev = &r;
+        r.invariant_check();
+
+        next->prev = this;
+        r.next = this;
+
+        TROMPELOEIL_ASSERT(next->prev == this);
+        TROMPELOEIL_ASSERT(prev->next == this);
+
+        r.unlink();
+
+        TROMPELOEIL_ASSERT(!r.is_linked());
+        invariant_check();
+      }
+      return *this;
+    }
+
+    list_elem&
+    operator=(
+      const list_elem&)
+    = delete;
+
+    virtual
+    ~list_elem()
+    {
+      unlink();
+    }
+
+    void
+    unlink()
+    noexcept
+    {
+      invariant_check();
+      auto n = next;
+      auto p = prev;
+      n->prev = p;
+      p->next = n;
+      next = this;
+      prev = this;
+      invariant_check();
+    }
+
+    void
+    invariant_check()
+    const
+    noexcept
+    {
+#ifdef TROMPELOEIL_SANITY_CHECKS
+      TROMPELOEIL_ASSERT(next->prev == this);
+      TROMPELOEIL_ASSERT(prev->next == this);
+      TROMPELOEIL_ASSERT((next == this) == (prev == this));
+      TROMPELOEIL_ASSERT((prev->next == next) == (next == this));
+      TROMPELOEIL_ASSERT((next->prev == prev) == (prev == this));
+      auto pp = prev;
+      auto nn = next;
+      do {
+        TROMPELOEIL_ASSERT((nn == this) == (pp == this));
+        TROMPELOEIL_ASSERT(nn->next->prev == nn);
+        TROMPELOEIL_ASSERT(nn->prev->next == nn);
+        TROMPELOEIL_ASSERT(pp->next->prev == pp);
+        TROMPELOEIL_ASSERT(pp->prev->next == pp);
+        TROMPELOEIL_ASSERT((nn->next == nn) == (nn == this));
+        TROMPELOEIL_ASSERT((pp->prev == pp) == (pp == this));
+        nn = nn->next;
+        pp = pp->prev;
+      } while (nn != this);
+#endif
+    }
+
+    bool
+    is_linked()
+    const
+    noexcept
+    {
+      invariant_check();
+      return next != this;
+    }
+  protected:
+    list_elem() noexcept = default;
+  public:
+    list_elem* next = this;
+    list_elem* prev = this;
+  };
+
+  class ignore_disposer
+  {
+  protected:
+    template <typename T>
+    TROMPELOEIL_NORETURN
+    void
+    dispose(
+      T*)
+    const
+    noexcept
+    {
+      std::abort(); // must never be called
+    }
+  };
+
+  class delete_disposer
+  {
+  protected:
+    template <typename T>
+    void
+    dispose(
+      T* t)
+    const
+    {
+      delete t;
+    }
+  };
+
+  template <typename T, typename Disposer = ignore_disposer>
+  class list : private list_elem<T>, private Disposer
+  {
+  public:
+    list() noexcept;
+    list(list&&) noexcept;
+    list(const list&) = delete;
+    list& operator=(list&&) noexcept;
+    list& operator=(const list&) = delete;
+    ~list() override;
+    class iterator;
+    iterator begin() const noexcept;
+    iterator end() const noexcept;
+    iterator push_front(T* t) noexcept;
+    iterator push_back(T* t) noexcept;
+    bool empty() const noexcept { return begin() == end(); }
+  private:
+    using list_elem<T>::invariant_check;
+    using list_elem<T>::next;
+    using list_elem<T>::prev;
+  };
+
+  template <typename T, typename Disposer>
+  class list<T, Disposer>::iterator
+  {
+    friend class list<T, Disposer>;
+    using iterator_category = std::bidirectional_iterator_tag;
+    using value_type = T;
+    using difference_type = std::ptrdiff_t;
+    using pointer = T*;
+    using reference = T&;
+  public:
+    friend
+    bool
+    operator==(
+      iterator const &lh,
+      iterator const &rh)
+    noexcept
+    {
+      return lh.p == rh.p;
+    }
+
+    friend
+    bool
+    operator!=(
+      iterator const &lh,
+      iterator const &rh)
+    noexcept
+    {
+      return !(lh == rh);
+    }
+
+    iterator&
+    operator++()
+    noexcept
+    {
+      p = p->next;
+      return *this;
+    }
+
+    iterator
+    operator++(int)
+    noexcept
+    {
+      auto rv = *this;
+      operator++();
+      return rv;
+    }
+
+    T&
+    operator*()
+    noexcept
+    {
+      return static_cast<T&>(*p);
+    }
+
+    T*
+    operator->()
+    noexcept
+    {
+      return static_cast<T*>(p);
+    }
+
+  private:
+    explicit
+    iterator(
+      list_elem<T> const *t)
+    noexcept
+    : p{const_cast<list_elem<T>*>(t)}
+    {}
+
+    list_elem<T>* p = nullptr;
+  };
+
+  template <typename T, typename Disposer>
+  list<T, Disposer>::list() noexcept = default;
+
+  template <typename T, typename Disposer>
+  list<T, Disposer>::list(list&&) noexcept = default;
+
+  template <typename T, typename Disposer>
+  list<T, Disposer>& list<T, Disposer>::operator=(list&&) noexcept = default;
+
+  template <typename T, typename Disposer>
+  list<T, Disposer>::~list()
+  {
+    auto i = this->begin();
+    while (i != this->end())
+    {
+      auto& elem = *i;
+      ++i; // intrusive list, so advance before destroying
+      Disposer::dispose(&elem);
+    }
+  }
+
+  template <typename T, typename Disposer>
+  auto
+  list<T, Disposer>::begin()
+  const
+  noexcept
+  -> iterator
+  {
+    return iterator{next};
+  }
+
+  template <typename T, typename Disposer>
+  auto
+  list<T, Disposer>::end()
+  const
+  noexcept
+  -> iterator
+  {
+    return iterator{this};
+  }
+
+  template <typename T, typename Disposer>
+  auto
+  list<T, Disposer>::push_front(
+    T* t)
+  noexcept
+  -> iterator
+  {
+    invariant_check();
+    t->next = next;
+    t->prev = this;
+    next->prev = t;
+    next = t;
+    invariant_check();
+    return iterator{t};
+  }
+
+  template <typename T, typename Disposer>
+  auto
+  list<T, Disposer>::push_back(
+    T* t)
+  noexcept
+  -> iterator
+  {
+    invariant_check();
+    t->prev = prev;
+    t->next = this;
+    prev->next = t;
+    prev = t;
+    invariant_check();
+    return iterator{t};
+  }
+
+  class sequence_matcher;
+
+  class sequence_type
+  {
+  public:
+    sequence_type() noexcept = default;
+    sequence_type(sequence_type&&) noexcept = delete;
+    sequence_type(const sequence_type&) = delete;
+    sequence_type& operator=(sequence_type&&) noexcept = delete;
+    sequence_type& operator=(const sequence_type&) = delete;
+    ~sequence_type();
+
+    bool
+    is_completed()
+    const
+    noexcept;
+
+    bool
+    is_first(
+      sequence_matcher const *m)
+    const
+    noexcept;
+
+    unsigned
+    cost(
+      sequence_matcher const *m)
+    const
+    noexcept;
+
+    void
+    retire_until(
+      sequence_matcher const* m)
+    noexcept;
+
+    void
+    add_last(
+      sequence_matcher *m)
+    noexcept;
+
+    void
+    validate_match(
+      severity s,
+      sequence_matcher const *matcher,
+      char const *seq_name,
+      char const *match_name,
+      location loc)
+    const;
+
+  private:
+    list<sequence_matcher> matchers;
+  };
+
+  class sequence
+  {
+  public:
+    sequence_type& operator*() { return *obj; }
+    bool is_completed() const { return obj->is_completed(); }
+  private:
+    std::unique_ptr<sequence_type> obj{detail::make_unique<sequence_type>()};
+  };
+
+  struct sequence_handler_base;
+
+  class sequence_matcher : public list_elem<sequence_matcher>
+  {
+  public:
+    using init_type = std::pair<char const*, sequence&>;
+
+    sequence_matcher(
+      char const *exp,
+      location loc,
+      const sequence_handler_base& handler,
+      init_type i)
+    noexcept
+    : seq_name(i.first)
+    , exp_name(exp)
+    , exp_loc(loc)
+    , sequence_handler(handler)
+    , seq(*i.second)
+    {
+      auto lock = get_lock();
+      seq.add_last(this);
+    }
+
+    void
+    validate_match(
+      severity s,
+      char const *match_name,
+      location loc)
+    const
+    {
+      seq.validate_match(s, this, seq_name, match_name, loc);
+    }
+
+    unsigned
+    cost()
+    const
+    noexcept
+    {
+      return seq.cost(this);
+    }
+
+    bool
+    is_satisfied()
+      const
+      noexcept;
+
+    bool
+    is_optional()
+      const
+      noexcept;
+
+    void
+    retire()
+    noexcept
+    {
+      this->unlink();
+    }
+
+    void
+    retire_predecessors()
+    noexcept
+    {
+      seq.retire_until(this);
+    }
+
+    void
+    print_expectation(std::ostream& os)
+    const
+    {
+      os << exp_name << " at " << exp_loc;
+    }
+
+    char const*
+    sequence_name()
+    const
+    noexcept
+    {
+      return seq_name;
+    }
+  private:
+    char const *seq_name;
+    char const *exp_name;
+    location    exp_loc;
+    const sequence_handler_base& sequence_handler;
+    sequence_type& seq;
+  };
+
+  inline
+  bool
+  sequence_type::is_completed()
+  const
+  noexcept
+  {
+    for (const auto& matcher : matchers)
+    {
+      if (!matcher.is_satisfied())
+      {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  inline
+  bool
+  sequence_type::is_first(
+    sequence_matcher const *m)
+  const
+  noexcept
+  {
+    return !matchers.empty() && &*matchers.begin() == m;
+  }
+
+  inline
+  unsigned
+  sequence_type::cost(
+    sequence_matcher const* m)
+  const
+  noexcept
+  {
+    unsigned sequence_cost = 0U;
+    for (auto const& e : matchers)
+    {
+      if (&e == m) return sequence_cost;
+      if (!e.is_satisfied())
+      {
+        return ~0U;
+      }
+      ++sequence_cost;
+    }
+    return ~0U;
+  }
+
+  inline
+  void
+  sequence_type::retire_until(
+    sequence_matcher const* m)
+  noexcept
+  {
+    while (!matchers.empty())
+    {
+      auto first = &*matchers.begin();
+      if (first == m) return;
+      first->retire();
+    }
+  }
+
+  inline
+  void
+  sequence_type::validate_match(
+    severity s,
+    sequence_matcher const *matcher,
+    char const* seq_name,
+    char const* match_name,
+    location loc)
+  const
+  {
+    if (is_first(matcher)) return;
+    if (matchers.empty())
+    {
+      std::ostringstream os;
+      os << "Sequence mismatch for sequence \"" << seq_name
+         << "\" with matching call of " << match_name
+         << " at " << loc
+         << ". Sequence \"" << seq_name
+         << "\" has no more pending expectations\n";
+      send_report<specialized>(s, loc, os.str());
+    }
+    bool first = true;
+    std::ostringstream os;
+    os << "Sequence mismatch for sequence \"" << seq_name
+       << "\" with matching call of " << match_name
+       << " at " << loc << ".\n";
+    for (auto const& m : matchers)
+    {
+      if (first || !m.is_optional())
+      {
+        if (first)
+        {
+          os << "Sequence \"" << seq_name << "\" has ";
+        }
+        else
+        {
+          os << "and has ";
+        }
+        m.print_expectation(os);
+        if (m.is_optional())
+        {
+          os << " first in line\n";
+        }
+        else
+        {
+          os << " as first required expectation\n";
+          break;
+        }
+      }
+      first = false;
+    }
+    send_report<specialized>(s, loc, os.str());
+  }
+
+  inline
+  sequence_type::~sequence_type()
+  {
+    bool touched = false;
+    std::ostringstream os;
+    while (!matchers.empty())
+    {
+      auto m = matchers.begin();
+      if (!touched)
+      {
+        os << "Sequence expectations not met at destruction of sequence object \""
+           << m->sequence_name() << "\":";
+        touched = true;
+      }
+      os << "\n  missing ";
+      m->print_expectation(os);
+      m->unlink();
+    }
+    if (touched)
+    {
+      os << "\n";
+      send_report<specialized>(severity::nonfatal, location{}, os.str());
+    }
+  }
+
+  inline
+  void
+  sequence_type::add_last(
+    sequence_matcher *m)
+  noexcept
+  {
+    matchers.push_back(m);
+  }
+
+  template <typename T>
+  void can_match_parameter(T&);
+
+  template <typename T>
+  void can_match_parameter(T&&);
+
+  template <typename M>
+  class ptr_deref : public matcher
+  {
+  public:
+    template <typename U,
+              typename = decltype(can_match_parameter<detail::remove_reference_t<decltype(*std::declval<U>())>>(std::declval<M>()))>
+    operator U() const;
+
+    template <typename U>
+    explicit
+    ptr_deref(
+      U&& m_)
+      : m( std::forward<U>(m_) )
+    {}
+
+    template <typename U>
+    bool
+    matches(
+      const U& u)
+    const
+    noexcept(noexcept(std::declval<M>().matches(*u)))
+    {
+      return (u != nullptr) && m.matches(*u);
+    }
+
+    friend
+    std::ostream&
+    operator<<(
+      std::ostream& os,
+      ptr_deref<M> const& p)
+    {
+      return os << p.m;
+    }
+  private:
+    M m;
+  };
+
+  template <typename M>
+  class neg_matcher : public matcher
+  {
+  public:
+    template <typename U,
+              typename = decltype(can_match_parameter<detail::remove_reference_t<decltype(std::declval<U>())>>(std::declval<M>()))>
+    operator U() const { return {}; }
+
+    template <typename U>
+    explicit
+    neg_matcher(
+      U&& m_)
+      : m( std::forward<U>(m_) )
+    {}
+
+    template <typename U>
+    bool
+    matches(
+      const U& u)
+    const
+    noexcept(noexcept(!std::declval<M>().matches(u)))
+    {
+      return !m.matches(u);
+    }
+
+    friend
+    std::ostream&
+    operator<<(
+      std::ostream& os,
+      neg_matcher<M> const& p)
+    {
+      return os << p.m;
+    }
+  private:
+    M m;
+  };
+
+  template <typename MatchType, typename Predicate, typename ... ActualType>
+  struct matcher_kind
+  {
+    using type = typed_matcher<MatchType>;
+  };
+
+  template <typename Predicate, typename ... ActualType>
+  struct matcher_kind<wildcard, Predicate, ActualType...>
+  {
+    using type = duck_typed_matcher<Predicate, ActualType...>;
+  };
+
+  template <typename MatchType, typename Predicate, typename ... ActualType>
+  using matcher_kind_t =
+    typename matcher_kind<MatchType, Predicate, ActualType...>::type;
+
+  template <typename Predicate, typename Printer, typename MatcherType, typename ... T>
+  class predicate_matcher
+    : private Predicate
+    , private Printer
+    , public MatcherType
+  {
+  public:
+    template <typename ... U>
+    constexpr
+    predicate_matcher(
+      Predicate&& pred,
+      Printer&& printer,
+      U&& ... v)
+      noexcept(noexcept(std::tuple<T...>(std::declval<U>()...)) && noexcept(Predicate(std::declval<Predicate&&>())) && noexcept(Printer(std::declval<Printer&&>())))
+      : Predicate(std::move(pred))
+      , Printer(std::move(printer))
+      , value(std::forward<U>(v)...)
+    {}
+
+    template <typename V>
+    constexpr
+    bool
+    matches(
+      V&& v)
+      const
+      noexcept(noexcept(std::declval<Predicate const&>()(std::declval<V&&>(), std::declval<const T&>()...)))
+    {
+      return matches_(std::forward<V>(v), detail::make_index_sequence<sizeof...(T)>{});
+    }
+
+    friend
+    std::ostream&
+    operator<<(
+      std::ostream& os,
+      predicate_matcher const& v)
+    {
+      return v.print_(os, detail::make_index_sequence<sizeof...(T)>{});
+    }
+  private:
+    // The below function call operator must be declared to
+    // work around gcc bug 78446
+    //
+    // For some reason microsoft compiler from VS2015 update 3
+    // requires the function call operator to be private to avoid
+    // ambiguities.
+    template <typename ... U>
+    void operator()(U&&...) const = delete;
+
+    template <typename V, size_t ... I>
+    bool matches_(V&& v, detail::index_sequence<I...>) const
+    {
+      return Predicate::operator()(std::forward<V>(v), std::get<I>(value)...);
+    }
+
+    template <size_t ... I>
+    std::ostream& print_(std::ostream& os_, detail::index_sequence<I...>) const
+    {
+      Printer::operator()(os_, std::get<I>(value)...);
+      return os_;
+    }
+
+    std::tuple<T...> value;
+  };
+
+  template <typename MatchType, typename Predicate, typename Printer, typename ... T>
+  using make_matcher_return =
+    predicate_matcher<Predicate,
+      Printer,
+      matcher_kind_t<MatchType, Predicate, detail::decay_t<T>...>,
+      detail::decay_t<T>...>;
+
+  namespace lambdas {
+
+    struct any_predicate
+    {
+      template <typename T>
+      bool
+      operator()(
+        T&&)
+      const
+      {
+        return true;
+      }
+    };
+
+    // The below must be classes/structs to work with VS 2015 update 3
+    // since it doesn't respect the trailing return type declaration on
+    // the lambdas of template deduction context
+
+#define TROMPELOEIL_MK_PRED_BINOP(name, op)                         \
+    struct name {                                                       \
+      template <typename X, typename Y>                                 \
+      auto operator()(X const& x, Y const& y) const -> decltype(x op y) \
+      {                                                                 \
+        ::trompeloeil::ignore(x,y);                                     \
+        return x op y;                                                  \
+      }                                                                 \
+    }
+    TROMPELOEIL_MK_PRED_BINOP(equal, ==);
+    TROMPELOEIL_MK_PRED_BINOP(not_equal, !=);
+    TROMPELOEIL_MK_PRED_BINOP(less, <);
+    TROMPELOEIL_MK_PRED_BINOP(less_equal, <=);
+    TROMPELOEIL_MK_PRED_BINOP(greater, >);
+    TROMPELOEIL_MK_PRED_BINOP(greater_equal, >=);
+#undef TROMPELOEIL_MK_PRED_BINOP
+
+    // Define `struct` with `operator()` to replace generic lambdas.
+
+    struct any_printer
+    {
+      explicit
+      any_printer(
+        char const* type_name_)
+        : type_name(type_name_)
+      {}
+
+      void
+      operator()(
+        std::ostream& os)
+      const
+      {
+        os << " matching ANY(" << type_name << ")";
+      }
+
+    private:
+      char const* type_name;
+    };
+
+    // These structures replace the `op` printer lambdas.
+
+#define TROMPELOEIL_MK_OP_PRINTER(name, op_string)                  \
+    struct name ## _printer                                             \
+    {                                                                   \
+      template <typename T>                                             \
+      void                                                              \
+      operator()(                                                       \
+        std::ostream& os,                                               \
+        T const& value)                                                 \
+      const                                                             \
+      {                                                                 \
+        os << op_string;                                                \
+        ::trompeloeil::print(os, value);                                \
+      }                                                                 \
+    }
+    TROMPELOEIL_MK_OP_PRINTER(equal, " == ");
+    TROMPELOEIL_MK_OP_PRINTER(not_equal, " != ");
+    TROMPELOEIL_MK_OP_PRINTER(less, " < ");
+    TROMPELOEIL_MK_OP_PRINTER(less_equal, " <= ");
+    TROMPELOEIL_MK_OP_PRINTER(greater, " > ");
+    TROMPELOEIL_MK_OP_PRINTER(greater_equal, " >= ");
+#undef TROMPELOEIL_MK_OP_PRINTER
+
+  }
+
+  template <typename MatchType, typename Predicate, typename Printer, typename ... T>
+  inline
+  make_matcher_return<MatchType, Predicate, Printer, T...>
+  make_matcher(Predicate pred, Printer print, T&& ... t)
+  {
+    return {std::move(pred), std::move(print), std::forward<T>(t)...};
+  }
+
+
+  template <
+    typename T,
+    typename R = make_matcher_return<T, lambdas::any_predicate, lambdas::any_printer>>
+  inline
+  auto
+  any_matcher_impl(char const* type_name, std::false_type)
+  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+  {
+    return make_matcher<T>(lambdas::any_predicate(), lambdas::any_printer(type_name));
+  }
+
+  template <typename T>
+  wildcard
+  any_matcher_impl(char const*, std::true_type);
+
+  template <typename T>
+  inline
+  auto
+  any_matcher(char const* name)
+  TROMPELOEIL_TRAILING_RETURN_TYPE(decltype(any_matcher_impl<T>(name, std::is_array<T>{})))
+  {
+    static_assert(!std::is_array<T>::value,
+                  "array parameter type decays to pointer type for ANY()"
+                  " matcher. Please rephrase as pointer instead");
+    return any_matcher_impl<T>(name, std::is_array<T>{});
+  }
+  template <
+    typename T = wildcard,
+    typename V,
+    typename R = make_matcher_return<T, lambdas::equal, lambdas::equal_printer, V>>
+  inline
+  auto
+  eq(
+    V&& v)
+  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+  {
+    return make_matcher<T>(lambdas::equal(),
+                           lambdas::equal_printer(),
+                           std::forward<V>(v));
+  }
+
+  template <
+    typename T = wildcard,
+    typename V,
+    typename R = make_matcher_return<T, lambdas::not_equal, lambdas::not_equal_printer, V>>
+  inline
+  auto
+  ne(
+    V&& v)
+  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+  {
+    return make_matcher<T>(lambdas::not_equal(),
+                           lambdas::not_equal_printer(),
+                           std::forward<V>(v));
+  }
+
+  template <
+    typename T = wildcard,
+    typename V,
+    typename R = make_matcher_return<T, lambdas::greater_equal, lambdas::greater_equal_printer, V>>
+  inline
+  auto
+  ge(
+    V&& v)
+  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+  {
+    return make_matcher<T>(lambdas::greater_equal(),
+                           lambdas::greater_equal_printer(),
+                           std::forward<V>(v));
+  }
+
+  template <
+    typename T = wildcard,
+    typename V,
+    typename R = make_matcher_return<T, lambdas::greater, lambdas::greater_printer, V>>
+  inline
+  auto
+  gt(
+    V&& v)
+  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+  {
+    return make_matcher<T>(lambdas::greater(),
+                           lambdas::greater_printer(),
+                           std::forward<V>(v));
+  }
+
+  template <
+    typename T = wildcard,
+    typename V,
+    typename R = make_matcher_return<T, lambdas::less, lambdas::less_printer, V>>
+  inline
+  auto
+  lt(
+    V&& v)
+  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+  {
+    return make_matcher<T>(lambdas::less(),
+                           lambdas::less_printer(),
+                           std::forward<V>(v));
+  }
+
+  template <
+    typename T = wildcard,
+    typename V,
+    typename R = make_matcher_return<T, lambdas::less_equal, lambdas::less_equal_printer,  V>>
+  inline
+  auto
+  le(
+    V&& v)
+  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+  {
+    return make_matcher<T>(lambdas::less_equal(),
+                           lambdas::less_equal_printer(),
+                           std::forward<V>(v));
+  }
+
+  namespace lambdas {
+
+    struct regex_check
+    {
+
+      class string_helper // a vastly simplified string_view type of class
+      {
+      public:
+        template <
+          typename S,
+          typename = decltype(std::declval<const char*&>() = std::declval<S>().data()),
+          typename = decltype(std::declval<S>().length())
+            >
+        string_helper(
+          const S& s)
+        noexcept
+          : begin_(s.data())
+          , end_(begin_ + s.length())
+        {}
+
+        constexpr
+        string_helper(
+          char const* s)
+        noexcept
+          : begin_(s)
+          , end_(s ? begin_ + strlen(s) : nullptr)
+        {
+        }
+
+        constexpr
+        explicit
+        operator bool() const
+        {
+          return begin_;
+        }
+        constexpr
+        char const *
+        begin()
+          const
+        {
+          return begin_;
+        }
+        constexpr
+        char const *
+        end()
+          const
+        {
+          return end_;
+        }
+      private:
+        char const* begin_;
+        char const* end_;
+      };
+
+      regex_check(
+        std::regex&& re_,
+        std::regex_constants::match_flag_type match_type_)
+        : re(std::move(re_)),
+          match_type(match_type_)
+      {}
+
+      template <typename T>
+      bool
+      operator()(
+        string_helper str,
+        T const&)
+      const
+      {
+        return str && std::regex_search(str.begin(), str.end(), re, match_type);
+      }
+
+    private:
+      std::regex re;
+      std::regex_constants::match_flag_type match_type;
+    };
+
+    struct regex_printer
+    {
+      template <typename T>
+      void
+      operator()(
+        std::ostream& os,
+        T const& str)
+      const
+      {
+        os << " matching regular expression /" << str << "/";
+      }
+    };
+  }
+
+  template <
+    typename Kind = wildcard,
+    typename R = make_matcher_return<Kind, lambdas::regex_check, lambdas::regex_printer, std::string&&>>
+  auto
+  re(
+    std::string s,
+    std::regex_constants::syntax_option_type opt = std::regex_constants::ECMAScript,
+    std::regex_constants::match_flag_type match_type = std::regex_constants::match_default)
+  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+  {
+    return make_matcher<Kind>(lambdas::regex_check(std::regex(s, opt),
+                                                   match_type),
+                              lambdas::regex_printer(),
+                              std::move(s));
+  }
+
+  template <
+    typename Kind = wildcard,
+    typename R = make_matcher_return<Kind, lambdas::regex_check, lambdas::regex_printer, std::string&&>>
+  auto
+  re(
+    std::string s,
+    std::regex_constants::match_flag_type match_type)
+  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+  {
+    return make_matcher<Kind>(lambdas::regex_check(std::regex(s), match_type),
+                              lambdas::regex_printer(),
+                              std::move(s));
+  }
+
+  inline
+  std::string
+  param_name_prefix(
+    void const*)
+  {
+    return "";
+  }
+
+  template <typename M>
+  std::string
+  param_name_prefix(
+    const ptr_deref<M>*)
+  {
+    return "*" + ::trompeloeil::param_name_prefix(static_cast<M*>(nullptr));
+  }
+
+  template <typename M>
+  std::string
+  param_name_prefix(
+    const neg_matcher<M>*)
+  {
+    return "not " + ::trompeloeil::param_name_prefix(static_cast<M*>(nullptr));
+  }
+
+  template <typename T>
+  struct null_on_move
+  {
+  public:
+    null_on_move()
+    noexcept
+    = default;
+
+    null_on_move(
+      null_on_move&&)
+    noexcept
+    {}
+
+    null_on_move(
+      null_on_move const&)
+    noexcept
+    {}
+
+    ~null_on_move()
+    = default;
+
+    null_on_move&
+    operator=(
+      const null_on_move&)
+    noexcept
+    {
+      p = nullptr;
+      return *this;
+    }
+
+    null_on_move&
+    operator=(
+      null_on_move&&)
+    noexcept
+    {
+      p = nullptr;
+      return *this;
+    }
+
+    null_on_move&
+    operator=(
+      T* t)
+    noexcept
+    {
+      p = t;
+      return *this;
+    }
+
+    T*&
+    leak()
+    noexcept
+    {
+      return p;
+    }
+
+    T&
+    operator*()
+    const
+    noexcept
+    {
+      return *p;
+    }
+
+    T*
+    operator->()
+    const
+    noexcept
+    {
+      return p;
+    }
+
+    explicit
+    operator bool()
+    const
+    noexcept
+    {
+      return p != nullptr;
+    }
+  private:
+    T* p = nullptr;
+  };
+
+  struct sequence_handler_base
+  {
+  private:
+    size_t min_calls{1};
+    size_t max_calls{1};
+    size_t call_count{0};
+  public:
+
+    virtual
+    ~sequence_handler_base()
+    noexcept = default;
+
+    void
+      increment_call()
+      noexcept
+    {
+      ++call_count;
+    }
+    bool
+      is_satisfied()
+      const
+      noexcept
+    {
+      return call_count >= min_calls;
+    }
+
+    bool
+      is_saturated()
+      const
+      noexcept
+    {
+      return call_count == max_calls;
+    }
+
+    bool
+      is_forbidden()
+      const
+      noexcept
+    {
+      return max_calls == 0ULL;
+    }
+
+    void
+    set_limits(size_t L, size_t H)
+      noexcept
+    {
+      min_calls = L;
+      max_calls = H;
+    }
+
+    size_t
+    get_min_calls()
+      const
+      noexcept
+    {
+      return min_calls;
+    }
+
+    size_t
+      get_calls()
+      const
+      noexcept
+    {
+      return call_count;
+    }
+
+    virtual
+    void
+      validate(severity s, char const *, location) = 0;
+
+    virtual
+    bool
+    can_be_called()
+    const
+    noexcept = 0;
+
+    virtual
+    unsigned
+    order()
+    const
+    noexcept = 0;
+
+    virtual
+    void
+      retire()
+      noexcept = 0;
+
+    virtual
+    void
+    retire_predecessors()
+    noexcept = 0;
+  protected:
+    sequence_handler_base() = default;
+    sequence_handler_base(const sequence_handler_base&) = default;
+  };
+
+  inline
+  bool
+  sequence_matcher::is_satisfied()
+  const
+  noexcept
+  {
+    return sequence_handler.is_satisfied();
+  }
+
+  inline
+  bool
+  sequence_matcher::is_optional()
+  const
+  noexcept
+  {
+    return sequence_handler.get_min_calls() == 0;
+  }
+
+  template <size_t N>
+  struct sequence_handler : public sequence_handler_base
+  {
+  public:
+    template <size_t M = N, typename detail::enable_if_t<M == 0>* = nullptr>
+    sequence_handler()
+      noexcept
+    {}
+
+    template <typename ... S>
+    sequence_handler(
+      const sequence_handler_base& base,
+      char const *name,
+      location loc,
+      S&& ... s)
+    noexcept
+      : sequence_handler_base(base)
+      , matchers{{sequence_matcher{name, loc, *this, std::forward<S>(s)}...}}
+    {
+    }
+
+    void
+    validate(
+      severity s,
+      char const *match_name,
+      location loc)
+    override
+    {
+      for (auto& e : matchers)
+      {
+        e.validate_match(s, match_name, loc);
+      }
+    }
+
+    unsigned
+    order()
+    const
+    noexcept
+    override
+    {
+      unsigned highest_order = 0U;
+      for (auto& m : matchers)
+      {
+        auto cost = m.cost();
+        if (cost > highest_order)
+        {
+          highest_order = cost;
+        }
+      }
+      return highest_order;
+    }
+
+    bool
+    can_be_called()
+    const
+    noexcept
+    override
+    {
+      return order() != ~0U;
+    }
+
+    void
+    retire()
+    noexcept
+    override
+    {
+      for (auto& e : matchers)
+      {
+        e.retire();
+      }
+    }
+
+    void
+    retire_predecessors()
+    noexcept
+      override
+    {
+      for (auto& e : matchers)
+      {
+        e.retire_predecessors();
+      }
+    }
+  private:
+    // work around for MS STL issue 942
+    // https://github.com/microsoft/STL/issues/942
+    detail::conditional_t<N == 0,
+                          std::vector<sequence_matcher>,
+                          std::array<sequence_matcher, N>> matchers;
+  };
+
+  struct lifetime_monitor;
+
+  template <typename T>
+  class deathwatched : public T
+  {
+    static_assert(std::has_virtual_destructor<T>::value,
+                  "virtual destructor is a necessity for deathwatched to work");
+  public:
+    template <typename ... U,
+              typename = detail::enable_if_t<std::is_constructible<T,U...>::value>>
+    deathwatched(
+      U&& ...u)
+    noexcept(noexcept(T(std::declval<U>()...)))
+      : T(std::forward<U>(u)...)
+    {}
+
+    ~deathwatched() override;
+
+    trompeloeil::lifetime_monitor*&
+    trompeloeil_expect_death(
+      trompeloeil::lifetime_monitor* monitor)
+    const
+    noexcept
+    {
+      auto lock = get_lock();
+      trompeloeil_lifetime_monitor = monitor;
+      return trompeloeil_lifetime_monitor.leak();
+    }
+  private:
+    mutable null_on_move<trompeloeil::lifetime_monitor> trompeloeil_lifetime_monitor;
+  };
+
+  struct expectation {
+    virtual ~expectation() = default;
+    virtual bool is_satisfied() const noexcept = 0;
+    virtual bool is_saturated() const noexcept = 0;
+  };
+
+  struct lifetime_monitor : public expectation
+  {
+    template <typename T>
+    lifetime_monitor(
+      ::trompeloeil::deathwatched<T> const &obj,
+      char const* obj_name_,
+      char const* invocation_name_,
+      char const* call_name_,
+      location loc_)
+    noexcept
+      : object_monitor(obj.trompeloeil_expect_death(this))
+      , loc(loc_)
+      , object_name(obj_name_)
+      , invocation_name(invocation_name_)
+      , call_name(call_name_)
+    {
+    }
+
+    bool is_satisfied() const noexcept override
+    {
+      return died;
+    }
+
+    bool is_saturated() const noexcept override
+    {
+      return died;
+    }
+
+    lifetime_monitor(lifetime_monitor const&) = delete;
+
+    ~lifetime_monitor() override
+    {
+      auto lock = get_lock();
+      if (!died)
+      {
+        std::ostringstream os;
+        os << "Object " << object_name << " is still alive";
+        send_report<specialized>(severity::nonfatal, loc, os.str());
+        object_monitor = nullptr; // prevent its death poking this cadaver
+      }
+    }
+
+    void
+    notify()
+    noexcept
+    {
+      died = true;
+      sequences->validate(severity::nonfatal, call_name, loc);
+
+      sequences->increment_call();
+      if (sequences->is_satisfied())
+      {
+        sequences->retire_predecessors();
+      }
+    }
+
+    template <typename ... T>
+    void
+    set_sequence(
+      T&& ... t)
+    {
+      using handler = sequence_handler<sizeof...(T)>;
+      auto seq = detail::make_unique<handler>(*sequences,
+                                              invocation_name,
+                                              loc,
+                                              std::forward<T>(t)...);
+      sequences = std::move(seq);
+    }
+  private:
+    atomic<bool>       died{false};
+    lifetime_monitor *&object_monitor;
+    location           loc;
+    char const        *object_name;
+    char const        *invocation_name;
+    char const        *call_name;
+    std::unique_ptr<sequence_handler_base>  sequences = detail::make_unique<sequence_handler<0>>();
+  };
+
+  template <typename T>
+  deathwatched<T>::~deathwatched()
+  {
+    auto lock = get_lock();
+    if (trompeloeil_lifetime_monitor)
+    {
+      trompeloeil_lifetime_monitor->notify();
+      return;
+    }
+    std::ostringstream os;
+    os << "Unexpected destruction of "
+       << TROMPELOEIL_TYPE_ID_NAME(T) << "@" << this << '\n';
+    send_report<specialized>(severity::nonfatal,
+                             location{},
+                             os.str());
+  }
+
+  template <typename T>
+  struct return_of;
+
+  template <typename R, typename ... A>
+  struct return_of<R(A...)>
+  {
+    using type = R;
+  };
+
+  template <typename T>
+  using return_of_t = typename return_of<T>::type;
+
+  template <typename T>
+  struct call_params_type;
+
+  template <typename R, typename ... T>
+  struct call_params_type<R(T...)>
+  {
+    using type = std::tuple<typename std::add_lvalue_reference<T>::type...>;
+  };
+
+  template <typename T>
+  using call_params_type_t = typename call_params_type<T>::type;
+
+
+  template <typename R>
+  struct default_return_t
+  {
+    TROMPELOEIL_NORETURN static R value()
+    {
+      std::abort(); // must never be called
+    }
+  };
+
+#if TROMPELOEIL_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4702)
+#endif
+  template <typename R>
+  inline
+  R
+  default_return()
+  {
+    return default_return_t<R>::value();
+  }
+#if TROMPELOEIL_MSVC
+#pragma warning(pop)
+#endif
+
+
+
+  template <>
+  inline
+  void
+  default_return<void>()
+  {
+    // Implicitly do nothing when returning from function returning void
+  }
+
+  template <typename Sig>
+  struct call_matcher_base;
+
+  template <typename Sig>
+  struct call_matcher_list : public list<call_matcher_base<Sig>>
+  {
+    void decommission()
+    {
+      auto lock = get_lock();
+      auto iter = this->begin();
+      auto const e = this->end();
+      while (iter != e)
+      {
+        auto &m = *iter;
+        ++iter; // intrusive list, so must advance to next before destroying
+        m.mock_destroyed();
+        m.unlink();
+      }
+    }
+  };
+
+  template <typename Sig>
+  struct call_matcher_base : public list_elem<call_matcher_base<Sig>>
+  {
+    using sig = Sig;
+    call_matcher_base(
+      location loc_,
+      char const* name_)
+    : loc{loc_}
+    , name{name_}
+    {
+    }
+
+    call_matcher_base(call_matcher_base&&) = delete;
+
+    ~call_matcher_base() override = default;
+
+    virtual
+    void
+    mock_destroyed() = 0;
+
+    virtual
+    bool
+    matches(
+      call_params_type_t<Sig> const&)
+    const = 0;
+
+    virtual
+    unsigned
+    sequence_cost()
+    const
+    noexcept = 0;
+
+    virtual
+    void
+    run_actions(
+      call_params_type_t<Sig> &,
+      call_matcher_list<Sig> &saturated_list
+    ) = 0;
+
+    virtual
+    std::ostream&
+    report_signature(
+      std::ostream&)
+    const = 0;
+
+    TROMPELOEIL_NORETURN
+    virtual
+    std::ostream&
+    report_mismatch(
+      std::ostream&,
+      call_params_type_t<Sig> const &) = 0;
+
+    virtual
+    return_of_t<Sig>
+    return_value(
+      trace_agent&,
+      call_params_type_t<Sig>& p) = 0;
+
+    location loc;
+    char const *name;
+  };
+
+  template <typename T, typename U>
+  bool
+  param_matches_impl(
+    T const& t,
+    U const& u,
+    matcher const*)
+  noexcept(noexcept(t.matches(u)))
+  {
+    return t.matches(u);
+  }
+
+  template <typename T,
+            typename U,
+            typename = detail::enable_if_t<is_equal_comparable<T, U>::value>>
+  inline
+  U&
+  identity(
+    U& t)
+  noexcept
+  {
+    return t;
+  }
+
+  template <typename T,
+            typename U,
+            typename = detail::enable_if_t<!is_equal_comparable<T, U>::value>>
+  inline
+  T
+  identity(
+    const U& u)
+  noexcept(noexcept(T(u)))
+  {
+    return u;
+  }
+
+  template <typename T, typename U>
+  bool
+  param_matches_impl(
+    T const& t,
+    U const& u,
+    void const*)
+  noexcept(noexcept(::trompeloeil::identity<U>(t) == u))
+  {
+    return ::trompeloeil::identity<U>(t) == u;
+  }
+
+  template <typename T, typename U>
+  bool
+  param_matches(
+    T const& t,
+    U const& u)
+  noexcept(noexcept(param_matches_impl(t, u, &t)))
+  {
+    return ::trompeloeil::param_matches_impl(t, u, &t);
+  }
+
+  template <size_t ... I, typename T, typename U>
+  bool
+  match_parameters(
+    detail::index_sequence<I...>,
+    T const& t,
+    U const& u)
+    noexcept(noexcept(std::initializer_list<bool>{trompeloeil::param_matches(std::get<I>(t),std::get<I>(u))...}))
+  {
+    bool all_true = true;
+    ::trompeloeil::ignore(t, u); // Kills unmotivated VS2015 warning in the empty case
+    ::trompeloeil::ignore(std::initializer_list<bool>{all_true = all_true && ::trompeloeil::param_matches(std::get<I>(t), std::get<I>(u))...});
+    return all_true;
+  }
+
+  template <typename ... T, typename ... U>
+  bool
+  match_parameters(
+    std::tuple<T...> const& t,
+    std::tuple<U...> const& u)
+  noexcept(noexcept(match_parameters(detail::make_index_sequence<sizeof...(T)>{}, t, u)))
+  {
+    return ::trompeloeil::match_parameters(detail::make_index_sequence<sizeof...(T)>{}, t, u);
+  }
+
+  template <typename V, typename P>
+  void print_mismatch(
+    std::ostream& os,
+    size_t num,
+    V const& v,
+    P const& p)
+  {
+    if (!::trompeloeil::param_matches(v, p))
+    {
+      auto prefix = ::trompeloeil::param_name_prefix(&v) + "_";
+      os << "  Expected " << std::setw((num < 9) ? 2 : 1) << prefix << num+1;
+      ::trompeloeil::print_expectation(os, v);
+    }
+  }
+
+  template <typename ... V, typename ... P, size_t ... I>
+  void print_mismatch(
+    std::ostream& os,
+    detail::index_sequence<I...>,
+    std::tuple<V...> const& v,
+    std::tuple<P...> const& p)
+  {
+    ::trompeloeil::ignore(os, v, p);  // Kills unmotivated VS2015 warning in the empty case
+    ::trompeloeil::ignore(std::initializer_list<int>{(print_mismatch(os, I, std::get<I>(v), std::get<I>(p)),0)...});
+  }
+
+  template <typename ... V, typename ... P>
+  void print_mismatch(
+    std::ostream& os,
+    std::tuple<V...> const& v,
+    std::tuple<P...> const& p)
+  {
+    print_mismatch(os, detail::make_index_sequence<sizeof...(V)>{}, v, p);
+  }
+
+  template <typename T>
+  void missed_value(
+    std::ostream& os,
+    int i,
+    T const& t)
+  {
+    auto prefix = ::trompeloeil::param_name_prefix(&t) + "_";
+    os << "  param " << std::setw((i < 9) ? 2 : 1) << prefix << i + 1
+       << ::trompeloeil::param_compare_operator(&t);
+    ::trompeloeil::print(os, t);
+    os << '\n';
+  }
+
+  template <size_t ... I, typename ... T>
+  void stream_params(
+    std::ostream &os,
+    detail::index_sequence<I...>,
+    std::tuple<T...> const &t)
+  {
+    ::trompeloeil::ignore(os, t);  // Kills unmotivated VS2015 warning in the empty case
+    ::trompeloeil::ignore(std::initializer_list<int>{(missed_value(os, I, std::get<I>(t)),0)...});
+  }
+
+  template <typename ... T>
+  void
+  stream_params(
+    std::ostream &os,
+    std::tuple<T...> const &t)
+  {
+    stream_params(os, detail::make_index_sequence<sizeof...(T)>{}, t);
+  }
+
+  template <typename ... T>
+  std::string
+  params_string(
+    std::tuple<T...> const& t)
+  {
+    std::ostringstream os;
+    stream_params(os, t);
+    return os.str();
+  }
+
+  class trace_agent
+  {
+  public:
+    trace_agent(
+      location loc_,
+      char const* name_,
+      tracer* t_)
+    : loc{loc_}
+    , t{t_}
+    {
+      if (t)
+      {
+        os << name_ << " with.\n";
+      }
+    }
+
+    trace_agent(trace_agent const&) = delete;
+
+    trace_agent(trace_agent &&) = delete;
+
+    ~trace_agent()
+    {
+      if (t)
+      {
+        t->trace(loc.file, loc.line, os.str());
+      }
+    }
+
+    trace_agent&
+    operator=(trace_agent const&) = delete;
+
+    trace_agent&
+    operator=(trace_agent &&) = delete;
+
+    template <typename ... T>
+    void
+    trace_params(
+      std::tuple<T...> const& params)
+    {
+      if (t)
+      {
+        stream_params(os, params);
+      }
+    }
+
+    template <typename T>
+    auto
+    trace_return(
+      T&& rv)
+    -> T
+    {
+      if (t)
+      {
+        os << " -> ";
+        print(os, rv);
+        os << '\n';
+      }
+      return std::forward<T>(rv);
+    }
+
+    void
+    trace_exception()
+    {
+      if (t)
+      {
+        try {
+          throw;
+        }
+        catch (std::exception const& e)
+        {
+          os << "threw exception: what() = " << e.what() << '\n';
+        }
+        catch (...)
+        {
+          os << "threw unknown exception\n";
+        }
+      }
+    }
+  private:
+    location loc;
+    tracer* t;
+    std::ostringstream os;
+  };
+
+  template <typename Sig>
+  call_matcher_base <Sig> *
+  find(
+    call_matcher_list <Sig> &list,
+    call_params_type_t <Sig> const &p)
+  noexcept
+  {
+    call_matcher_base<Sig>* first_match = nullptr;
+    unsigned lowest_cost = ~0U;
+    for (auto& i : list)
+    {
+      if (i.matches(p))
+      {
+        unsigned cost = i.sequence_cost();
+        if (cost == 0)
+        {
+          return &i;
+        }
+        if (!first_match || cost < lowest_cost)
+        {
+          first_match = &i;
+          lowest_cost = cost;
+        }
+      }
+    }
+    return first_match;
+  }
+
+  template <typename Sig>
+  TROMPELOEIL_NORETURN
+  void
+  report_mismatch(
+    call_matcher_list <Sig> &matcher_list,
+    call_matcher_list <Sig> &saturated_list,
+    std::string const &name,
+    call_params_type_t <Sig> const &p)
+  {
+    std::ostringstream os;
+    os << "No match for call of " << name << " with.\n";
+    stream_params(os, p);
+    bool saturated_match = false;
+    for (auto& m : saturated_list)
+    {
+      if (m.matches(p))
+      {
+        if (!saturated_match)
+        {
+          os << "\nMatches saturated call requirement\n";
+          saturated_match = true;
+        }
+        os << "  ";
+        m.report_signature(os) << '\n';
+      }
+    }
+    if (!saturated_match)
+    {
+      for (auto& m : matcher_list)
+      {
+        os << "\nTried ";
+        m.report_mismatch(os, p);
+      }
+    }
+    send_report<specialized>(severity::fatal, location{}, os.str());
+    std::abort(); // must never get here.
+  }
+
+  template <typename Sig>
+  void
+  report_match(
+    call_matcher_list <Sig> &matcher_list)
+  {
+    if(! matcher_list.empty())
+    {
+        send_ok_report<specialized>((matcher_list.begin())->name);
+    }
+  }
+
+  template <typename Sig>
+  class return_handler
+  {
+  public:
+    virtual
+    ~return_handler() = default;
+
+    virtual
+    return_of_t<Sig>
+    call(
+      trace_agent&,
+      call_params_type_t<Sig>& params) = 0;
+  };
+
+  template <typename Ret, typename F, typename P, typename = detail::enable_if_t<std::is_void<Ret>::value>>
+  void
+  trace_return(
+    trace_agent const&,
+    F& func,
+    P& params)
+  {
+    func(params);
+  }
+
+  template <typename Ret, typename F, typename P, typename = detail::enable_if_t<!std::is_void<Ret>::value>>
+  Ret
+  trace_return(
+    trace_agent& agent,
+    F& func,
+    P& params)
+  {
+    /* Work around VS 2017 15.7.x C4702 warning by
+     * enclosing the operation in an otherwise
+     * unnecessary try/catch block.
+     */
+    try
+    {
+      return agent.trace_return(func(params));
+    }
+    catch (...)
+    {
+      throw;
+    }
+  }
+
+  template <typename Sig, typename T>
+  class return_handler_t : public return_handler<Sig>
+  {
+  public:
+    template <typename U>
+    explicit
+    return_handler_t(
+      U&& u)
+    : func(std::forward<U>(u))
+    {}
+
+    return_of_t<Sig>
+    call(
+      trace_agent& agent,
+      call_params_type_t<Sig>& params)
+    override
+    {
+      return trace_return<return_of_t<Sig>>(agent, func, params);
+    }
+  private:
+    T func;
+  };
+
+#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
+  template <typename Sig, bool = trompeloeil::is_coroutine<return_of_t<Sig>>::value>
+  struct yield_expr_base : public list_elem<yield_expr_base<Sig, true>>
+  {
+    ~yield_expr_base() override = default;
+
+    using ret_type = coro_value_type_t<return_of_t<Sig>>;
+    virtual
+    ret_type
+    expr(
+      call_params_type_t<Sig>&)
+    const = 0;
+  };
+  template <typename Sig>
+  struct yield_expr_base<Sig, false> : public list_elem<yield_expr_base<Sig, false>>
+  {
+    using ret_type = return_of_t<Sig>;
+    virtual
+    ret_type
+    expr(
+      call_params_type_t<Sig>&)
+    const = 0;
+  };
+
+  template <typename Sig>
+  using yield_expr_list = list<yield_expr_base<Sig>, delete_disposer>;
+
+  template <typename Sig, typename Expr>
+  struct yield_expr : yield_expr_base<Sig>
+  {
+    using ret_type = typename yield_expr_base<Sig>::ret_type;
+    template <typename E>
+    explicit
+    yield_expr(
+      E&& e_)
+      : e(std::forward<E>(e_))
+    {}
+
+    ret_type
+    expr(
+      call_params_type_t<Sig>& t)
+    const
+    override
+    {
+      return e(t);
+    }
+  private:
+    Expr e;
+  };
+
+  template <typename Sig, typename T>
+  class co_return_handler_t : public return_handler<Sig>
+  {
+  public:
+    template <typename U>
+    explicit
+    co_return_handler_t(
+      U&& u,
+      std::shared_ptr<yield_expr_list<Sig>> yields_)
+      : func(std::forward<U>(u))
+      , yields(std::move(yields_))
+    {}
+
+    return_of_t<Sig>
+    call(
+      trace_agent& /*agent*/,
+      call_params_type_t<Sig>& params)
+    override
+    {
+      using coro_type = return_of_t<Sig>;
+      using promise_type = typename std::coroutine_traits<coro_type>::promise_type;
+      using value_type = coro_value_type_t<coro_type>;
+      if constexpr (requires {std::declval<promise_type&>().yield_value(std::declval<value_type>());})
+      {
+        for (auto & e : *yields)
+        {
+          co_yield e.expr(params);
+        }
+      }
+      co_return func(params);
+    }
+  private:
+    T func;
+    std::shared_ptr<yield_expr_list<Sig>> yields;
+  };
+#endif
+
+  template <typename Sig>
+  class condition_base : public list_elem<condition_base<Sig>>
+  {
+  public:
+    explicit
+    condition_base(
+      char const *n)
+    noexcept
+      : id(n)
+    {}
+
+    ~condition_base() override = default;
+
+    virtual
+    bool
+    check(
+      call_params_type_t<Sig> const&)
+    const = 0;
+
+    virtual
+    char const*
+    name()
+    const
+    noexcept
+    {
+      return id;
+    }
+  private:
+    char const *id;
+  };
+
+  template <typename Sig>
+  using condition_list = list<condition_base<Sig>, delete_disposer>;
+
+  template <typename Sig, typename Cond>
+  struct condition : public condition_base<Sig>
+  {
+    condition(
+      char const *str_,
+      Cond c_)
+      : condition_base<Sig>(str_)
+      , c(c_) {}
+
+    bool
+    check(
+      call_params_type_t<Sig> const & t)
+    const
+    override
+    {
+      return c(t);
+    }
+
+  private:
+    Cond c;
+  };
+
+  template <typename Sig>
+  struct side_effect_base : public list_elem<side_effect_base<Sig>>
+  {
+    ~side_effect_base() override = default;
+
+    virtual
+    void
+    action(
+      call_params_type_t<Sig> &)
+    const = 0;
+  };
+
+  template <typename Sig>
+  using side_effect_list = list<side_effect_base<Sig>, delete_disposer>;
+
+  template <typename Sig, typename Action>
+  struct side_effect : public side_effect_base<Sig>
+  {
+    template <typename A>
+    explicit
+    side_effect(
+      A&& a_)
+    : a(std::forward<A>(a_))
+    {}
+
+    void
+    action(
+      call_params_type_t<Sig> &t)
+    const
+    override
+    {
+      a(t);
+    }
+  private:
+    Action a;
+  };
+  template <size_t L, size_t H = L>
+  struct multiplicity { };
+
+  template <typename R, typename Parent>
+  struct co_return_injector : Parent
+  {
+    using co_return_type = R;
+  };
+
+  template <typename R, typename Parent>
+  struct return_injector : Parent
+  {
+    using return_type = R;
+  };
+
+  template <typename Parent>
+  struct throw_injector : Parent
+  {
+    static bool const throws = true;
+  };
+
+  template <typename Parent>
+  struct sideeffect_injector : Parent
+  {
+    static bool const side_effects = true;
+  };
+
+  template <typename Parent, size_t H>
+  struct call_limit_injector : Parent
+  {
+    static bool   const call_limit_set = true;
+    static size_t const upper_call_limit = H;
+  };
+
+  template <typename Parent>
+  struct call_limit_injector<Parent, 0> : Parent
+  {
+    static bool   const call_limit_set = true;
+    static size_t const upper_call_limit = 0;
+  };
+
+  template <typename Parent>
+  struct sequence_injector : Parent
+  {
+    static bool const sequence_set = true;
+  };
+
+  template <typename Matcher, typename modifier_tag, typename Parent>
+  struct call_modifier : public Parent
+  {
+    using typename Parent::signature;
+    using typename Parent::co_return_type;
+    using typename Parent::return_type;
+    using Parent::call_limit_set;
+    using Parent::upper_call_limit;
+    using Parent::sequence_set;
+    using Parent::throws;
+    using Parent::side_effects;
+
+    call_modifier(
+       Matcher* m)
+    noexcept
+      : matcher{m}
+    {}
+
+    template <typename D>
+    call_modifier&&
+    with(
+      char const* str,
+      D&& d)
+    &&
+    {
+      matcher->add_condition(str, std::forward<D>(d));
+      return std::move(*this);
+    }
+
+    template <typename A>
+    call_modifier<Matcher, modifier_tag, sideeffect_injector<Parent>>
+    sideeffect(
+      A&& a)
+    {
+      constexpr bool forbidden = upper_call_limit == 0U;
+      static_assert(!forbidden,
+                    "SIDE_EFFECT for forbidden call does not make sense");
+      matcher->add_side_effect(std::forward<A>(a));
+      return {std::move(matcher)};
+    }
+    template <typename...> struct S;
+#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
+    template <typename E>
+    call_modifier<Matcher, modifier_tag, Parent>
+    handle_co_yield(
+      E&& e)
+    {
+      using params_type = call_params_type_t<signature>&;
+      using sigret = return_of_t<signature>;
+      using ret = std::invoke_result_t<E, params_type>;
+
+      constexpr bool is_void = std::is_same_v<ret, void>;
+      constexpr bool is_coroutine = trompeloeil::is_coroutine<sigret>::value;
+      constexpr bool is_matching_type = std::invoke([]{
+        if constexpr (is_coroutine && !is_void) {
+          using promise = typename std::coroutine_traits<sigret>::promise_type;
+          return requires(promise p, ret r){ p.yield_value(r); };
+        } else {
+          return false;
+        }
+      });
+      static_assert(is_coroutine,
+                    "CO_YIELD when return type is not a coroutine");
+      static_assert(!is_coroutine || !is_void,
+                    "You cannot CO_YIELD void");
+      static_assert(!is_coroutine || is_void || is_matching_type,
+                    "CO_YIELD is incompatible with the promise type");
+      constexpr auto valid = is_coroutine && !is_void && is_matching_type;
+      if constexpr (valid)
+      {
+        matcher->add_yield_expr(std::forward<E>(e));
+      }
+      return {matcher};
+    }
+    template <typename H>
+    call_modifier<Matcher, modifier_tag, co_return_injector<return_of_t<signature>, Parent >>
+    handle_co_return(
+      H&& h)
+    {
+      using params_type = call_params_type_t<signature>&;
+      using sigret = return_of_t<signature>;
+      using ret = std::invoke_result_t<H, params_type>;
+
+      constexpr bool has_return = !std::is_same_v<return_type, void>;
+      constexpr bool has_co_return = !std::is_same_v<co_return_type, void>;
+      constexpr bool is_coroutine = trompeloeil::is_coroutine<sigret>::value;
+      constexpr bool is_matching_type = std::invoke([]{if constexpr (is_coroutine) {
+        using promise = typename std::coroutine_traits<sigret>::promise_type;
+        if constexpr (std::is_same_v<void, ret>) {
+          return requires (promise p){p.return_void();};
+        } else {
+          return requires(promise p) { p.return_value(std::declval<ret>()); };
+        }}
+        return true;});
+
+      static_assert(!has_return,
+                    "CO_RETURN and RETURN cannot be combined");
+      static_assert(has_return || !has_co_return,
+                    "Multiple CO_RETURN does not make sense");
+      static_assert(has_return || is_coroutine, "CO_RETURN when return type is not a coroutine");
+      static_assert(has_return || has_co_return || !is_coroutine || is_matching_type,
+                    "Expression type does not match the coroutine promise type");
+      static_assert(!throws || upper_call_limit == 0,
+                    "CO_THROW and CO_RETURN does not make sense");
+      static_assert(upper_call_limit > 0,
+                    "CO_RETURN for forbidden call does not make sense");
+
+      constexpr bool valid = !has_return && !has_co_return && is_coroutine && is_matching_type && !throws && upper_call_limit > 0;
+      if constexpr (valid)
+      {
+        matcher->set_co_return(std::forward<H>(h));
+      }
+      return {matcher};
+    }
+#endif
+    template <typename H>
+    call_modifier<Matcher, modifier_tag, return_injector<return_of_t<signature>, Parent >>
+    handle_return(
+      H&& h)
+    {
+      using params_type = call_params_type_t<signature>&;
+      using sigret = return_of_t<signature>;
+      using ret = decltype(std::declval<H>()(std::declval<params_type>()));
+      // don't know why MS VS 2015 RC doesn't like std::result_of
+
+#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
+      constexpr bool is_coroutine      = trompeloeil::is_coroutine<sigret>::value;
+#else
+      constexpr bool is_coroutine      = false;
+#endif
+      constexpr bool is_illegal_type   = std::is_same<detail::decay_t<ret>, illegal_argument>::value;
+      constexpr bool has_co_return     = !std::is_same<co_return_type, void>::value;
+      constexpr bool is_first_return   = std::is_same<return_type, void>::value;
+      constexpr bool void_signature    = std::is_same<sigret, void>::value;
+      constexpr bool is_pointer_sigret = std::is_pointer<sigret>::value;
+      constexpr bool is_pointer_ret    = std::is_pointer<detail::decay_t<ret>>::value;
+      constexpr bool ptr_const_mismatch =
+        is_pointer_ret &&
+        is_pointer_sigret &&
+        !std::is_const<detail::remove_pointer_t<sigret>>{} &&
+        std::is_const<detail::remove_pointer_t<detail::decay_t<ret>>>{};
+      constexpr bool is_ref_sigret     = std::is_reference<sigret>::value;
+      constexpr bool is_ref_ret        = std::is_reference<ret>::value;
+      constexpr bool ref_const_mismatch=
+        is_ref_ret &&
+        is_ref_sigret &&
+        !std::is_const<detail::remove_reference_t<sigret>>::value &&
+        std::is_const<detail::remove_reference_t<ret>>::value;
+      constexpr bool matching_ret_type = std::is_constructible<sigret, ret>::value;
+      constexpr bool ref_value_mismatch = !is_ref_ret && is_ref_sigret;
+
+      static_assert(!has_co_return,
+                    "RETURN and CO_RETURN cannot be combined");
+      static_assert(!is_coroutine,
+                    "Do not use RETURN from a coroutine, use CO_RETURN");
+      static_assert(is_coroutine || matching_ret_type || !void_signature,
+                    "RETURN does not make sense for void-function");
+      static_assert(is_coroutine || !is_illegal_type,
+                    "RETURN illegal argument");
+      static_assert(is_coroutine || !ptr_const_mismatch,
+                    "RETURN const* from function returning pointer to non-const");
+      static_assert(is_coroutine || !ref_value_mismatch || matching_ret_type,
+                    "RETURN non-reference from function returning reference");
+      static_assert(is_coroutine || ref_value_mismatch || !ref_const_mismatch,
+                    "RETURN const& from function returning non-const reference");
+
+      static_assert(is_coroutine || ptr_const_mismatch || ref_const_mismatch || is_illegal_type || matching_ret_type || void_signature,
+                    "RETURN value is not convertible to the return type of the function");
+      static_assert(is_coroutine || is_first_return,
+                    "Multiple RETURN does not make sense");
+      static_assert(is_coroutine || !throws || upper_call_limit == 0,
+                    "THROW and RETURN does not make sense");
+      static_assert(is_coroutine || upper_call_limit > 0,
+                    "RETURN for forbidden call does not make sense");
+
+      constexpr bool valid = !is_coroutine && !is_illegal_type && matching_ret_type && is_first_return && !throws && upper_call_limit > 0;
+      using tag = std::integral_constant<bool, valid>;
+      matcher->set_return(tag{}, std::forward<H>(h));
+      return {matcher};
+    }
+
+    call_modifier&&
+    null_modifier()
+    {
+      return std::move(*this);
+    }
+
+#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
+
+    template <typename H>
+    struct co_throw_handler_t
+    {
+      using R = decltype(default_return<return_of_t<signature>>());
+      using promise_value_type = trompeloeil::coro_value_type_t<R>;
+      explicit
+      co_throw_handler_t(H&& h_)
+        : h(std::move(h_))
+      {}
+
+      template <typename T>
+      promise_value_type operator()(T& p)
+      {
+        return ((void)h(p), trompeloeil::default_return<promise_value_type>());
+      }
+
+    private:
+      H h;
+    };
+
+    template <typename H>
+    call_modifier<Matcher, modifier_tag, throw_injector<Parent>>
+    handle_co_throw(
+      H&& h)
+    {
+      using sigret = return_of_t<signature>;
+      constexpr bool is_coroutine      = trompeloeil::is_coroutine<sigret>::value;
+      static_assert(is_coroutine,
+                    "Do not use CO_THROW from a normal function, use THROW");
+      static_assert(!is_coroutine || !throws,
+                    "Multiple CO_THROW does not make sense");
+      constexpr bool has_return = !std::is_same<co_return_type, void>::value;
+      static_assert(!is_coroutine || !has_return,
+                    "CO_THROW and CO_RETURN does not make sense");
+
+      constexpr bool forbidden = upper_call_limit == 0U;
+
+      static_assert(!is_coroutine || !forbidden,
+                    "CO_THROW for forbidden call does not make sense");
+
+      constexpr bool valid = is_coroutine && !throws && !has_return;
+      if constexpr (valid) {
+        auto handler = co_throw_handler_t<H>(std::forward<H>(h));
+        matcher->set_co_return(std::move(handler));
+      }
+      return {matcher};
+    }
+#endif
+    template <typename H>
+    struct throw_handler_t
+    {
+      using R = decltype(default_return<return_of_t<signature>>());
+
+      explicit
+      throw_handler_t(H&& h_)
+        : h(std::move(h_))
+      {}
+
+      template <typename T>
+      R operator()(T& p)
+      {
+        /* Work around VS 2017 15.7.x C4702 warning by
+         * enclosing the operation in an otherwise
+         * unnecessary try/catch block.
+         */
+        try
+        {
+          h(p);
+          abort();
+        }
+        catch (...)
+        {
+          throw;
+        }
+        return default_return<R>(); // unreachable code
+      }
+
+    private:
+      H h;
+    };
+
+    template <typename H>
+    call_modifier<Matcher, modifier_tag, throw_injector<Parent>>
+    handle_throw(
+      H&& h)
+    {
+#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
+      using sigret = return_of_t<signature>;
+      constexpr bool is_coroutine      = trompeloeil::is_coroutine<sigret>::value;
+#else
+      constexpr bool is_coroutine      = false;
+#endif
+      static_assert(!is_coroutine,
+                    "Do not use THROW from a coroutine, use CO_THROW");
+      static_assert(is_coroutine || !throws,
+                    "Multiple THROW does not make sense");
+      constexpr bool has_return = !std::is_same<return_type, void>::value;
+      static_assert(!has_return,
+                    "THROW and RETURN does not make sense");
+
+      constexpr bool forbidden = upper_call_limit == 0U;
+
+      static_assert(is_coroutine || !forbidden,
+                    "THROW for forbidden call does not make sense");
+
+      constexpr bool valid = !is_coroutine && !throws && !has_return;
+      using tag = std::integral_constant<bool, valid>;
+      auto handler = throw_handler_t<H>(std::forward<H>(h));
+      matcher->set_return(tag{}, std::move(handler));
+      return {matcher};
+    }
+
+    template <size_t L,
+              size_t H,
+              bool               times_set = call_limit_set>
+    call_modifier<Matcher, modifier_tag, call_limit_injector<Parent, H>>
+    times(
+      multiplicity<L, H>)
+    {
+      static_assert(!times_set,
+                    "Only one TIMES call limit is allowed, but it can express an interval");
+
+      static_assert(H >= L,
+                    "In TIMES the first value must not exceed the second");
+
+      static_assert(H > 0 || !throws,
+                    "THROW and TIMES(0) does not make sense");
+
+      static_assert(H > 0 || std::is_same<return_type, void>::value,
+                    "RETURN and TIMES(0) does not make sense");
+
+      static_assert(H > 0 || !side_effects,
+                    "SIDE_EFFECT and TIMES(0) does not make sense");
+
+      static_assert(H > 0 || !sequence_set,
+                    "IN_SEQUENCE and TIMES(0) does not make sense");
+
+      matcher->sequences->set_limits(L, H);
+      return {matcher};
+    }
+
+    template <typename ... T,
+              bool b = sequence_set>
+    call_modifier<Matcher, modifier_tag, sequence_injector<Parent>>
+    in_sequence(
+      T&& ... t)
+    {
+      static_assert(!b,
+                    "Multiple IN_SEQUENCE does not make sense."
+                    " You can list several sequence objects at once");
+
+      static_assert(upper_call_limit > 0,
+                    "IN_SEQUENCE for forbidden call does not make sense");
+
+      matcher->set_sequence(std::forward<T>(t)...);
+      return {matcher};
+    }
+    Matcher* matcher;
+  };
+
+  inline
+  void
+  report_unfulfilled(
+    const char* reason,
+    char const        *name,
+    std::string const &values,
+    size_t min_calls,
+    size_t call_count,
+    location           loc)
+  {
+    std::ostringstream os;
+    os << reason
+       << ":\nExpected " << name << " to be called ";
+    if (min_calls == 1)
+      os << "once";
+    else
+      os << min_calls << " times";
+    os << ", actually ";
+    switch (call_count)
+    {
+    case 0:
+      os << "never called\n"; break;
+    case 1:
+      os << "called once\n"; break;
+    default:
+      os << "called " << call_count << " times\n";
+    }
+    os << values;
+    send_report<specialized>(severity::nonfatal, loc, os.str());
+  }
+
+  inline
+  void
+  report_forbidden_call(
+    char const *name,
+    location loc,
+    std::string const& values)
+  {
+    std::ostringstream os;
+    os << "Match of forbidden call of " << name
+       << " at " << loc << '\n' << values;
+    send_report<specialized>(severity::fatal, loc, os.str());
+  }
+
+  template <typename Sig>
+  struct matcher_info
+  {
+    using signature = Sig;
+    using co_return_type = void;
+    using return_type = void;
+    static size_t const upper_call_limit = 1;
+    static bool const throws = false;
+    static bool const call_limit_set = false;
+    static bool const sequence_set = false;
+    static bool const side_effects = false;
+  };
+
+
+  template <typename Sig, typename Value>
+  struct call_matcher : public call_matcher_base<Sig>, expectation
+  {
+    using call_matcher_base<Sig>::name;
+    using call_matcher_base<Sig>::loc;
+
+#if TROMPELOEIL_GCC && TROMPELOEIL_GCC_VERSION >= 70000 && TROMPELOEIL_GCC_VERSION < 80000
+#pragma GCC diagnostic ignored "-Wconversion"
+#pragma GCC diagnostic push
+#endif
+    template <typename ... U>
+    call_matcher(
+      char const *file,
+      unsigned long line,
+      char const *call_string,
+      U &&... u)
+    : call_matcher_base<Sig>(location{file, line}, call_string)
+    , val(std::forward<U>(u)...)
+    {}
+#if TROMPELOEIL_GCC && TROMPELOEIL_GCC_VERSION >= 70000 && TROMPELOEIL_GCC_VERSION < 80000
+#pragma GCC diagnostic pop
+#endif
+
+    call_matcher(call_matcher &&r) = delete;
+
+    ~call_matcher() override
+    {
+      auto lock = get_lock();
+      if (is_unfulfilled())
+      {
+        report_missed("Unfulfilled expectation");
+      }
+      this->unlink();
+    }
+
+    bool
+    is_satisfied()
+      const
+      noexcept
+      override
+    {
+      auto lock = get_lock();
+      return sequences->is_satisfied();
+    }
+
+    bool
+    is_saturated()
+      const
+      noexcept
+      override
+    {
+      auto lock = get_lock();
+      return sequences->is_saturated();
+    }
+    bool
+    is_unfulfilled()
+    const
+    noexcept
+    {
+      return !reported && this->is_linked() && !sequences->is_satisfied();
+    }
+
+    void
+    mock_destroyed()
+    override
+    {
+      if (is_unfulfilled())
+      {
+        report_missed("Pending expectation on destroyed mock object");
+      }
+    }
+
+    call_matcher*
+    hook_last(
+      call_matcher_list<Sig> &list)
+    noexcept
+    {
+      list.push_front(this);
+      return this;
+    }
+
+    bool
+    matches(
+      call_params_type_t<Sig> const& params)
+    const
+    override
+    {
+      return match_parameters(val, params) && match_conditions(params);
+    }
+
+    bool
+    match_conditions(
+      call_params_type_t<Sig> const & params)
+    const
+    {
+      // std::all_of() is almost always preferable. The only reason
+      // for using a hand rolled loop is because it cuts compilation
+      // times quite noticeably (almost 10% with g++5.1)
+      for (auto& c : conditions)
+      {
+        if (!c.check(params)) return false;
+      }
+      return true;
+    }
+
+    unsigned
+    sequence_cost()
+      const
+      noexcept
+      override
+    {
+      return sequences->order();
+    }
+
+    return_of_t<Sig>
+    return_value(
+      trace_agent& agent,
+      call_params_type_t<Sig>& params)
+    override
+    {
+      if (!return_handler_obj) return default_return<return_of_t<Sig>>();
+      return return_handler_obj->call(agent, params);
+    }
+
+    void
+    run_actions(
+      call_params_type_t<Sig>& params,
+      call_matcher_list<Sig> &saturated_list)
+    override
+    {
+      if (sequences->is_forbidden())
+      {
+        reported = true;
+        report_forbidden_call(name, loc, params_string(params));
+      }
+      auto lock = get_lock();
+      {
+        if (!sequences->can_be_called())
+        {
+          sequences->validate(severity::fatal, name, loc);
+        }
+        sequences->increment_call();
+        if (sequences->is_satisfied())
+        {
+          sequences->retire_predecessors();
+        }
+        if (sequences->is_saturated())
+        {
+          sequences->retire();
+          this->unlink();
+          saturated_list.push_back(this);
+        }
+      }
+      for (auto& a : actions) a.action(params);
+    }
+
+    std::ostream&
+    report_signature(
+      std::ostream& os)
+    const override
+    {
+      return os << name << " at " << loc;
+    }
+
+    std::ostream&
+    report_mismatch(
+      std::ostream& os,
+      call_params_type_t<Sig> const & params)
+    override
+    {
+      reported = true;
+      report_signature(os);
+      if (match_parameters(val, params))
+      {
+        for (auto& cond : conditions)
+        {
+          if (!cond.check(params))
+          {
+            os << "\n  Failed WITH(" << cond.name() << ')';
+          }
+        }
+      }
+      else
+      {
+        os << '\n';
+        ::trompeloeil::print_mismatch(os, val, params);
+      }
+      return os;
+    }
+
+    void
+    report_missed(
+      char const *reason)
+    noexcept
+    {
+      reported = true;
+      report_unfulfilled(
+        reason,
+        name,
+        params_string(val),
+        sequences->get_min_calls(),
+        sequences->get_calls(),
+        loc);
+    }
+
+    template <typename C>
+    void
+    add_condition(
+      char const *str,
+      C&& c)
+    {
+      auto cond = new condition<Sig, C>(str, std::forward<C>(c));
+      conditions.push_back(cond);
+    }
+
+    template <typename S>
+    void
+    add_side_effect(
+      S&& s)
+    {
+      auto effect = new side_effect<Sig, S>(std::forward<S>(s));
+      actions.push_back(effect);
+    }
+
+    template <typename ... T>
+    void
+    set_sequence(
+      T&& ... t)
+    {
+      using handler = sequence_handler<sizeof...(T)>;
+      auto seq = detail::make_unique<handler>(*sequences,
+                                              name,
+                                              loc,
+                                              std::forward<T>(t)...);
+      sequences = std::move(seq);
+    }
+#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
+    template <typename E>
+    void
+    add_yield_expr(
+      E&& e)
+    {
+      auto expr = new yield_expr<Sig, E>(std::forward<E>(e));
+      yield_expressions->push_back(expr);
+    }
+#endif
+    template <typename T>
+    inline
+    void
+    set_return(
+      std::true_type,
+      T&& h)
+    {
+      using basic_t = typename std::remove_reference<T>::type;
+      using handler = return_handler_t<Sig, basic_t>;
+      return_handler_obj.reset(new handler(std::forward<T>(h)));
+    }
+
+    template <typename T>            // Never called. Used to limit errmsg
+    static                           // with RETURN of wrong type and after:
+    void                             //   FORBIDDEN_CALL
+    set_return(std::false_type, T&&t)//   RETURN
+      noexcept;                      //   THROW
+
+#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
+    template <typename T>
+    inline
+    void
+    set_co_return(
+      T&& h)
+    {
+      using basic_t = typename std::remove_reference<T>::type;
+      using handler = co_return_handler_t<Sig, basic_t>;
+      return_handler_obj.reset(new handler(std::forward<T>(h), yield_expressions));
+    }
+#endif
+
+    condition_list<Sig>                    conditions;
+    side_effect_list<Sig>                  actions;
+#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
+    std::shared_ptr<yield_expr_list<Sig>>  yield_expressions = std::make_shared<yield_expr_list<Sig>>();
+#endif
+
+    std::unique_ptr<return_handler<Sig>>   return_handler_obj;
+    std::unique_ptr<sequence_handler_base> sequences = detail::make_unique<sequence_handler<0>>();
+    Value                                  val;
+    bool                                   reported = false;
+  };
+
+  /* Clang (all versions) does not like computing the return type R
+   * before determining if the function overload is the best match.
+   */
+  template <
+    int N,
+    typename T,
+    typename = detail::enable_if_t<N <= std::tuple_size<T>::value>,
+    typename R = decltype(std::get<N-1>(std::declval<T>()))
+  >
+  constexpr
+  TROMPELOEIL_DECLTYPE_AUTO
+  arg(
+    T* t,
+    std::true_type)
+  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+  {
+    return std::get<N-1>(*t);
+  }
+
+  template <int>
+  constexpr
+  illegal_argument
+  arg(
+    void const*,
+    std::false_type)
+  noexcept
+  {
+    return {};
+  }
+
+  template <
+    int N,
+    typename T,
+    typename R = decltype(arg<N>(std::declval<T*>(),
+                                 std::integral_constant<bool, (N <= std::tuple_size<T>::value)>{}))
+  >
+  TROMPELOEIL_DECLTYPE_AUTO
+  mkarg(
+    T& t)
+  noexcept
+  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+  {
+    return arg<N>(&t, std::integral_constant<bool, (N <= std::tuple_size<T>::value)>{});
+  }
+
+  template <typename Mock>
+  struct call_validator_t
+  {
+    template <typename M, typename Tag, typename Info>
+    auto
+    make_expectation(
+      std::true_type,
+      call_modifier<M, Tag, Info> const& m)
+    const
+    noexcept
+    TROMPELOEIL_TRAILING_RETURN_TYPE(std::unique_ptr<expectation>)
+    {
+      auto lock = get_lock();
+      m.matcher->hook_last(obj.trompeloeil_matcher_list(static_cast<Tag*>(nullptr)));
+
+      return std::unique_ptr<expectation>(m.matcher);
+    }
+
+    template <typename T>
+    static                                           // Never called. Used to
+    std::unique_ptr<expectation>                     // limit errmsg when RETURN
+    make_expectation(std::false_type, T&&) noexcept; // is missing in non-void
+                                                     // function
+
+    template <typename M, typename Tag, typename Info>
+    inline
+    auto
+    operator+(
+      call_modifier<M, Tag, Info>&& t)
+    const
+    TROMPELOEIL_TRAILING_RETURN_TYPE(std::unique_ptr<expectation>)
+    {
+      using call = call_modifier<M, Tag, Info>;
+      using sigret = return_of_t<typename call::signature>;
+      using ret = typename call::return_type;
+      using coret = typename call::co_return_type;
+#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
+      constexpr bool is_coroutine = trompeloeil::is_coroutine<sigret>::value;
+#else
+      constexpr bool is_coroutine = false;
+#endif
+      constexpr bool retmatch = std::is_same<ret, sigret>::value;
+      constexpr bool coretmatch = std::is_same<coret, sigret>::value;
+      constexpr bool forbidden = call::upper_call_limit == 0;
+      constexpr bool valid_return_type = retmatch || coretmatch || forbidden;
+      constexpr bool handles_return = is_coroutine || valid_return_type || call::throws;
+      constexpr bool handles_co_return = !is_coroutine || valid_return_type || call::throws;
+      static_assert(handles_return, "RETURN missing for non-void function");
+      static_assert(handles_co_return, "CO_RETURN missing for coroutine");
+      auto tag = std::integral_constant<bool, handles_return || handles_co_return>{};
+      return make_expectation(tag, std::move(t));
+    }
+    Mock& obj;
+  };
+
+  template <typename T,
+            typename = detail::enable_if_t<std::is_lvalue_reference<T&&>::value>>
+  inline
+  T&&
+  decay_return_type(
+    T&& t)
+  {
+    return std::forward<T>(t);
+  }
+
+  template <typename T,
+            typename = detail::enable_if_t<std::is_rvalue_reference<T&&>::value>>
+  inline
+  T
+  decay_return_type(
+    T&& t)
+  {
+    return std::forward<T>(t);
+  }
+
+  template <typename T, size_t N>
+  inline
+  T*
+  decay_return_type(
+    T (&t)[N])
+  {
+    return t;
+  }
+
+  inline
+  void
+  decay_return_type()
+  {
+  }
+
+  template <bool sequence_set>
+  struct lifetime_monitor_modifier : std::unique_ptr<lifetime_monitor>
+  {
+    explicit
+    lifetime_monitor_modifier(
+      std::unique_ptr<lifetime_monitor>&& p)
+    noexcept
+    : unique_ptr(std::move(p))
+    {}
+
+    template <typename ... T, bool b = sequence_set>
+    auto
+    in_sequence(T&& ... t)
+    -> lifetime_monitor_modifier<true>
+    {
+      static_assert(!b,
+                    "Multiple IN_SEQUENCE does not make sense."
+                      " You can list several sequence objects at once");
+      std::unique_ptr<lifetime_monitor>& m = *this;
+      m->set_sequence(std::forward<T>(t)...);
+      return lifetime_monitor_modifier<true>{std::move(m)};
+    }
+  };
+
+  struct lifetime_monitor_releaser
+  {
+    template <bool b>
+    std::unique_ptr<trompeloeil::lifetime_monitor>
+    operator+(
+      lifetime_monitor_modifier<b>&& m)
+    const
+    {
+      return std::move(m);
+    }
+  };
+
+  template <bool movable, typename Sig>
+  struct expectations
+  {
+    expectations() = default;
+    expectations(expectations&&) noexcept = default;
+    ~expectations() {
+      active.decommission();
+      saturated.decommission();
+    }
+    call_matcher_list<Sig> active{};
+    call_matcher_list<Sig> saturated{};
+  };
+
+  template <typename Sig>
+  struct expectations<false, Sig>
+  {
+    expectations() = default;
+    expectations(expectations&&)
+    noexcept
+    {
+      static_assert(std::is_same<Sig,void>::value,
+        "By default, mock objects are not movable. "
+        "To make a mock object movable, see: "
+        "https://github.com/rollbear/trompeloeil/blob/master/docs/reference.md#movable_mock");
+    }
+    ~expectations() {
+      active.decommission();
+      saturated.decommission();
+    }
+    call_matcher_list<Sig> active{};
+    call_matcher_list<Sig> saturated{};
+  };
+
+  template <typename Sig, typename ... P>
+  return_of_t<Sig> mock_func(std::false_type, P&& ...);
+
+
+  template <bool movable, typename Sig, typename ... P>
+  return_of_t<Sig>
+  mock_func(std::true_type,
+            expectations<movable, Sig>& e,
+            char const *func_name,
+            char const *sig_name,
+            P&& ... p)
+  {
+    auto lock = get_lock();
+
+    call_params_type_t<void(P...)> param_value(std::forward<P>(p)...);
+
+    auto i = find(e.active, param_value);
+    if (!i)
+    {
+      report_mismatch(e.active,
+                      e.saturated,
+                      func_name + std::string(" with signature ") + sig_name,
+                      param_value);
+    }
+    else{
+        report_match(e.active);
+    }
+    trace_agent ta{i->loc, i->name, tracer_obj()};
+    try
+    {
+      ta.trace_params(param_value);
+      i->run_actions(param_value, e.saturated);
+      return i->return_value(ta, param_value);
+    }
+    catch (...)
+    {
+      ta.trace_exception();
+      throw;
+    }
+  }
+
+  template <typename ... U>
+  struct param_helper {
+    using type = decltype(detail::make_tuple(std::declval<U>()...));
+  };
+
+  template <typename ... U>
+  using param_t = typename param_helper<U...>::type;
+
+  template <typename sig, typename tag, typename... U>
+  using modifier_t = call_modifier<call_matcher<sig, param_t<U...>>,
+                                   tag,
+                                   matcher_info<sig>>;
+
+  template <typename M,
+            typename = detail::enable_if_t<::trompeloeil::is_matcher<M>::value>>
+  inline
+  ::trompeloeil::ptr_deref<detail::decay_t<M>>
+  operator*(
+    M&& m)
+  {
+    return ::trompeloeil::ptr_deref<detail::decay_t<M>>{std::forward<M>(m)};
+  }
+
+  template <typename M,
+            typename = detail::enable_if_t<::trompeloeil::is_matcher<M>::value>>
+  inline
+  ::trompeloeil::neg_matcher<detail::decay_t<M>>
+  operator!(
+    M&& m)
+  {
+    return ::trompeloeil::neg_matcher<detail::decay_t<M>>{std::forward<M>(m)};
+  }
+
+  /*
+   * Convert the signature S of a mock function to the signature of
+   * a member function of class T that takes the same parameters P
+   * but returns R.
+   *
+   * The member function has the same constness as the mock function.
+   */
+  template <typename T, typename R, typename S>
+  struct signature_to_member_function;
+
+  template <typename T, typename R, typename R_of_S, typename... P>
+  struct signature_to_member_function<T, R, R_of_S(P...)>
+  {
+    using type = detail::conditional_t<
+      std::is_const<T>::value,
+      R (T::*)(P...) const,
+      R (T::*)(P...)>;
+  };
+
+  template <typename T>
+  struct mock_interface : public T
+  {
+    using trompeloeil_interface_name = T;
+    using T::T;
+ };
+
+#if defined(TROMPELOEIL_USER_DEFINED_COMPILE_TIME_REPORTER)
+ extern template struct reporter<specialized>;
+#endif // TROMPELOEIL_USER_DEFINED_COMPILE_TIME_REPORTER
+}
+
+#define TROMPELOEIL_LINE_ID(name)                                        \
+  TROMPELOEIL_CONCAT(trompeloeil_l_ ## name ## _, __LINE__)
+
+#define TROMPELOEIL_COUNT_ID(name)                                       \
+  TROMPELOEIL_CONCAT(trompeloeil_c_ ## name ## _, __COUNTER__)
+
+#if TROMPELOEIL_MSVC
+#define TROMPELOEIL_MAKE_MOCK0(name, sig, ...)                           \
+  TROMPELOEIL_MAKE_MOCK_(name,,0, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK1(name, sig, ...)                           \
+  TROMPELOEIL_MAKE_MOCK_(name,,1, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK2(name, sig, ...)                           \
+  TROMPELOEIL_MAKE_MOCK_(name,,2, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK3(name, sig, ...)                           \
+  TROMPELOEIL_MAKE_MOCK_(name,,3, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK4(name, sig, ...)                           \
+  TROMPELOEIL_MAKE_MOCK_(name,,4, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK5(name, sig, ...)                           \
+  TROMPELOEIL_MAKE_MOCK_(name,,5, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK6(name, sig, ...)                           \
+  TROMPELOEIL_MAKE_MOCK_(name,,6, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK7(name, sig, ...)                           \
+  TROMPELOEIL_MAKE_MOCK_(name,,7, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK8(name, sig, ...)                           \
+  TROMPELOEIL_MAKE_MOCK_(name,,8, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK9(name, sig, ...)                           \
+  TROMPELOEIL_MAKE_MOCK_(name,,9, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK10(name, sig, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,,10, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK11(name, sig, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,,11, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK12(name, sig, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,,12, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK13(name, sig, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,,13, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK14(name, sig, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,,14, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK15(name, sig, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,,15, sig, __VA_ARGS__,,)
+
+#define TROMPELOEIL_MAKE_CONST_MOCK0(name, sig, ...)                     \
+  TROMPELOEIL_MAKE_MOCK_(name,const,0, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK1(name, sig, ...)                     \
+  TROMPELOEIL_MAKE_MOCK_(name,const,1, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK2(name, sig, ...)                     \
+  TROMPELOEIL_MAKE_MOCK_(name,const,2, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK3(name, sig, ...)                     \
+  TROMPELOEIL_MAKE_MOCK_(name,const,3, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK4(name, sig, ...)                     \
+  TROMPELOEIL_MAKE_MOCK_(name,const,4, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK5(name, sig, ...)                     \
+  TROMPELOEIL_MAKE_MOCK_(name,const,5, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK6(name, sig, ...)                     \
+  TROMPELOEIL_MAKE_MOCK_(name,const,6, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK7(name, sig, ...)                     \
+  TROMPELOEIL_MAKE_MOCK_(name,const,7, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK8(name, sig, ...)                     \
+  TROMPELOEIL_MAKE_MOCK_(name,const,8, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK9(name, sig, ...)                     \
+  TROMPELOEIL_MAKE_MOCK_(name,const,9, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK10(name, sig, ...)                    \
+  TROMPELOEIL_MAKE_MOCK_(name,const,10, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK11(name, sig, ...)                    \
+  TROMPELOEIL_MAKE_MOCK_(name,const,11, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK12(name, sig, ...)                    \
+  TROMPELOEIL_MAKE_MOCK_(name,const,12, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK13(name, sig, ...)                    \
+  TROMPELOEIL_MAKE_MOCK_(name,const,13, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK14(name, sig, ...)                    \
+  TROMPELOEIL_MAKE_MOCK_(name,const,14, sig, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK15(name, sig, ...)                    \
+  TROMPELOEIL_MAKE_MOCK_(name,const,15, sig, __VA_ARGS__,,)
+
+
+#else
+// sane standards compliant preprocessor
+
+#define TROMPELOEIL_MAKE_MOCK0(name, ...)                                \
+  TROMPELOEIL_MAKE_MOCK_(name,,0, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK1(name, ...)                                \
+  TROMPELOEIL_MAKE_MOCK_(name,,1, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK2(name, ...)                                \
+  TROMPELOEIL_MAKE_MOCK_(name,,2, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK3(name, ...)                                \
+  TROMPELOEIL_MAKE_MOCK_(name,,3, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK4(name, ...)                                \
+  TROMPELOEIL_MAKE_MOCK_(name,,4, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK5(name, ...)                                \
+  TROMPELOEIL_MAKE_MOCK_(name,,5, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK6(name, ...)                                \
+  TROMPELOEIL_MAKE_MOCK_(name,,6, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK7(name, ...)                                \
+  TROMPELOEIL_MAKE_MOCK_(name,,7, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK8(name, ...)                                \
+  TROMPELOEIL_MAKE_MOCK_(name,,8, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK9(name, ...)                                \
+  TROMPELOEIL_MAKE_MOCK_(name,,9, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK10(name, ...)                               \
+  TROMPELOEIL_MAKE_MOCK_(name,,10, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK11(name, ...)                               \
+  TROMPELOEIL_MAKE_MOCK_(name,,11, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK12(name, ...)                               \
+  TROMPELOEIL_MAKE_MOCK_(name,,12, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK13(name, ...)                               \
+  TROMPELOEIL_MAKE_MOCK_(name,,13, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK14(name, ...)                               \
+  TROMPELOEIL_MAKE_MOCK_(name,,14,__VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_MOCK15(name, ...)                               \
+  TROMPELOEIL_MAKE_MOCK_(name,,15, __VA_ARGS__,,)
+
+#define TROMPELOEIL_MAKE_CONST_MOCK0(name, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,const,0, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK1(name, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,const,1, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK2(name, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,const,2, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK3(name, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,const,3, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK4(name, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,const,4, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK5(name, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,const,5, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK6(name, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,const,6, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK7(name, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,const,7, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK8(name, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,const,8, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK9(name, ...)                          \
+  TROMPELOEIL_MAKE_MOCK_(name,const,9, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK10(name, ...)                         \
+  TROMPELOEIL_MAKE_MOCK_(name,const,10, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK11(name, ...)                         \
+  TROMPELOEIL_MAKE_MOCK_(name,const,11, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK12(name, ...)                         \
+  TROMPELOEIL_MAKE_MOCK_(name,const,12, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK13(name, ...)                         \
+  TROMPELOEIL_MAKE_MOCK_(name,const,13, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK14(name, ...)                         \
+  TROMPELOEIL_MAKE_MOCK_(name,const,14, __VA_ARGS__,,)
+#define TROMPELOEIL_MAKE_CONST_MOCK15(name, ...)                         \
+  TROMPELOEIL_MAKE_MOCK_(name,const,15, __VA_ARGS__,,)
+
+#endif
+
+#define TROMPELOEIL_IMPLEMENT_MOCK0(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(0, __VA_ARGS__,override))
+#define TROMPELOEIL_IMPLEMENT_MOCK1(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(1, __VA_ARGS__,override))
+#define TROMPELOEIL_IMPLEMENT_MOCK2(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(2, __VA_ARGS__,override))
+#define TROMPELOEIL_IMPLEMENT_MOCK3(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(3, __VA_ARGS__,override))
+#define TROMPELOEIL_IMPLEMENT_MOCK4(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(4, __VA_ARGS__,override))
+#define TROMPELOEIL_IMPLEMENT_MOCK5(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(5, __VA_ARGS__,override))
+#define TROMPELOEIL_IMPLEMENT_MOCK6(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(6, __VA_ARGS__,override))
+#define TROMPELOEIL_IMPLEMENT_MOCK7(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(7, __VA_ARGS__,override))
+#define TROMPELOEIL_IMPLEMENT_MOCK8(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(8, __VA_ARGS__,override))
+#define TROMPELOEIL_IMPLEMENT_MOCK9(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(9, __VA_ARGS__,override))
+#define TROMPELOEIL_IMPLEMENT_MOCK10(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(10, __VA_ARGS__,override))
+#define TROMPELOEIL_IMPLEMENT_MOCK11(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(11, __VA_ARGS__,override))
+#define TROMPELOEIL_IMPLEMENT_MOCK12(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(12, __VA_ARGS__,override))
+#define TROMPELOEIL_IMPLEMENT_MOCK13(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(13, __VA_ARGS__,override))
+#define TROMPELOEIL_IMPLEMENT_MOCK14(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(14, __VA_ARGS__,override))
+#define TROMPELOEIL_IMPLEMENT_MOCK15(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_MOCK_(15, __VA_ARGS__,override))
+
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK0(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(0, __VA_ARGS__,override))
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK1(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(1, __VA_ARGS__,override))
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK2(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(2, __VA_ARGS__,override))
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK3(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(3, __VA_ARGS__,override))
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK4(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(4, __VA_ARGS__,override))
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK5(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(5, __VA_ARGS__,override))
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK6(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(6, __VA_ARGS__,override))
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK7(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(7, __VA_ARGS__,override))
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK8(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(8, __VA_ARGS__,override))
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK9(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(9, __VA_ARGS__,override))
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK10(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(10, __VA_ARGS__,override))
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK11(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(11, __VA_ARGS__,override))
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK12(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(12, __VA_ARGS__,override))
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK13(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(13, __VA_ARGS__,override))
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK14(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(14, __VA_ARGS__,override))
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK15(...) \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_IMPLEMENT_CONST_MOCK_(15, __VA_ARGS__,override))
+
+
+#define TROMPELOEIL_IMPLEMENT_MOCK_(num, name, ...) \
+  TROMPELOEIL_MAKE_MOCK_(name,\
+                         ,\
+                         num,\
+                         decltype(::trompeloeil::nonconst_member_signature(&trompeloeil_interface_name::name))::type,\
+                         TROMPELOEIL_SEPARATE(__VA_ARGS__),)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK_(num, name, ...) \
+  TROMPELOEIL_MAKE_MOCK_(name,\
+                         const,\
+                         num,\
+                         decltype(::trompeloeil::const_member_signature(&trompeloeil_interface_name::name))::type,\
+                         TROMPELOEIL_SEPARATE(__VA_ARGS__),)
+
+#define TROMPELOEIL_MAKE_MOCK_(name, constness, num, sig, spec, ...)           \
+  private:                                                                     \
+  using TROMPELOEIL_LINE_ID(cardinality_match) =                               \
+    std::integral_constant<bool, num ==                                        \
+      ::trompeloeil::param_list<TROMPELOEIL_REMOVE_PAREN(sig)>::size>;         \
+  static_assert(TROMPELOEIL_LINE_ID(cardinality_match)::value,                 \
+                "Function signature does not have " #num " parameters");       \
+  using TROMPELOEIL_LINE_ID(matcher_list_t) =                                  \
+  ::trompeloeil::call_matcher_list<TROMPELOEIL_REMOVE_PAREN(sig)>;             \
+  using TROMPELOEIL_LINE_ID(expectation_list_t) =                              \
+    ::trompeloeil::expectations<trompeloeil_movable_mock,                      \
+                                TROMPELOEIL_REMOVE_PAREN(sig)>;                \
+                                                                               \
+  struct TROMPELOEIL_LINE_ID(tag_type_trompeloeil)                             \
+  {                                                                            \
+    const char* trompeloeil_expectation_file;                                  \
+    unsigned long trompeloeil_expectation_line;                                \
+    const char *trompeloeil_expectation_string;                                \
+                                                                               \
+    /* Work around parsing bug in VS 2015 when a "complex" */                  \
+    /* decltype() appears in a trailing return type. */                        \
+    /* Further, work around C2066 defect in VS 2017 15.7.1. */                 \
+    using trompeloeil_sig_t = typename                                         \
+    ::trompeloeil::identity_type<TROMPELOEIL_REMOVE_PAREN(sig)>::type;         \
+                                                                               \
+    using trompeloeil_call_params_type_t =                                     \
+      ::trompeloeil::call_params_type_t<TROMPELOEIL_REMOVE_PAREN(sig)>;        \
+                                                                               \
+    using trompeloeil_return_of_t =                                            \
+      ::trompeloeil::return_of_t<TROMPELOEIL_REMOVE_PAREN(sig)>;               \
+                                                                               \
+    template <typename ... trompeloeil_param_type>                             \
+    auto name(                                                                 \
+      trompeloeil_param_type&& ... trompeloeil_param)                          \
+      -> ::trompeloeil::modifier_t<trompeloeil_sig_t,                          \
+                                   TROMPELOEIL_LINE_ID(tag_type_trompeloeil),  \
+                                   trompeloeil_param_type...>                  \
+    {                                                                          \
+      using matcher = ::trompeloeil::call_matcher<                             \
+                          TROMPELOEIL_REMOVE_PAREN(sig),                       \
+                          ::trompeloeil::param_t<trompeloeil_param_type...>>;  \
+      return {                                                                 \
+          new matcher {                                                        \
+                trompeloeil_expectation_file,                                  \
+                trompeloeil_expectation_line,                                  \
+                trompeloeil_expectation_string,                                \
+                std::forward<trompeloeil_param_type>(trompeloeil_param)...     \
+              }                                                                \
+      };                                                                       \
+    }                                                                          \
+  };                                                                           \
+                                                                               \
+  public:                                                                      \
+  TROMPELOEIL_LINE_ID(matcher_list_t)&                                         \
+  trompeloeil_matcher_list(                                                    \
+    TROMPELOEIL_LINE_ID(tag_type_trompeloeil)*)                                \
+  constness                                                                    \
+  noexcept                                                                     \
+  {                                                                            \
+    return TROMPELOEIL_LINE_ID(expectations).active;                           \
+  }                                                                            \
+                                                                               \
+  ::trompeloeil::return_of_t<TROMPELOEIL_REMOVE_PAREN(sig)>                    \
+  name(TROMPELOEIL_PARAM_LIST(num, sig))                                       \
+  constness                                                                    \
+  spec                                                                         \
+  {                                                                            \
+    return ::trompeloeil::mock_func<trompeloeil_movable_mock, TROMPELOEIL_REMOVE_PAREN(sig)>( \
+                                    TROMPELOEIL_LINE_ID(cardinality_match){},  \
+                                    TROMPELOEIL_LINE_ID(expectations),         \
+#name,                                     \
+#sig                                       \
+                                    TROMPELOEIL_PARAMS(num));                  \
+  }                                                                            \
+                                                                               \
+  TROMPELOEIL_NOT_IMPLEMENTED(                                                 \
+  auto                                                                         \
+  trompeloeil_self_ ## name(TROMPELOEIL_PARAM_LIST(num, sig)) constness        \
+  -> decltype(*this));                                                         \
+                                                                               \
+  TROMPELOEIL_NOT_IMPLEMENTED(TROMPELOEIL_LINE_ID(tag_type_trompeloeil)        \
+  trompeloeil_tag_ ## name(TROMPELOEIL_PARAM_LIST(num, sig)) constness);       \
+                                                                               \
+  private:                                                                     \
+  mutable                                                                      \
+  TROMPELOEIL_LINE_ID(expectation_list_t) TROMPELOEIL_LINE_ID(expectations){}; \
+                                                                               \
+  public:                                                                      \
+  /* An unused alias declaration to make trailing semicolon acceptable. */     \
+  using TROMPELOEIL_LINE_ID(unused_alias) = void
+
+
+#define TROMPELOEIL_LPAREN (
+
+#define TROMPELOEIL_MORE_THAN_TWO_ARGS(...)                                    \
+  TROMPELOEIL_IDENTITY(                                                        \
+    TROMPELOEIL_ARG16(__VA_ARGS__,                                             \
+                      T, T, T, T, T, T, T, T, T, T, T, T, T, F, F, F))
+
+
+#define TROMPELOEIL_REQUIRE_CALL_V(...)                                        \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_REQUIRE_CALL_IMPL TROMPELOEIL_LPAREN        \
+      TROMPELOEIL_MORE_THAN_TWO_ARGS(__VA_ARGS__), __VA_ARGS__))
+
+// Dispatch to _F (0, 1, or 2 arguments) or _T (> 2 arguments) macro
+#define TROMPELOEIL_REQUIRE_CALL_IMPL(N, ...)                                  \
+    TROMPELOEIL_IDENTITY(                                                      \
+      TROMPELOEIL_REQUIRE_CALL_ ## N TROMPELOEIL_LPAREN __VA_ARGS__))
+
+// Accept only two arguments
+#define TROMPELOEIL_REQUIRE_CALL_F(obj, func)                                  \
+  auto TROMPELOEIL_COUNT_ID(call_obj) =                                        \
+    TROMPELOEIL_REQUIRE_CALL_V_LAMBDA(obj, func, #obj, #func, .null_modifier())
+
+// Accept three or more arguments.
+#define TROMPELOEIL_REQUIRE_CALL_T(obj, func, ...)                             \
+  auto TROMPELOEIL_COUNT_ID(call_obj) =                                        \
+    TROMPELOEIL_REQUIRE_CALL_V_LAMBDA(obj, func, #obj, #func, __VA_ARGS__)
+
+#if TROMPELOEIL_GCC
+// This is highly unfortunate. Conversion warnings are desired here, but there
+// are situations when the wildcard _ uses conversion when creating an
+// expectation. It would be much better if the warning could be suppressed only
+// for that type. See https://github.com/rollbear/trompeloeil/issues/293
+#pragma GCC diagnostic ignored "-Wconversion"
+#pragma GCC diagnostic push
+#endif
+#define TROMPELOEIL_REQUIRE_CALL_V_LAMBDA(obj, func, obj_s, func_s, ...)       \
+  [&]                                                                          \
+  {                                                                            \
+    using trompeloeil_s_t = decltype((obj)                                     \
+                              .TROMPELOEIL_CONCAT(trompeloeil_self_, func));   \
+    using trompeloeil_e_t = decltype((obj)                                     \
+                              .TROMPELOEIL_CONCAT(trompeloeil_tag_,func));     \
+                                                                               \
+    return TROMPELOEIL_REQUIRE_CALL_LAMBDA_OBJ(obj, func, obj_s, func_s)       \
+      __VA_ARGS__                                                              \
+      ;                                                                        \
+  }()
+#if TROMPELOEIL_GCC
+#pragma GCC diagnostic pop
+#endif
+#define TROMPELOEIL_REQUIRE_CALL_LAMBDA_OBJ(obj, func, obj_s, func_s)          \
+  ::trompeloeil::call_validator_t<trompeloeil_s_t>{(obj)} +                    \
+      ::trompeloeil::detail::conditional_t<false,                              \
+                                           decltype((obj).func),               \
+                                           trompeloeil_e_t>                    \
+    {__FILE__, static_cast<unsigned long>(__LINE__), obj_s "." func_s}.func
+
+#define TROMPELOEIL_NAMED_REQUIRE_CALL_V(...)                                  \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_NAMED_REQUIRE_CALL_IMPL TROMPELOEIL_LPAREN  \
+    TROMPELOEIL_MORE_THAN_TWO_ARGS(__VA_ARGS__), __VA_ARGS__))
+
+// Dispatch to _F (0, 1, or 2 arguments) or _T (> 2 arguments) macro
+#define TROMPELOEIL_NAMED_REQUIRE_CALL_IMPL(N, ...)                            \
+  TROMPELOEIL_IDENTITY(                                                        \
+    TROMPELOEIL_NAMED_REQUIRE_CALL_ ## N TROMPELOEIL_LPAREN __VA_ARGS__))
+
+// Accept only two arguments
+#define TROMPELOEIL_NAMED_REQUIRE_CALL_F(obj, func)                            \
+  TROMPELOEIL_REQUIRE_CALL_V_LAMBDA(obj, func, #obj, #func, .null_modifier())
+
+// Accept three or more arguments.
+#define TROMPELOEIL_NAMED_REQUIRE_CALL_T(obj, func, ...)                       \
+  TROMPELOEIL_REQUIRE_CALL_V_LAMBDA(obj, func, #obj, #func, __VA_ARGS__)
+
+
+#define TROMPELOEIL_ALLOW_CALL_V(...)                                          \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_ALLOW_CALL_IMPL TROMPELOEIL_LPAREN          \
+    TROMPELOEIL_MORE_THAN_TWO_ARGS(__VA_ARGS__), __VA_ARGS__))
+
+// Dispatch to _F (0, 1, or 2 arguments) or _T (> 2 arguments) macro
+#define TROMPELOEIL_ALLOW_CALL_IMPL(N, ...)                                    \
+  TROMPELOEIL_IDENTITY(                                                        \
+    TROMPELOEIL_ALLOW_CALL_ ## N TROMPELOEIL_LPAREN __VA_ARGS__))
+
+// Accept only two arguments
+#define TROMPELOEIL_ALLOW_CALL_F(obj, func)                                    \
+  TROMPELOEIL_REQUIRE_CALL_T(obj, func, .TROMPELOEIL_INFINITY_TIMES())
+
+// Accept three or more arguments.
+#define TROMPELOEIL_ALLOW_CALL_T(obj, func, ...)                               \
+  TROMPELOEIL_REQUIRE_CALL_T(obj,                                              \
+                             func,                                             \
+                             .TROMPELOEIL_INFINITY_TIMES() __VA_ARGS__)
+
+
+#define TROMPELOEIL_NAMED_ALLOW_CALL_V(...)                                    \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_NAMED_ALLOW_CALL_IMPL TROMPELOEIL_LPAREN    \
+    TROMPELOEIL_MORE_THAN_TWO_ARGS(__VA_ARGS__), __VA_ARGS__))
+
+// Dispatch to _F (0, 1, or 2 arguments) or _T (> 2 arguments) macro
+#define TROMPELOEIL_NAMED_ALLOW_CALL_IMPL(N, ...)                              \
+  TROMPELOEIL_IDENTITY(                                                        \
+    TROMPELOEIL_NAMED_ALLOW_CALL_ ## N TROMPELOEIL_LPAREN __VA_ARGS__))
+
+// Accept only two arguments
+#define TROMPELOEIL_NAMED_ALLOW_CALL_F(obj, func)                              \
+  TROMPELOEIL_NAMED_REQUIRE_CALL_T(obj, func, .TROMPELOEIL_INFINITY_TIMES())
+
+// Accept three or more arguments.
+#define TROMPELOEIL_NAMED_ALLOW_CALL_T(obj, func, ...)                         \
+  TROMPELOEIL_NAMED_REQUIRE_CALL_T(obj,                                        \
+                                   func,                                       \
+                                   .TROMPELOEIL_INFINITY_TIMES()               \
+                                   __VA_ARGS__)
+
+
+#define TROMPELOEIL_FORBID_CALL_V(...)                                         \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_FORBID_CALL_IMPL TROMPELOEIL_LPAREN         \
+    TROMPELOEIL_MORE_THAN_TWO_ARGS(__VA_ARGS__), __VA_ARGS__))
+
+// Dispatch to _F (0, 1, or 2 arguments) or _T (> 2 arguments) macro
+#define TROMPELOEIL_FORBID_CALL_IMPL(N, ...)                                   \
+  TROMPELOEIL_IDENTITY(                                                        \
+    TROMPELOEIL_FORBID_CALL_ ## N TROMPELOEIL_LPAREN __VA_ARGS__))
+
+// Accept only two arguments
+#define TROMPELOEIL_FORBID_CALL_F(obj, func)                                   \
+  TROMPELOEIL_REQUIRE_CALL_T(obj, func, .TROMPELOEIL_TIMES(0))
+
+// Accept three or more arguments.
+#define TROMPELOEIL_FORBID_CALL_T(obj, func, ...)                              \
+  TROMPELOEIL_REQUIRE_CALL_T(obj,                                              \
+                             func,                                             \
+                             .TROMPELOEIL_TIMES(0) __VA_ARGS__)
+
+
+#define TROMPELOEIL_NAMED_FORBID_CALL_V(...)                                   \
+  TROMPELOEIL_IDENTITY(TROMPELOEIL_NAMED_FORBID_CALL_IMPL TROMPELOEIL_LPAREN   \
+    TROMPELOEIL_MORE_THAN_TWO_ARGS(__VA_ARGS__), __VA_ARGS__))
+
+// Dispatch to _F (0, 1, or 2 arguments) or _T (> 2 arguments) macro
+#define TROMPELOEIL_NAMED_FORBID_CALL_IMPL(N, ...)                             \
+  TROMPELOEIL_IDENTITY(                                                        \
+    TROMPELOEIL_NAMED_FORBID_CALL_ ## N TROMPELOEIL_LPAREN __VA_ARGS__))
+
+// Accept only two arguments
+#define TROMPELOEIL_NAMED_FORBID_CALL_F(obj, func)                             \
+  TROMPELOEIL_NAMED_REQUIRE_CALL_T(obj, func, .TROMPELOEIL_TIMES(0))
+
+// Accept three or more arguments.
+#define TROMPELOEIL_NAMED_FORBID_CALL_T(obj, func, ...)                        \
+  TROMPELOEIL_NAMED_REQUIRE_CALL_T(obj,                                        \
+                                   func,                                       \
+                                   .TROMPELOEIL_TIMES(0) __VA_ARGS__)
+
+
+#if (TROMPELOEIL_CPLUSPLUS > 201103L)
+
+#define TROMPELOEIL_REQUIRE_CALL(obj, func)                                    \
+  TROMPELOEIL_REQUIRE_CALL_(obj, func, #obj, #func)
+
+#define TROMPELOEIL_REQUIRE_CALL_(obj, func, obj_s, func_s)                    \
+  auto TROMPELOEIL_COUNT_ID(call_obj) = TROMPELOEIL_REQUIRE_CALL_OBJ(obj, func,\
+                                                               obj_s, func_s)
+
+#define TROMPELOEIL_NAMED_REQUIRE_CALL(obj, func)                              \
+  TROMPELOEIL_NAMED_REQUIRE_CALL_(obj, func, #obj, #func)
+
+#define TROMPELOEIL_NAMED_REQUIRE_CALL_(obj, func, obj_s, func_s)              \
+  TROMPELOEIL_REQUIRE_CALL_OBJ(obj, func, obj_s, func_s)
+
+
+#define TROMPELOEIL_REQUIRE_CALL_OBJ(obj, func, obj_s, func_s)                 \
+  ::trompeloeil::call_validator_t<decltype((obj).TROMPELOEIL_CONCAT(trompeloeil_self_, func))>{(obj)} + \
+    ::trompeloeil::detail::conditional_t<false,                                \
+                       decltype((obj).func),                                   \
+                       decltype((obj).TROMPELOEIL_CONCAT(trompeloeil_tag_,func))>\
+    {__FILE__, static_cast<unsigned long>(__LINE__), obj_s "." func_s}.func
+
+
+#define TROMPELOEIL_ALLOW_CALL(obj, func)                                      \
+  TROMPELOEIL_ALLOW_CALL_(obj, func, #obj, #func)
+
+#define TROMPELOEIL_ALLOW_CALL_(obj, func, obj_s, func_s)                      \
+  TROMPELOEIL_REQUIRE_CALL_(obj, func, obj_s, func_s)                          \
+    .TROMPELOEIL_INFINITY_TIMES()
+
+
+#define TROMPELOEIL_NAMED_ALLOW_CALL(obj, func)                                \
+  TROMPELOEIL_NAMED_ALLOW_CALL_(obj, func, #obj, #func)
+
+#define TROMPELOEIL_NAMED_ALLOW_CALL_(obj, func, obj_s, func_s)                \
+  TROMPELOEIL_NAMED_REQUIRE_CALL_(obj, func, obj_s, func_s)                    \
+    .TROMPELOEIL_INFINITY_TIMES()
+
+
+#define TROMPELOEIL_FORBID_CALL(obj, func)                                     \
+  TROMPELOEIL_FORBID_CALL_(obj, func, #obj, #func)
+
+#define TROMPELOEIL_FORBID_CALL_(obj, func, obj_s, func_s)                     \
+  TROMPELOEIL_REQUIRE_CALL_(obj, func, obj_s, func_s)                          \
+    .TROMPELOEIL_TIMES(0)
+
+
+#define TROMPELOEIL_NAMED_FORBID_CALL(obj, func)                               \
+  TROMPELOEIL_NAMED_FORBID_CALL_(obj, func, #obj, #func)
+
+#define TROMPELOEIL_NAMED_FORBID_CALL_(obj, func, obj_s, func_s)               \
+  TROMPELOEIL_NAMED_REQUIRE_CALL_(obj, func, obj_s, func_s)                    \
+    .TROMPELOEIL_TIMES(0)
+
+#endif /* (TROMPELOEIL_CPLUSPLUS > 201103L) */
+
+
+#define TROMPELOEIL_WITH(...)    TROMPELOEIL_WITH_(=,#__VA_ARGS__, __VA_ARGS__)
+#define TROMPELOEIL_LR_WITH(...) TROMPELOEIL_WITH_(&,#__VA_ARGS__, __VA_ARGS__)
+
+
+#if (TROMPELOEIL_CPLUSPLUS == 201103L)
+
+#define TROMPELOEIL_WITH_(capture, arg_s, ...)                                 \
+  with(                                                                        \
+    arg_s,                                                                     \
+    [capture]                                                                  \
+    (typename trompeloeil_e_t::trompeloeil_call_params_type_t const& trompeloeil_x)\
+    {                                                                          \
+      auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                      \
+      auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                      \
+      auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                      \
+      auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                      \
+      auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                      \
+      auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                      \
+      auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                      \
+      auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                      \
+      auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                      \
+      auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                     \
+      auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                     \
+      auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                     \
+      auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                     \
+      auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                     \
+      auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                     \
+      ::trompeloeil::ignore(                                                   \
+        _1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15);                   \
+      return __VA_ARGS__;                                                      \
+    })
+
+#else /* (TROMPELOEIL_CPLUSPLUS == 201103L) */
+
+#define TROMPELOEIL_WITH_(capture, arg_s, ...)                                 \
+  with(arg_s, [capture](auto const& trompeloeil_x) {                           \
+    auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                        \
+    auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                        \
+    auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                        \
+    auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                        \
+    auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                        \
+    auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                        \
+    auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                        \
+    auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                        \
+    auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                        \
+    auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                       \
+    auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                       \
+    auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                       \
+    auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                       \
+    auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                       \
+    auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                       \
+    ::trompeloeil::ignore(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15); \
+    return __VA_ARGS__;                                                        \
+  })
+
+#endif /* !(TROMPELOEIL_CPLUSPLUS == 201103L) */
+
+
+#define TROMPELOEIL_SIDE_EFFECT(...)    TROMPELOEIL_SIDE_EFFECT_(=, __VA_ARGS__)
+#define TROMPELOEIL_LR_SIDE_EFFECT(...) TROMPELOEIL_SIDE_EFFECT_(&, __VA_ARGS__)
+
+
+#if (TROMPELOEIL_CPLUSPLUS == 201103L)
+
+#define TROMPELOEIL_SIDE_EFFECT_(capture, ...)                                 \
+  sideeffect(                                                                  \
+    [capture]                                                                  \
+    (typename trompeloeil_e_t::trompeloeil_call_params_type_t& trompeloeil_x)  \
+    {                                                                          \
+      auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                      \
+      auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                      \
+      auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                      \
+      auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                      \
+      auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                      \
+      auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                      \
+      auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                      \
+      auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                      \
+      auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                      \
+      auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                     \
+      auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                     \
+      auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                     \
+      auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                     \
+      auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                     \
+      auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                     \
+      ::trompeloeil::ignore(                                                   \
+        _1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15);                   \
+      __VA_ARGS__;                                                             \
+    })
+
+#else /* (TROMPELOEIL_CPLUSPLUS == 201103L) */
+
+#define TROMPELOEIL_SIDE_EFFECT_(capture, ...)                                 \
+  sideeffect([capture](auto& trompeloeil_x) {                                  \
+    auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                        \
+    auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                        \
+    auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                        \
+    auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                        \
+    auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                        \
+    auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                        \
+    auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                        \
+    auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                        \
+    auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                        \
+    auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                       \
+    auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                       \
+    auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                       \
+    auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                       \
+    auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                       \
+    auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                       \
+    ::trompeloeil::ignore(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15); \
+    __VA_ARGS__;                                                               \
+  })
+
+#endif /* !(TROMPELOEIL_CPLUSPLUS == 201103L) */
+
+
+#define TROMPELOEIL_RETURN(...)    TROMPELOEIL_RETURN_(=, __VA_ARGS__)
+#define TROMPELOEIL_LR_RETURN(...) TROMPELOEIL_RETURN_(&, __VA_ARGS__)
+
+
+#if (TROMPELOEIL_CPLUSPLUS == 201103L)
+
+#define TROMPELOEIL_RETURN_(capture, ...)                                      \
+  handle_return(                                                               \
+    [capture]                                                                  \
+    (typename trompeloeil_e_t::trompeloeil_call_params_type_t& trompeloeil_x)  \
+      -> typename trompeloeil_e_t::trompeloeil_return_of_t                     \
+    {                                                                          \
+      auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                      \
+      auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                      \
+      auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                      \
+      auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                      \
+      auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                      \
+      auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                      \
+      auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                      \
+      auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                      \
+      auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                      \
+      auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                     \
+      auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                     \
+      auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                     \
+      auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                     \
+      auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                     \
+      auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                     \
+      ::trompeloeil::ignore(                                                   \
+        _1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15);                   \
+      return ::trompeloeil::decay_return_type(__VA_ARGS__);                    \
+    })
+
+#else /* (TROMPELOEIL_CPLUSPLUS == 201103L) */
+
+#define TROMPELOEIL_RETURN_(capture, ...)                                      \
+  handle_return([capture](auto& trompeloeil_x) -> decltype(auto) {             \
+    auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                        \
+    auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                        \
+    auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                        \
+    auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                        \
+    auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                        \
+    auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                        \
+    auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                        \
+    auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                        \
+    auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                        \
+    auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                       \
+    auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                       \
+    auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                       \
+    auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                       \
+    auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                       \
+    auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                       \
+    ::trompeloeil::ignore(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15); \
+    return ::trompeloeil::decay_return_type(__VA_ARGS__);                      \
+  })
+
+#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
+
+#define TROMPELOEIL_CO_RETURN(...)    TROMPELOEIL_CO_RETURN_(=, __VA_ARGS__)
+#define TROMPELOEIL_LR_CO_RETURN(...) TROMPELOEIL_CO_RETURN_(&, __VA_ARGS__)
+
+#define TROMPELOEIL_CO_RETURN_(capture, ...) \
+  handle_co_return([capture](auto& trompeloeil_x) -> decltype(auto) { \
+    auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                        \
+    auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                        \
+    auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                        \
+    auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                        \
+    auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                        \
+    auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                        \
+    auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                        \
+    auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                        \
+    auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                        \
+    auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                       \
+    auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                       \
+    auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                       \
+    auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                       \
+    auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                       \
+    auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                       \
+    ::trompeloeil::ignore(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15); \
+    return ::trompeloeil::decay_return_type(__VA_ARGS__);                      \
+  })
+
+#endif
+
+#endif /* !(TROMPELOEIL_CPLUSPLUS == 201103L) */
+
+
+#define TROMPELOEIL_THROW(...)    TROMPELOEIL_THROW_(=, __VA_ARGS__)
+#define TROMPELOEIL_LR_THROW(...) TROMPELOEIL_THROW_(&, __VA_ARGS__)
+
+
+#if (TROMPELOEIL_CPLUSPLUS == 201103L)
+
+#define TROMPELOEIL_THROW_(capture, ...)                                       \
+  handle_throw(                                                                \
+    [capture]                                                                  \
+    (typename trompeloeil_e_t::trompeloeil_call_params_type_t& trompeloeil_x)  \
+    {                                                                          \
+      auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                      \
+      auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                      \
+      auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                      \
+      auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                      \
+      auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                      \
+      auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                      \
+      auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                      \
+      auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                      \
+      auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                      \
+      auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                     \
+      auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                     \
+      auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                     \
+      auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                     \
+      auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                     \
+      auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                     \
+      ::trompeloeil::ignore(                                                   \
+        _1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15);                   \
+      throw __VA_ARGS__;                                                       \
+    })
+
+#else /* (TROMPELOEIL_CPLUSPLUS == 201103L) */
+
+#define TROMPELOEIL_THROW_(capture, ...)                                       \
+  handle_throw([capture](auto& trompeloeil_x)  {                               \
+    auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                        \
+    auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                        \
+    auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                        \
+    auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                        \
+    auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                        \
+    auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                        \
+    auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                        \
+    auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                        \
+    auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                        \
+    auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                       \
+    auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                       \
+    auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                       \
+    auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                       \
+    auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                       \
+    auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                       \
+    ::trompeloeil::ignore(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15); \
+    throw __VA_ARGS__;                                                         \
+ })
+
+#endif /* !(TROMPELOEIL_CPLUSPLUS == 201103L) */
+
+#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
+
+#define TROMPELOEIL_CO_THROW(...)    TROMPELOEIL_CO_THROW_(=, __VA_ARGS__)
+#define TROMPELOEIL_LR_CO_THROW(...) TROMPELOEIL_CO_THROW_(&, __VA_ARGS__)
+
+#define TROMPELOEIL_CO_THROW_(capture, ...)                                    \
+  handle_co_throw([capture](auto& trompeloeil_x)  {                            \
+    auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                        \
+    auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                        \
+    auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                        \
+    auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                        \
+    auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                        \
+    auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                        \
+    auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                        \
+    auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                        \
+    auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                        \
+    auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                       \
+    auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                       \
+    auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                       \
+    auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                       \
+    auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                       \
+    auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                       \
+    ::trompeloeil::ignore(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15); \
+    throw __VA_ARGS__;                                                         \
+ })
+
+#define TROMPELOEIL_CO_YIELD(...)    TROMPELOEIL_CO_YIELD_(=, __VA_ARGS__)
+#define TROMPELOEIL_LR_CO_YIELD(...) TROMPELOEIL_CO_YIELD_(&, __VA_ARGS__)
+
+
+#define TROMPELOEIL_CO_YIELD_(capture, ...)                                   \
+  handle_co_yield([capture](auto& trompeloeil_x)  {                            \
+    auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                        \
+    auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                        \
+    auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                        \
+    auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                        \
+    auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                        \
+    auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                        \
+    auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                        \
+    auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                        \
+    auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                        \
+    auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                       \
+    auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                       \
+    auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                       \
+    auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                       \
+    auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                       \
+    auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                       \
+    ::trompeloeil::ignore(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15); \
+    return __VA_ARGS__;                                                         \
+ })
+#endif
+
+
+#define TROMPELOEIL_TIMES(...) times(::trompeloeil::multiplicity<__VA_ARGS__>{})
+#define TROMPELOEIL_INFINITY_TIMES() TROMPELOEIL_TIMES(0, ~static_cast<size_t>(0))
+
+#define TROMPELOEIL_IN_SEQUENCE(...)                                           \
+  in_sequence(TROMPELOEIL_INIT_WITH_STR(::trompeloeil::sequence_matcher::init_type, __VA_ARGS__))
+
+#define TROMPELOEIL_ANY(type) ::trompeloeil::any_matcher<type>(#type)
+
+#define TROMPELOEIL_AT_LEAST(num) num, ~static_cast<size_t>(0)
+#define TROMPELOEIL_AT_MOST(num) 0, num
+
+#define TROMPELOEIL_REQUIRE_DESTRUCTION(obj)                                   \
+  TROMPELOEIL_REQUIRE_DESTRUCTION_(obj, #obj)
+
+#define TROMPELOEIL_REQUIRE_DESTRUCTION_(obj, obj_s)                           \
+  std::unique_ptr<trompeloeil::expectation>                                    \
+    TROMPELOEIL_CONCAT(trompeloeil_death_monitor_, __LINE__)                   \
+    = TROMPELOEIL_NAMED_REQUIRE_DESTRUCTION_(,obj, obj_s)
+
+#define TROMPELOEIL_NAMED_REQUIRE_DESTRUCTION(obj)                             \
+  TROMPELOEIL_NAMED_REQUIRE_DESTRUCTION_("NAMED_", obj, #obj)
+
+#define TROMPELOEIL_NAMED_REQUIRE_DESTRUCTION_(prefix, obj, obj_s)             \
+  trompeloeil::lifetime_monitor_releaser{} +                                   \
+  trompeloeil::lifetime_monitor_modifier<false>{                               \
+    ::trompeloeil::detail::make_unique<trompeloeil::lifetime_monitor>(         \
+      obj,                                                                     \
+      obj_s,                                                                   \
+      prefix "REQUIRE_DESTRUCTION(" obj_s ")",                                 \
+      "destructor for " obj_s,                                                 \
+      ::trompeloeil::location{__FILE__,                                        \
+                              static_cast<unsigned long>(__LINE__)})           \
+  }
+
+#ifndef TROMPELOEIL_LONG_MACROS
+#define MAKE_MOCK0                TROMPELOEIL_MAKE_MOCK0
+#define MAKE_MOCK1                TROMPELOEIL_MAKE_MOCK1
+#define MAKE_MOCK2                TROMPELOEIL_MAKE_MOCK2
+#define MAKE_MOCK3                TROMPELOEIL_MAKE_MOCK3
+#define MAKE_MOCK4                TROMPELOEIL_MAKE_MOCK4
+#define MAKE_MOCK5                TROMPELOEIL_MAKE_MOCK5
+#define MAKE_MOCK6                TROMPELOEIL_MAKE_MOCK6
+#define MAKE_MOCK7                TROMPELOEIL_MAKE_MOCK7
+#define MAKE_MOCK8                TROMPELOEIL_MAKE_MOCK8
+#define MAKE_MOCK9                TROMPELOEIL_MAKE_MOCK9
+#define MAKE_MOCK10               TROMPELOEIL_MAKE_MOCK10
+#define MAKE_MOCK11               TROMPELOEIL_MAKE_MOCK11
+#define MAKE_MOCK12               TROMPELOEIL_MAKE_MOCK12
+#define MAKE_MOCK13               TROMPELOEIL_MAKE_MOCK13
+#define MAKE_MOCK14               TROMPELOEIL_MAKE_MOCK14
+#define MAKE_MOCK15               TROMPELOEIL_MAKE_MOCK15
+
+#define MAKE_CONST_MOCK0          TROMPELOEIL_MAKE_CONST_MOCK0
+#define MAKE_CONST_MOCK1          TROMPELOEIL_MAKE_CONST_MOCK1
+#define MAKE_CONST_MOCK2          TROMPELOEIL_MAKE_CONST_MOCK2
+#define MAKE_CONST_MOCK3          TROMPELOEIL_MAKE_CONST_MOCK3
+#define MAKE_CONST_MOCK4          TROMPELOEIL_MAKE_CONST_MOCK4
+#define MAKE_CONST_MOCK5          TROMPELOEIL_MAKE_CONST_MOCK5
+#define MAKE_CONST_MOCK6          TROMPELOEIL_MAKE_CONST_MOCK6
+#define MAKE_CONST_MOCK7          TROMPELOEIL_MAKE_CONST_MOCK7
+#define MAKE_CONST_MOCK8          TROMPELOEIL_MAKE_CONST_MOCK8
+#define MAKE_CONST_MOCK9          TROMPELOEIL_MAKE_CONST_MOCK9
+#define MAKE_CONST_MOCK10         TROMPELOEIL_MAKE_CONST_MOCK10
+#define MAKE_CONST_MOCK11         TROMPELOEIL_MAKE_CONST_MOCK11
+#define MAKE_CONST_MOCK12         TROMPELOEIL_MAKE_CONST_MOCK12
+#define MAKE_CONST_MOCK13         TROMPELOEIL_MAKE_CONST_MOCK13
+#define MAKE_CONST_MOCK14         TROMPELOEIL_MAKE_CONST_MOCK14
+#define MAKE_CONST_MOCK15         TROMPELOEIL_MAKE_CONST_MOCK15
+
+#define IMPLEMENT_MOCK0           TROMPELOEIL_IMPLEMENT_MOCK0
+#define IMPLEMENT_MOCK1           TROMPELOEIL_IMPLEMENT_MOCK1
+#define IMPLEMENT_MOCK2           TROMPELOEIL_IMPLEMENT_MOCK2
+#define IMPLEMENT_MOCK3           TROMPELOEIL_IMPLEMENT_MOCK3
+#define IMPLEMENT_MOCK4           TROMPELOEIL_IMPLEMENT_MOCK4
+#define IMPLEMENT_MOCK5           TROMPELOEIL_IMPLEMENT_MOCK5
+#define IMPLEMENT_MOCK6           TROMPELOEIL_IMPLEMENT_MOCK6
+#define IMPLEMENT_MOCK7           TROMPELOEIL_IMPLEMENT_MOCK7
+#define IMPLEMENT_MOCK8           TROMPELOEIL_IMPLEMENT_MOCK8
+#define IMPLEMENT_MOCK9           TROMPELOEIL_IMPLEMENT_MOCK9
+#define IMPLEMENT_MOCK10          TROMPELOEIL_IMPLEMENT_MOCK10
+#define IMPLEMENT_MOCK11          TROMPELOEIL_IMPLEMENT_MOCK11
+#define IMPLEMENT_MOCK12          TROMPELOEIL_IMPLEMENT_MOCK12
+#define IMPLEMENT_MOCK13          TROMPELOEIL_IMPLEMENT_MOCK13
+#define IMPLEMENT_MOCK14          TROMPELOEIL_IMPLEMENT_MOCK14
+#define IMPLEMENT_MOCK15          TROMPELOEIL_IMPLEMENT_MOCK15
+
+#define IMPLEMENT_CONST_MOCK0     TROMPELOEIL_IMPLEMENT_CONST_MOCK0
+#define IMPLEMENT_CONST_MOCK1     TROMPELOEIL_IMPLEMENT_CONST_MOCK1
+#define IMPLEMENT_CONST_MOCK2     TROMPELOEIL_IMPLEMENT_CONST_MOCK2
+#define IMPLEMENT_CONST_MOCK3     TROMPELOEIL_IMPLEMENT_CONST_MOCK3
+#define IMPLEMENT_CONST_MOCK4     TROMPELOEIL_IMPLEMENT_CONST_MOCK4
+#define IMPLEMENT_CONST_MOCK5     TROMPELOEIL_IMPLEMENT_CONST_MOCK5
+#define IMPLEMENT_CONST_MOCK6     TROMPELOEIL_IMPLEMENT_CONST_MOCK6
+#define IMPLEMENT_CONST_MOCK7     TROMPELOEIL_IMPLEMENT_CONST_MOCK7
+#define IMPLEMENT_CONST_MOCK8     TROMPELOEIL_IMPLEMENT_CONST_MOCK8
+#define IMPLEMENT_CONST_MOCK9     TROMPELOEIL_IMPLEMENT_CONST_MOCK9
+#define IMPLEMENT_CONST_MOCK10    TROMPELOEIL_IMPLEMENT_CONST_MOCK10
+#define IMPLEMENT_CONST_MOCK11    TROMPELOEIL_IMPLEMENT_CONST_MOCK11
+#define IMPLEMENT_CONST_MOCK12    TROMPELOEIL_IMPLEMENT_CONST_MOCK12
+#define IMPLEMENT_CONST_MOCK13    TROMPELOEIL_IMPLEMENT_CONST_MOCK13
+#define IMPLEMENT_CONST_MOCK14    TROMPELOEIL_IMPLEMENT_CONST_MOCK14
+#define IMPLEMENT_CONST_MOCK15    TROMPELOEIL_IMPLEMENT_CONST_MOCK15
+
+#define REQUIRE_CALL_V            TROMPELOEIL_REQUIRE_CALL_V
+#define NAMED_REQUIRE_CALL_V      TROMPELOEIL_NAMED_REQUIRE_CALL_V
+#define ALLOW_CALL_V              TROMPELOEIL_ALLOW_CALL_V
+#define NAMED_ALLOW_CALL_V        TROMPELOEIL_NAMED_ALLOW_CALL_V
+#define FORBID_CALL_V             TROMPELOEIL_FORBID_CALL_V
+#define NAMED_FORBID_CALL_V       TROMPELOEIL_NAMED_FORBID_CALL_V
+
+#if (TROMPELOEIL_CPLUSPLUS > 201103L)
+
+#define REQUIRE_CALL              TROMPELOEIL_REQUIRE_CALL
+#define NAMED_REQUIRE_CALL        TROMPELOEIL_NAMED_REQUIRE_CALL
+#define ALLOW_CALL                TROMPELOEIL_ALLOW_CALL
+#define NAMED_ALLOW_CALL          TROMPELOEIL_NAMED_ALLOW_CALL
+#define FORBID_CALL               TROMPELOEIL_FORBID_CALL
+#define NAMED_FORBID_CALL         TROMPELOEIL_NAMED_FORBID_CALL
+
+#endif /* (TROMPELOEIL_CPLUSPLUS > 201103L) */
+
+#define WITH                      TROMPELOEIL_WITH
+#define LR_WITH                   TROMPELOEIL_LR_WITH
+#define SIDE_EFFECT               TROMPELOEIL_SIDE_EFFECT
+#define LR_SIDE_EFFECT            TROMPELOEIL_LR_SIDE_EFFECT
+#define RETURN                    TROMPELOEIL_RETURN
+#define LR_RETURN                 TROMPELOEIL_LR_RETURN
+#define THROW                     TROMPELOEIL_THROW
+#define LR_THROW                  TROMPELOEIL_LR_THROW
+#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
+#define CO_RETURN                 TROMPELOEIL_CO_RETURN
+#define LR_CO_RETURN              TROMPELOEIL_LR_CO_RETURN
+#define CO_THROW                  TROMPELOEIL_CO_THROW
+#define LR_CO_THROW               TROMPELOEIL_LR_CO_THROW
+#define CO_YIELD                  TROMPELOEIL_CO_YIELD
+#define LR_CO_YIELD               TROMPELOEIL_LR_CO_YIELD
+#endif
+#define TIMES                     TROMPELOEIL_TIMES
+#define IN_SEQUENCE               TROMPELOEIL_IN_SEQUENCE
+#define ANY                       TROMPELOEIL_ANY
+#define AT_LEAST                  TROMPELOEIL_AT_LEAST
+#define AT_MOST                   TROMPELOEIL_AT_MOST
+#define REQUIRE_DESTRUCTION       TROMPELOEIL_REQUIRE_DESTRUCTION
+#define NAMED_REQUIRE_DESTRUCTION TROMPELOEIL_NAMED_REQUIRE_DESTRUCTION
+
+#endif // TROMPELOEIL_LONG_MACROS
+
+#endif // include guard

From 859151b45dcd1a26ab4fc97048c0e9ea256c1bbc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Fahller?= <bjorn@fahller.se>
Date: Sat, 4 Nov 2023 14:26:40 +0100
Subject: [PATCH 02/20] Break out matcher/re.hpp

---
 docs/reference.md                  |   2 +
 include/trompeloeil.hpp            |   1 +
 include/trompeloeil/matcher/re.hpp | 146 +++++++++++++++++++++++++++++
 include/trompeloeil/mock.hpp       | 120 ------------------------
 4 files changed, 149 insertions(+), 120 deletions(-)
 create mode 100644 include/trompeloeil/matcher/re.hpp

diff --git a/docs/reference.md b/docs/reference.md
index f28847d3..e2189d4b 100644
--- a/docs/reference.md
+++ b/docs/reference.md
@@ -537,6 +537,8 @@ equal value.
 Used in the parameter list of an [expectation](#expectation) to match a
 string with a regular expression.
 
+`#include <trompeloeil/matcher/re.hpp>`
+
 **`re()`** exists in two flavours.
 
 - **`re(`** *string*, *flags...* **`)`**
diff --git a/include/trompeloeil.hpp b/include/trompeloeil.hpp
index 482c77cd..0a1ead3f 100644
--- a/include/trompeloeil.hpp
+++ b/include/trompeloeil.hpp
@@ -27,5 +27,6 @@
 // * If a macro kills a kitten, this threatens extinction of all felines!
 
 #include "trompeloeil/mock.hpp"
+#include "trompeloeil/matcher/re.hpp"
 
 #endif // include guard
diff --git a/include/trompeloeil/matcher/re.hpp b/include/trompeloeil/matcher/re.hpp
new file mode 100644
index 00000000..ca49ae07
--- /dev/null
+++ b/include/trompeloeil/matcher/re.hpp
@@ -0,0 +1,146 @@
+/*
+ * Trompeloeil C++ mocking framework
+ *
+ * Copyright (C) Björn Fahller
+ * Copyright (C) Andrew Paxie
+ *
+ *  Use, modification and distribution is subject to the
+ *  Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy atl
+ *  http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * Project home: https://github.com/rollbear/trompeloeil
+ */
+
+#ifndef TROMPELOEIL_RE_HPP
+#define TROMPELOEIL_RE_HPP
+
+#include "../mock.hpp"
+
+#include <regex>
+#include <cstring>
+
+namespace trompeloeil
+{
+namespace lambdas {
+struct regex_check
+{
+
+  class string_helper // a vastly simplified string_view type of class
+  {
+  public:
+    template <
+      typename S,
+      typename = decltype(std::declval<const char*&>() = std::declval<S>().data()),
+      typename = decltype(std::declval<S>().length())
+    >
+    string_helper(
+      const S& s)
+    noexcept
+      : begin_(s.data())
+        , end_(begin_ + s.length())
+    {}
+
+    constexpr
+    string_helper(
+      char const* s)
+    noexcept
+      : begin_(s)
+        , end_(s ? begin_ + strlen(s) : nullptr)
+    {
+    }
+
+    constexpr
+    explicit
+    operator bool() const
+    {
+      return begin_;
+    }
+    constexpr
+    char const *
+    begin()
+    const
+    {
+      return begin_;
+    }
+    constexpr
+    char const *
+    end()
+    const
+    {
+      return end_;
+    }
+  private:
+    char const* begin_;
+    char const* end_;
+  };
+
+  regex_check(
+    std::regex&& re_,
+    std::regex_constants::match_flag_type match_type_)
+    : re(std::move(re_)),
+    match_type(match_type_)
+  {}
+
+  template <typename T>
+  bool
+  operator()(
+    string_helper str,
+    T const&)
+  const
+  {
+    return str && std::regex_search(str.begin(), str.end(), re, match_type);
+  }
+
+private:
+  std::regex re;
+  std::regex_constants::match_flag_type match_type;
+};
+
+struct regex_printer
+{
+  template <typename T>
+  void
+  operator()(
+    std::ostream& os,
+    T const& str)
+  const
+  {
+    os << " matching regular expression /" << str << "/";
+  }
+};
+}
+
+template <
+  typename Kind = wildcard,
+  typename R = make_matcher_return<Kind, lambdas::regex_check, lambdas::regex_printer, std::string&&>>
+auto
+re(
+  std::string s,
+  std::regex_constants::syntax_option_type opt = std::regex_constants::ECMAScript,
+  std::regex_constants::match_flag_type match_type = std::regex_constants::match_default)
+TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+{
+  return make_matcher<Kind>(lambdas::regex_check(std::regex(s, opt),
+                                                 match_type),
+                            lambdas::regex_printer(),
+                            std::move(s));
+}
+
+template <
+  typename Kind = wildcard,
+  typename R = make_matcher_return<Kind, lambdas::regex_check, lambdas::regex_printer, std::string&&>>
+auto
+re(
+  std::string s,
+  std::regex_constants::match_flag_type match_type)
+TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+{
+  return make_matcher<Kind>(lambdas::regex_check(std::regex(s), match_type),
+                            lambdas::regex_printer(),
+                            std::move(s));
+}
+
+
+}
+#endif //TROMPELOEIL_RE_HPP
diff --git a/include/trompeloeil/mock.hpp b/include/trompeloeil/mock.hpp
index f33c7aa8..965b886c 100644
--- a/include/trompeloeil/mock.hpp
+++ b/include/trompeloeil/mock.hpp
@@ -2602,126 +2602,6 @@ template <typename T>
                            std::forward<V>(v));
   }
 
-  namespace lambdas {
-
-    struct regex_check
-    {
-
-      class string_helper // a vastly simplified string_view type of class
-      {
-      public:
-        template <
-          typename S,
-          typename = decltype(std::declval<const char*&>() = std::declval<S>().data()),
-          typename = decltype(std::declval<S>().length())
-            >
-        string_helper(
-          const S& s)
-        noexcept
-          : begin_(s.data())
-          , end_(begin_ + s.length())
-        {}
-
-        constexpr
-        string_helper(
-          char const* s)
-        noexcept
-          : begin_(s)
-          , end_(s ? begin_ + strlen(s) : nullptr)
-        {
-        }
-
-        constexpr
-        explicit
-        operator bool() const
-        {
-          return begin_;
-        }
-        constexpr
-        char const *
-        begin()
-          const
-        {
-          return begin_;
-        }
-        constexpr
-        char const *
-        end()
-          const
-        {
-          return end_;
-        }
-      private:
-        char const* begin_;
-        char const* end_;
-      };
-
-      regex_check(
-        std::regex&& re_,
-        std::regex_constants::match_flag_type match_type_)
-        : re(std::move(re_)),
-          match_type(match_type_)
-      {}
-
-      template <typename T>
-      bool
-      operator()(
-        string_helper str,
-        T const&)
-      const
-      {
-        return str && std::regex_search(str.begin(), str.end(), re, match_type);
-      }
-
-    private:
-      std::regex re;
-      std::regex_constants::match_flag_type match_type;
-    };
-
-    struct regex_printer
-    {
-      template <typename T>
-      void
-      operator()(
-        std::ostream& os,
-        T const& str)
-      const
-      {
-        os << " matching regular expression /" << str << "/";
-      }
-    };
-  }
-
-  template <
-    typename Kind = wildcard,
-    typename R = make_matcher_return<Kind, lambdas::regex_check, lambdas::regex_printer, std::string&&>>
-  auto
-  re(
-    std::string s,
-    std::regex_constants::syntax_option_type opt = std::regex_constants::ECMAScript,
-    std::regex_constants::match_flag_type match_type = std::regex_constants::match_default)
-  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
-  {
-    return make_matcher<Kind>(lambdas::regex_check(std::regex(s, opt),
-                                                   match_type),
-                              lambdas::regex_printer(),
-                              std::move(s));
-  }
-
-  template <
-    typename Kind = wildcard,
-    typename R = make_matcher_return<Kind, lambdas::regex_check, lambdas::regex_printer, std::string&&>>
-  auto
-  re(
-    std::string s,
-    std::regex_constants::match_flag_type match_type)
-  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
-  {
-    return make_matcher<Kind>(lambdas::regex_check(std::regex(s), match_type),
-                              lambdas::regex_printer(),
-                              std::move(s));
-  }
-
   inline
   std::string
   param_name_prefix(

From f7f58b0b2f5cb45bbcc167e2684816e10fa415e7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Fahller?= <bjorn@fahller.se>
Date: Sat, 4 Nov 2023 14:42:34 +0100
Subject: [PATCH 03/20] Break out matcher/compare.hpp

---
 docs/reference.md                       |  12 ++
 include/trompeloeil.hpp                 |   1 +
 include/trompeloeil/matcher/compare.hpp | 161 ++++++++++++++++++++++++
 include/trompeloeil/mock.hpp            | 133 --------------------
 4 files changed, 174 insertions(+), 133 deletions(-)
 create mode 100644 include/trompeloeil/matcher/compare.hpp

diff --git a/docs/reference.md b/docs/reference.md
index e2189d4b..0fb126a1 100644
--- a/docs/reference.md
+++ b/docs/reference.md
@@ -295,6 +295,8 @@ value equal to the one provided. By default it matches any parameter type
 that supports `operator==()` with the value, but an explicit type can be
 specified if needed for disambiguation.
 
+`#include <trompeloeil/matcher/compare.hpp>`
+
 Example:
 
 ```Cpp
@@ -335,6 +337,8 @@ value not equal to the one provided. By default it matches any parameter type
 that supports `operator!=()` with the value, but an explicit type can be
 specified if needed for disambiguation.
 
+`#include <trompeloeil/matcher/compare.hpp>`
+
 Example:
 
 ```Cpp
@@ -372,6 +376,8 @@ value greater than the one provided. By default it matches any parameter type
 that supports `operator>()` with the value, but an explicit type can be
 specified if needed for disambiguation.
 
+`#include <trompeloeil/matcher/compare.hpp>`
+
 Example:
 
 ```Cpp
@@ -415,6 +421,8 @@ value greater than on equal to the one provided. By default it matches any
 parameter type that supports `operator>=()` with the value, but an explicit
 type can be specified if needed for disambiguation.
 
+`#include <trompeloeil/matcher/compare.hpp>`
+
 Example:
 
 ```Cpp
@@ -457,6 +465,8 @@ value less than the one provided. By default it matches any parameter type
 that supports `operator<()` with the value, but an explicit type can be
 specified if needed for disambiguation.
 
+`#include <trompeloeil/matcher/compare.hpp>`
+
 Example:
 
 ```Cpp
@@ -498,6 +508,8 @@ value less than or equal to the one provided. By default it matches any
 parameter type that supports `operator<=()` with the value, but an explicit type
 can be specified if needed for disambiguation.
 
+`#include <trompeloeil/matcher/compare.hpp>`
+
 Example:
 
 ```Cpp
diff --git a/include/trompeloeil.hpp b/include/trompeloeil.hpp
index 0a1ead3f..301713b0 100644
--- a/include/trompeloeil.hpp
+++ b/include/trompeloeil.hpp
@@ -27,6 +27,7 @@
 // * If a macro kills a kitten, this threatens extinction of all felines!
 
 #include "trompeloeil/mock.hpp"
+#include "trompeloeil/matcher/compare.hpp"
 #include "trompeloeil/matcher/re.hpp"
 
 #endif // include guard
diff --git a/include/trompeloeil/matcher/compare.hpp b/include/trompeloeil/matcher/compare.hpp
new file mode 100644
index 00000000..b06f8ba2
--- /dev/null
+++ b/include/trompeloeil/matcher/compare.hpp
@@ -0,0 +1,161 @@
+/*
+ * Trompeloeil C++ mocking framework
+ *
+ * Copyright (C) Björn Fahller
+ * Copyright (C) Andrew Paxie
+ *
+ *  Use, modification and distribution is subject to the
+ *  Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy atl
+ *  http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * Project home: https://github.com/rollbear/trompeloeil
+ */
+
+#ifndef TROMPELOEIL_COMPARE_HPP
+#define TROMPELOEIL_COMPARE_HPP
+
+#include "../mock.hpp"
+
+namespace trompeloeil
+{
+
+  namespace lambdas {
+    // The below must be classes/structs to work with VS 2015 update 3
+    // since it doesn't respect the trailing return type declaration on
+    // the lambdas of template deduction context
+
+#define TROMPELOEIL_MK_PRED_BINOP(name, op)                             \
+    struct name {                                                       \
+      template <typename X, typename Y>                                 \
+      auto operator()(X const& x, Y const& y) const -> decltype(x op y) \
+      {                                                                 \
+        ::trompeloeil::ignore(x,y);                                     \
+        return x op y;                                                  \
+      }                                                                 \
+    }
+    TROMPELOEIL_MK_PRED_BINOP(equal, ==);
+    TROMPELOEIL_MK_PRED_BINOP(not_equal, !=);
+    TROMPELOEIL_MK_PRED_BINOP(less, <);
+    TROMPELOEIL_MK_PRED_BINOP(less_equal, <=);
+    TROMPELOEIL_MK_PRED_BINOP(greater, >);
+    TROMPELOEIL_MK_PRED_BINOP(greater_equal, >=);
+#undef TROMPELOEIL_MK_PRED_BINOP
+
+#define TROMPELOEIL_MK_OP_PRINTER(name, op_string)                      \
+    struct name ## _printer                                             \
+    {                                                                   \
+      template <typename T>                                             \
+      void                                                              \
+      operator()(                                                       \
+        std::ostream& os,                                               \
+        T const& value)                                                 \
+      const                                                             \
+      {                                                                 \
+        os << op_string;                                                \
+        ::trompeloeil::print(os, value);                                \
+      }                                                                 \
+    }
+    TROMPELOEIL_MK_OP_PRINTER(equal, " == ");
+    TROMPELOEIL_MK_OP_PRINTER(not_equal, " != ");
+    TROMPELOEIL_MK_OP_PRINTER(less, " < ");
+    TROMPELOEIL_MK_OP_PRINTER(less_equal, " <= ");
+    TROMPELOEIL_MK_OP_PRINTER(greater, " > ");
+    TROMPELOEIL_MK_OP_PRINTER(greater_equal, " >= ");
+#undef TROMPELOEIL_MK_OP_PRINTER
+
+
+  }
+template <
+  typename T = wildcard,
+  typename V,
+  typename R = make_matcher_return<T, lambdas::equal, lambdas::equal_printer, V>>
+inline
+auto
+eq(
+  V&& v)
+TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+{
+  return make_matcher<T>(lambdas::equal(),
+                         lambdas::equal_printer(),
+                         std::forward<V>(v));
+}
+
+template <
+  typename T = wildcard,
+  typename V,
+  typename R = make_matcher_return<T, lambdas::not_equal, lambdas::not_equal_printer, V>>
+inline
+auto
+ne(
+  V&& v)
+TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+{
+  return make_matcher<T>(lambdas::not_equal(),
+                         lambdas::not_equal_printer(),
+                         std::forward<V>(v));
+}
+
+template <
+  typename T = wildcard,
+  typename V,
+  typename R = make_matcher_return<T, lambdas::greater_equal, lambdas::greater_equal_printer, V>>
+inline
+auto
+ge(
+  V&& v)
+TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+{
+  return make_matcher<T>(lambdas::greater_equal(),
+                         lambdas::greater_equal_printer(),
+                         std::forward<V>(v));
+}
+
+template <
+  typename T = wildcard,
+  typename V,
+  typename R = make_matcher_return<T, lambdas::greater, lambdas::greater_printer, V>>
+inline
+auto
+gt(
+  V&& v)
+TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+{
+  return make_matcher<T>(lambdas::greater(),
+                         lambdas::greater_printer(),
+                         std::forward<V>(v));
+}
+
+template <
+  typename T = wildcard,
+  typename V,
+  typename R = make_matcher_return<T, lambdas::less, lambdas::less_printer, V>>
+inline
+auto
+lt(
+  V&& v)
+TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+{
+  return make_matcher<T>(lambdas::less(),
+                         lambdas::less_printer(),
+                         std::forward<V>(v));
+}
+
+template <
+  typename T = wildcard,
+  typename V,
+  typename R = make_matcher_return<T, lambdas::less_equal, lambdas::less_equal_printer,  V>>
+inline
+auto
+le(
+  V&& v)
+TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+{
+  return make_matcher<T>(lambdas::less_equal(),
+                         lambdas::less_equal_printer(),
+                         std::forward<V>(v));
+}
+
+}
+
+#endif //TROMPELOEIL_COMPARE_HPP
diff --git a/include/trompeloeil/mock.hpp b/include/trompeloeil/mock.hpp
index 965b886c..c4d798e4 100644
--- a/include/trompeloeil/mock.hpp
+++ b/include/trompeloeil/mock.hpp
@@ -2408,26 +2408,6 @@ template <typename T>
       }
     };
 
-    // The below must be classes/structs to work with VS 2015 update 3
-    // since it doesn't respect the trailing return type declaration on
-    // the lambdas of template deduction context
-
-#define TROMPELOEIL_MK_PRED_BINOP(name, op)                         \
-    struct name {                                                       \
-      template <typename X, typename Y>                                 \
-      auto operator()(X const& x, Y const& y) const -> decltype(x op y) \
-      {                                                                 \
-        ::trompeloeil::ignore(x,y);                                     \
-        return x op y;                                                  \
-      }                                                                 \
-    }
-    TROMPELOEIL_MK_PRED_BINOP(equal, ==);
-    TROMPELOEIL_MK_PRED_BINOP(not_equal, !=);
-    TROMPELOEIL_MK_PRED_BINOP(less, <);
-    TROMPELOEIL_MK_PRED_BINOP(less_equal, <=);
-    TROMPELOEIL_MK_PRED_BINOP(greater, >);
-    TROMPELOEIL_MK_PRED_BINOP(greater_equal, >=);
-#undef TROMPELOEIL_MK_PRED_BINOP
 
     // Define `struct` with `operator()` to replace generic lambdas.
 
@@ -2451,30 +2431,6 @@ template <typename T>
       char const* type_name;
     };
 
-    // These structures replace the `op` printer lambdas.
-
-#define TROMPELOEIL_MK_OP_PRINTER(name, op_string)                  \
-    struct name ## _printer                                             \
-    {                                                                   \
-      template <typename T>                                             \
-      void                                                              \
-      operator()(                                                       \
-        std::ostream& os,                                               \
-        T const& value)                                                 \
-      const                                                             \
-      {                                                                 \
-        os << op_string;                                                \
-        ::trompeloeil::print(os, value);                                \
-      }                                                                 \
-    }
-    TROMPELOEIL_MK_OP_PRINTER(equal, " == ");
-    TROMPELOEIL_MK_OP_PRINTER(not_equal, " != ");
-    TROMPELOEIL_MK_OP_PRINTER(less, " < ");
-    TROMPELOEIL_MK_OP_PRINTER(less_equal, " <= ");
-    TROMPELOEIL_MK_OP_PRINTER(greater, " > ");
-    TROMPELOEIL_MK_OP_PRINTER(greater_equal, " >= ");
-#undef TROMPELOEIL_MK_OP_PRINTER
-
   }
 
   template <typename MatchType, typename Predicate, typename Printer, typename ... T>
@@ -2512,95 +2468,6 @@ template <typename T>
                   " matcher. Please rephrase as pointer instead");
     return any_matcher_impl<T>(name, std::is_array<T>{});
   }
-  template <
-    typename T = wildcard,
-    typename V,
-    typename R = make_matcher_return<T, lambdas::equal, lambdas::equal_printer, V>>
-  inline
-  auto
-  eq(
-    V&& v)
-  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
-  {
-    return make_matcher<T>(lambdas::equal(),
-                           lambdas::equal_printer(),
-                           std::forward<V>(v));
-  }
-
-  template <
-    typename T = wildcard,
-    typename V,
-    typename R = make_matcher_return<T, lambdas::not_equal, lambdas::not_equal_printer, V>>
-  inline
-  auto
-  ne(
-    V&& v)
-  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
-  {
-    return make_matcher<T>(lambdas::not_equal(),
-                           lambdas::not_equal_printer(),
-                           std::forward<V>(v));
-  }
-
-  template <
-    typename T = wildcard,
-    typename V,
-    typename R = make_matcher_return<T, lambdas::greater_equal, lambdas::greater_equal_printer, V>>
-  inline
-  auto
-  ge(
-    V&& v)
-  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
-  {
-    return make_matcher<T>(lambdas::greater_equal(),
-                           lambdas::greater_equal_printer(),
-                           std::forward<V>(v));
-  }
-
-  template <
-    typename T = wildcard,
-    typename V,
-    typename R = make_matcher_return<T, lambdas::greater, lambdas::greater_printer, V>>
-  inline
-  auto
-  gt(
-    V&& v)
-  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
-  {
-    return make_matcher<T>(lambdas::greater(),
-                           lambdas::greater_printer(),
-                           std::forward<V>(v));
-  }
-
-  template <
-    typename T = wildcard,
-    typename V,
-    typename R = make_matcher_return<T, lambdas::less, lambdas::less_printer, V>>
-  inline
-  auto
-  lt(
-    V&& v)
-  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
-  {
-    return make_matcher<T>(lambdas::less(),
-                           lambdas::less_printer(),
-                           std::forward<V>(v));
-  }
-
-  template <
-    typename T = wildcard,
-    typename V,
-    typename R = make_matcher_return<T, lambdas::less_equal, lambdas::less_equal_printer,  V>>
-  inline
-  auto
-  le(
-    V&& v)
-  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
-  {
-    return make_matcher<T>(lambdas::less_equal(),
-                           lambdas::less_equal_printer(),
-                           std::forward<V>(v));
-  }
 
   inline
   std::string

From d990d54ebe8070cbd939def357e67685a1fe1ed3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Fahller?= <bjorn@fahller.se>
Date: Sat, 4 Nov 2023 15:04:21 +0100
Subject: [PATCH 04/20] Break out lifetime.hpp

---
 docs/reference.md                |   8 ++
 include/trompeloeil.hpp          |   1 +
 include/trompeloeil/lifetime.hpp | 221 +++++++++++++++++++++++++++++++
 include/trompeloeil/mock.hpp     | 190 --------------------------
 4 files changed, 230 insertions(+), 190 deletions(-)
 create mode 100644 include/trompeloeil/lifetime.hpp

diff --git a/docs/reference.md b/docs/reference.md
index 0fb126a1..90999673 100644
--- a/docs/reference.md
+++ b/docs/reference.md
@@ -1659,6 +1659,8 @@ object which reports a violation if the
 [**`deathwatched_type`**](#deathwatched_type) [mock object](#mock_object) is
 not destroyed by the time the `expectation` is destroyed.
 
+`#include <trompeloeil/lifetime.hpp>`
+
 Example:
 
 ```Cpp
@@ -1763,6 +1765,8 @@ Create an anonymous [`lifetime_monitor`](#lifetime_monitor_type) which reports
 a violation if the [**`deathwatched`**](#deathwatched_type)
 [mock object](#mock_object) is not destroyed by the end of the scope.
 
+`#include <trompeloeil/lifetime.hpp>`
+
 Example:
 
 ```Cpp
@@ -2073,6 +2077,8 @@ Template used when it is necessary to control the life time of a
 [**`NAMED_REQUIRE_DESTRUCTION(...)`**](#NAMED_REQUIRE_DESTRUCTION)
 operates on instances of `trompeloeil::deathwatched<T>`.
 
+`#include <trompeloeil/lifetime.hpp>`
+
 Example:
 
 ```Cpp
@@ -2140,6 +2146,8 @@ results in a
 which you can hold in a variable. `trompeloeil::lifetime_monitor` inherits from
 [`trompeloeil::expectation`](#expectation_type).
 
+`#include <trompeloeil/lifetime.hpp>`
+
 Example:
 
 ```Cpp
diff --git a/include/trompeloeil.hpp b/include/trompeloeil.hpp
index 301713b0..e454cf95 100644
--- a/include/trompeloeil.hpp
+++ b/include/trompeloeil.hpp
@@ -27,6 +27,7 @@
 // * If a macro kills a kitten, this threatens extinction of all felines!
 
 #include "trompeloeil/mock.hpp"
+#include "trompeloeil/lifetime.hpp"
 #include "trompeloeil/matcher/compare.hpp"
 #include "trompeloeil/matcher/re.hpp"
 
diff --git a/include/trompeloeil/lifetime.hpp b/include/trompeloeil/lifetime.hpp
new file mode 100644
index 00000000..c4b3fa26
--- /dev/null
+++ b/include/trompeloeil/lifetime.hpp
@@ -0,0 +1,221 @@
+/*
+ * Trompeloeil C++ mocking framework
+ *
+ * Copyright (C) Björn Fahller
+ * Copyright (C) Andrew Paxie
+ *
+ *  Use, modification and distribution is subject to the
+ *  Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy atl
+ *  http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * Project home: https://github.com/rollbear/trompeloeil
+ */
+
+#ifndef TROMPELOEIL_LIFETIME_HPP
+#define TROMPELOEIL_LIFETIME_HPP
+
+#include "mock.hpp"
+
+#if defined(__cxx_rtti) || defined(__GXX_RTTI) || defined(_CPPRTTI)
+#  define TROMPELOEIL_TYPE_ID_NAME(x) typeid(x).name()
+#else
+#  define TROMPELOEIL_TYPE_ID_NAME(x) "object"
+#endif
+
+namespace trompeloeil
+{
+struct lifetime_monitor;
+
+template <typename T>
+class deathwatched : public T
+{
+  static_assert(std::has_virtual_destructor<T>::value,
+                "virtual destructor is a necessity for deathwatched to work");
+public:
+  template <typename ... U,
+    typename = detail::enable_if_t<std::is_constructible<T,U...>::value>>
+  deathwatched(
+    U&& ...u)
+  noexcept(noexcept(T(std::declval<U>()...)))
+    : T(std::forward<U>(u)...)
+  {}
+
+  ~deathwatched() override;
+
+  trompeloeil::lifetime_monitor*&
+  trompeloeil_expect_death(
+    trompeloeil::lifetime_monitor* monitor)
+  const
+  noexcept
+  {
+    auto lock = get_lock();
+    trompeloeil_lifetime_monitor = monitor;
+    return trompeloeil_lifetime_monitor.leak();
+  }
+private:
+  mutable null_on_move<trompeloeil::lifetime_monitor> trompeloeil_lifetime_monitor;
+};
+
+struct lifetime_monitor : public expectation
+{
+  template <typename T>
+  lifetime_monitor(
+    ::trompeloeil::deathwatched<T> const &obj,
+    char const* obj_name_,
+    char const* invocation_name_,
+    char const* call_name_,
+    location loc_)
+  noexcept
+    : object_monitor(obj.trompeloeil_expect_death(this))
+      , loc(loc_)
+      , object_name(obj_name_)
+      , invocation_name(invocation_name_)
+      , call_name(call_name_)
+  {
+  }
+
+  bool is_satisfied() const noexcept override
+  {
+    return died;
+  }
+
+  bool is_saturated() const noexcept override
+  {
+    return died;
+  }
+
+  lifetime_monitor(lifetime_monitor const&) = delete;
+
+  ~lifetime_monitor() override
+  {
+    auto lock = get_lock();
+    if (!died)
+    {
+      std::ostringstream os;
+      os << "Object " << object_name << " is still alive";
+      send_report<specialized>(severity::nonfatal, loc, os.str());
+      object_monitor = nullptr; // prevent its death poking this cadaver
+    }
+  }
+
+  void
+  notify()
+  noexcept
+  {
+    died = true;
+    sequences->validate(severity::nonfatal, call_name, loc);
+
+    sequences->increment_call();
+    if (sequences->is_satisfied())
+    {
+      sequences->retire_predecessors();
+    }
+  }
+
+  template <typename ... T>
+  void
+  set_sequence(
+    T&& ... t)
+  {
+    using handler = sequence_handler<sizeof...(T)>;
+    auto seq = detail::make_unique<handler>(*sequences,
+                                            invocation_name,
+                                            loc,
+                                            std::forward<T>(t)...);
+    sequences = std::move(seq);
+  }
+private:
+  atomic<bool>       died{false};
+  lifetime_monitor *&object_monitor;
+  location           loc;
+  char const        *object_name;
+  char const        *invocation_name;
+  char const        *call_name;
+  std::unique_ptr<sequence_handler_base>  sequences = detail::make_unique<sequence_handler<0>>();
+};
+
+template <typename T>
+deathwatched<T>::~deathwatched()
+{
+  auto lock = get_lock();
+  if (trompeloeil_lifetime_monitor)
+  {
+    trompeloeil_lifetime_monitor->notify();
+    return;
+  }
+  std::ostringstream os;
+  os << "Unexpected destruction of "
+     << TROMPELOEIL_TYPE_ID_NAME(T) << "@" << this << '\n';
+  send_report<specialized>(severity::nonfatal,
+                           location{},
+                           os.str());
+}
+
+template <bool sequence_set>
+struct lifetime_monitor_modifier : std::unique_ptr<lifetime_monitor>
+{
+  explicit
+  lifetime_monitor_modifier(
+    std::unique_ptr<lifetime_monitor>&& p)
+  noexcept
+    : unique_ptr(std::move(p))
+  {}
+
+  template <typename ... T, bool b = sequence_set>
+  auto
+  in_sequence(T&& ... t)
+  -> lifetime_monitor_modifier<true>
+  {
+    static_assert(!b,
+                  "Multiple IN_SEQUENCE does not make sense."
+                  " You can list several sequence objects at once");
+    std::unique_ptr<lifetime_monitor>& m = *this;
+    m->set_sequence(std::forward<T>(t)...);
+    return lifetime_monitor_modifier<true>{std::move(m)};
+  }
+};
+
+struct lifetime_monitor_releaser
+{
+  template <bool b>
+  std::unique_ptr<trompeloeil::lifetime_monitor>
+  operator+(
+    lifetime_monitor_modifier<b>&& m)
+  const
+  {
+    return std::move(m);
+  }
+};
+
+}
+
+#define TROMPELOEIL_REQUIRE_DESTRUCTION(obj)                                   \
+  TROMPELOEIL_REQUIRE_DESTRUCTION_(obj, #obj)
+
+#define TROMPELOEIL_REQUIRE_DESTRUCTION_(obj, obj_s)                           \
+  std::unique_ptr<trompeloeil::expectation>                                    \
+    TROMPELOEIL_CONCAT(trompeloeil_death_monitor_, __LINE__)                   \
+    = TROMPELOEIL_NAMED_REQUIRE_DESTRUCTION_(,obj, obj_s)
+
+#define TROMPELOEIL_NAMED_REQUIRE_DESTRUCTION(obj)                             \
+  TROMPELOEIL_NAMED_REQUIRE_DESTRUCTION_("NAMED_", obj, #obj)
+
+#define TROMPELOEIL_NAMED_REQUIRE_DESTRUCTION_(prefix, obj, obj_s)             \
+  trompeloeil::lifetime_monitor_releaser{} +                                   \
+  trompeloeil::lifetime_monitor_modifier<false>{                               \
+    ::trompeloeil::detail::make_unique<trompeloeil::lifetime_monitor>(         \
+      obj,                                                                     \
+      obj_s,                                                                   \
+      prefix "REQUIRE_DESTRUCTION(" obj_s ")",                                 \
+      "destructor for " obj_s,                                                 \
+      ::trompeloeil::location{__FILE__,                                        \
+                              static_cast<unsigned long>(__LINE__)})           \
+  }
+
+#ifndef TROMPELOEIL_LONG_MACROS
+#define REQUIRE_DESTRUCTION       TROMPELOEIL_REQUIRE_DESTRUCTION
+#define NAMED_REQUIRE_DESTRUCTION TROMPELOEIL_NAMED_REQUIRE_DESTRUCTION
+#endif
+
+#endif //TROMPELOEIL_LIFETIME_HPP
diff --git a/include/trompeloeil/mock.hpp b/include/trompeloeil/mock.hpp
index c4d798e4..c2e8562a 100644
--- a/include/trompeloeil/mock.hpp
+++ b/include/trompeloeil/mock.hpp
@@ -348,12 +348,6 @@ namespace trompeloeil { using std::unique_lock; }
 
 #define TROMPELOEIL_PARAMS(num) TROMPELOEIL_CONCAT(TROMPELOEIL_PARAMS, num)
 
-#if defined(__cxx_rtti) || defined(__GXX_RTTI) || defined(_CPPRTTI)
-#  define TROMPELOEIL_TYPE_ID_NAME(x) typeid(x).name()
-#else
-#  define TROMPELOEIL_TYPE_ID_NAME(x) "object"
-#endif
-
 #if (TROMPELOEIL_CPLUSPLUS == 201103L)
 
 #define TROMPELOEIL_DECLTYPE_AUTO \
@@ -2779,37 +2773,6 @@ template <typename T>
                           std::array<sequence_matcher, N>> matchers;
   };
 
-  struct lifetime_monitor;
-
-  template <typename T>
-  class deathwatched : public T
-  {
-    static_assert(std::has_virtual_destructor<T>::value,
-                  "virtual destructor is a necessity for deathwatched to work");
-  public:
-    template <typename ... U,
-              typename = detail::enable_if_t<std::is_constructible<T,U...>::value>>
-    deathwatched(
-      U&& ...u)
-    noexcept(noexcept(T(std::declval<U>()...)))
-      : T(std::forward<U>(u)...)
-    {}
-
-    ~deathwatched() override;
-
-    trompeloeil::lifetime_monitor*&
-    trompeloeil_expect_death(
-      trompeloeil::lifetime_monitor* monitor)
-    const
-    noexcept
-    {
-      auto lock = get_lock();
-      trompeloeil_lifetime_monitor = monitor;
-      return trompeloeil_lifetime_monitor.leak();
-    }
-  private:
-    mutable null_on_move<trompeloeil::lifetime_monitor> trompeloeil_lifetime_monitor;
-  };
 
   struct expectation {
     virtual ~expectation() = default;
@@ -2817,100 +2780,6 @@ template <typename T>
     virtual bool is_saturated() const noexcept = 0;
   };
 
-  struct lifetime_monitor : public expectation
-  {
-    template <typename T>
-    lifetime_monitor(
-      ::trompeloeil::deathwatched<T> const &obj,
-      char const* obj_name_,
-      char const* invocation_name_,
-      char const* call_name_,
-      location loc_)
-    noexcept
-      : object_monitor(obj.trompeloeil_expect_death(this))
-      , loc(loc_)
-      , object_name(obj_name_)
-      , invocation_name(invocation_name_)
-      , call_name(call_name_)
-    {
-    }
-
-    bool is_satisfied() const noexcept override
-    {
-      return died;
-    }
-
-    bool is_saturated() const noexcept override
-    {
-      return died;
-    }
-
-    lifetime_monitor(lifetime_monitor const&) = delete;
-
-    ~lifetime_monitor() override
-    {
-      auto lock = get_lock();
-      if (!died)
-      {
-        std::ostringstream os;
-        os << "Object " << object_name << " is still alive";
-        send_report<specialized>(severity::nonfatal, loc, os.str());
-        object_monitor = nullptr; // prevent its death poking this cadaver
-      }
-    }
-
-    void
-    notify()
-    noexcept
-    {
-      died = true;
-      sequences->validate(severity::nonfatal, call_name, loc);
-
-      sequences->increment_call();
-      if (sequences->is_satisfied())
-      {
-        sequences->retire_predecessors();
-      }
-    }
-
-    template <typename ... T>
-    void
-    set_sequence(
-      T&& ... t)
-    {
-      using handler = sequence_handler<sizeof...(T)>;
-      auto seq = detail::make_unique<handler>(*sequences,
-                                              invocation_name,
-                                              loc,
-                                              std::forward<T>(t)...);
-      sequences = std::move(seq);
-    }
-  private:
-    atomic<bool>       died{false};
-    lifetime_monitor *&object_monitor;
-    location           loc;
-    char const        *object_name;
-    char const        *invocation_name;
-    char const        *call_name;
-    std::unique_ptr<sequence_handler_base>  sequences = detail::make_unique<sequence_handler<0>>();
-  };
-
-  template <typename T>
-  deathwatched<T>::~deathwatched()
-  {
-    auto lock = get_lock();
-    if (trompeloeil_lifetime_monitor)
-    {
-      trompeloeil_lifetime_monitor->notify();
-      return;
-    }
-    std::ostringstream os;
-    os << "Unexpected destruction of "
-       << TROMPELOEIL_TYPE_ID_NAME(T) << "@" << this << '\n';
-    send_report<specialized>(severity::nonfatal,
-                             location{},
-                             os.str());
-  }
 
   template <typename T>
   struct return_of;
@@ -4497,41 +4366,6 @@ template <typename T>
   {
   }
 
-  template <bool sequence_set>
-  struct lifetime_monitor_modifier : std::unique_ptr<lifetime_monitor>
-  {
-    explicit
-    lifetime_monitor_modifier(
-      std::unique_ptr<lifetime_monitor>&& p)
-    noexcept
-    : unique_ptr(std::move(p))
-    {}
-
-    template <typename ... T, bool b = sequence_set>
-    auto
-    in_sequence(T&& ... t)
-    -> lifetime_monitor_modifier<true>
-    {
-      static_assert(!b,
-                    "Multiple IN_SEQUENCE does not make sense."
-                      " You can list several sequence objects at once");
-      std::unique_ptr<lifetime_monitor>& m = *this;
-      m->set_sequence(std::forward<T>(t)...);
-      return lifetime_monitor_modifier<true>{std::move(m)};
-    }
-  };
-
-  struct lifetime_monitor_releaser
-  {
-    template <bool b>
-    std::unique_ptr<trompeloeil::lifetime_monitor>
-    operator+(
-      lifetime_monitor_modifier<b>&& m)
-    const
-    {
-      return std::move(m);
-    }
-  };
 
   template <bool movable, typename Sig>
   struct expectations
@@ -5523,28 +5357,6 @@ template <typename T>
 #define TROMPELOEIL_AT_LEAST(num) num, ~static_cast<size_t>(0)
 #define TROMPELOEIL_AT_MOST(num) 0, num
 
-#define TROMPELOEIL_REQUIRE_DESTRUCTION(obj)                                   \
-  TROMPELOEIL_REQUIRE_DESTRUCTION_(obj, #obj)
-
-#define TROMPELOEIL_REQUIRE_DESTRUCTION_(obj, obj_s)                           \
-  std::unique_ptr<trompeloeil::expectation>                                    \
-    TROMPELOEIL_CONCAT(trompeloeil_death_monitor_, __LINE__)                   \
-    = TROMPELOEIL_NAMED_REQUIRE_DESTRUCTION_(,obj, obj_s)
-
-#define TROMPELOEIL_NAMED_REQUIRE_DESTRUCTION(obj)                             \
-  TROMPELOEIL_NAMED_REQUIRE_DESTRUCTION_("NAMED_", obj, #obj)
-
-#define TROMPELOEIL_NAMED_REQUIRE_DESTRUCTION_(prefix, obj, obj_s)             \
-  trompeloeil::lifetime_monitor_releaser{} +                                   \
-  trompeloeil::lifetime_monitor_modifier<false>{                               \
-    ::trompeloeil::detail::make_unique<trompeloeil::lifetime_monitor>(         \
-      obj,                                                                     \
-      obj_s,                                                                   \
-      prefix "REQUIRE_DESTRUCTION(" obj_s ")",                                 \
-      "destructor for " obj_s,                                                 \
-      ::trompeloeil::location{__FILE__,                                        \
-                              static_cast<unsigned long>(__LINE__)})           \
-  }
 
 #ifndef TROMPELOEIL_LONG_MACROS
 #define MAKE_MOCK0                TROMPELOEIL_MAKE_MOCK0
@@ -5654,8 +5466,6 @@ template <typename T>
 #define ANY                       TROMPELOEIL_ANY
 #define AT_LEAST                  TROMPELOEIL_AT_LEAST
 #define AT_MOST                   TROMPELOEIL_AT_MOST
-#define REQUIRE_DESTRUCTION       TROMPELOEIL_REQUIRE_DESTRUCTION
-#define NAMED_REQUIRE_DESTRUCTION TROMPELOEIL_NAMED_REQUIRE_DESTRUCTION
 
 #endif // TROMPELOEIL_LONG_MACROS
 

From ac00a34ffe2f98202b9d6913ed709ce0d4230d34 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Fahller?= <bjorn@fahller.se>
Date: Sat, 4 Nov 2023 15:13:04 +0100
Subject: [PATCH 05/20] Break out stream_tracer.hpp

---
 docs/reference.md                     |  2 ++
 include/trompeloeil.hpp               |  1 +
 include/trompeloeil/mock.hpp          | 20 ------------------
 include/trompeloeil/stream_tracer.hpp | 29 +++++++++++++++++++++++++++
 4 files changed, 32 insertions(+), 20 deletions(-)
 create mode 100644 include/trompeloeil/stream_tracer.hpp

diff --git a/docs/reference.md b/docs/reference.md
index 90999673..ece9db72 100644
--- a/docs/reference.md
+++ b/docs/reference.md
@@ -2372,6 +2372,8 @@ matched calls to the
 it refers to. `stream_tracer` inherits from
 [`trompeloeil::tracer`](#tracer_type).
 
+`#include <trompeloeil/stream_tracer.hpp>`
+
 ```Cpp
 namespace trompeloeil {
 class stream_tracer : public ::trompeloeil::tracer
diff --git a/include/trompeloeil.hpp b/include/trompeloeil.hpp
index e454cf95..f645d18a 100644
--- a/include/trompeloeil.hpp
+++ b/include/trompeloeil.hpp
@@ -30,5 +30,6 @@
 #include "trompeloeil/lifetime.hpp"
 #include "trompeloeil/matcher/compare.hpp"
 #include "trompeloeil/matcher/re.hpp"
+#include "trompeloeil/stream_tracer.hpp"
 
 #endif // include guard
diff --git a/include/trompeloeil/mock.hpp b/include/trompeloeil/mock.hpp
index c2e8562a..0ba6f79b 100644
--- a/include/trompeloeil/mock.hpp
+++ b/include/trompeloeil/mock.hpp
@@ -1014,26 +1014,6 @@ using coro_value_type_t = typename coro_value_type<T>::type;
     tracer* previous = set_tracer(this);
   };
 
-  class stream_tracer : public tracer
-  {
-  public:
-    explicit
-    stream_tracer(
-      std::ostream& stream_)
-      : stream(stream_) {}
-    void
-    trace(
-      char const *file,
-      unsigned long line,
-      std::string const &call)
-      override
-    {
-      stream << location{file, line} << '\n' << call << '\n';
-    }
-  private:
-    std::ostream& stream;
-  };
-
   class trace_agent;
 
   template <typename T>
diff --git a/include/trompeloeil/stream_tracer.hpp b/include/trompeloeil/stream_tracer.hpp
new file mode 100644
index 00000000..7cbf5b63
--- /dev/null
+++ b/include/trompeloeil/stream_tracer.hpp
@@ -0,0 +1,29 @@
+#ifndef TROMPELOEIL_STREAM_TRACER_HPP
+#define TROMPELOEIL_STREAM_TRACER_HPP
+
+#include "mock.hpp"
+
+namespace trompeloeil {
+
+class stream_tracer : public tracer
+{
+public:
+  explicit
+  stream_tracer(
+    std::ostream& stream_)
+    : stream(stream_) {}
+  void
+  trace(
+    char const *file,
+    unsigned long line,
+    std::string const &call)
+  override
+  {
+    stream << location{file, line} << '\n' << call << '\n';
+  }
+private:
+  std::ostream& stream;
+};
+
+}
+#endif //TROMPELOEIL_STREAM_TRACER_HPP

From dc7d5e67ef0baa42d4eb1566d0763b26a0bd380e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Fahller?= <bjorn@fahller.se>
Date: Sat, 4 Nov 2023 15:41:33 +0100
Subject: [PATCH 06/20] Break out not.hpp

---
 docs/reference.md                   |  6 ++-
 include/trompeloeil.hpp             |  1 +
 include/trompeloeil/matcher/not.hpp | 80 +++++++++++++++++++++++++++++
 include/trompeloeil/mock.hpp        | 58 ++-------------------
 test/compiling_tests_11.cpp         |  2 +-
 test/compiling_tests_14.cpp         |  2 +-
 6 files changed, 90 insertions(+), 59 deletions(-)
 create mode 100644 include/trompeloeil/matcher/not.hpp

diff --git a/docs/reference.md b/docs/reference.md
index ece9db72..0fde0812 100644
--- a/docs/reference.md
+++ b/docs/reference.md
@@ -16,7 +16,7 @@
     - [**`le(`** *value* **`)`**](#le)
     - [**`re(`** *string* **`)`**](#re)
     - [**`*`** *matcher*](#deref_matcher)
-    - [**`!`** *matcher*](#negate_matcher)
+    - [**`!`** *matcher*](#not_matcher)
 - [Macros](#macros) (alphabetical order)
   - [**`ALLOW_CALL(`** *mock_object*, *func_name*(*parameter_list*)**`)`**](#ALLOW_CALL)
   - [**`ANY(`** *type* **`)`**](#ANY_MACRO)
@@ -629,12 +629,14 @@ TEST(atest)
 Above, `test_function(&mock_obj)` must call `mock_obj.func()` with a pointer
 to the value `3`.
 
-#### <A name="negate_matcher"/>**`!`** *matcher*
+#### <A name="not_matcher"/>**`!`** *matcher*
 
 Used in the parameter list of an [expectation](#expectation) together with a
 matcher, to negate a matcher, i.e. to fail what the matcher allows, and to
 allow what the matcher fails.
 
+`#include <trompeloeil/matcher/not.hpp>`
+
 Example:
 
 ```Cpp
diff --git a/include/trompeloeil.hpp b/include/trompeloeil.hpp
index f645d18a..552f5b43 100644
--- a/include/trompeloeil.hpp
+++ b/include/trompeloeil.hpp
@@ -29,6 +29,7 @@
 #include "trompeloeil/mock.hpp"
 #include "trompeloeil/lifetime.hpp"
 #include "trompeloeil/matcher/compare.hpp"
+#include "trompeloeil/matcher/not.hpp"
 #include "trompeloeil/matcher/re.hpp"
 #include "trompeloeil/stream_tracer.hpp"
 
diff --git a/include/trompeloeil/matcher/not.hpp b/include/trompeloeil/matcher/not.hpp
new file mode 100644
index 00000000..2731621c
--- /dev/null
+++ b/include/trompeloeil/matcher/not.hpp
@@ -0,0 +1,80 @@
+/*
+ * Trompeloeil C++ mocking framework
+ *
+ * Copyright (C) Björn Fahller
+ * Copyright (C) Andrew Paxie
+ *
+ *  Use, modification and distribution is subject to the
+ *  Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy atl
+ *  http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * Project home: https://github.com/rollbear/trompeloeil
+ */
+
+#ifndef TROMPELOEIL_NOT_HPP
+#define TROMPELOEIL_NOT_HPP
+
+#include "../mock.hpp"
+
+namespace trompeloeil
+{
+
+template <typename M>
+class not_matcher : public matcher
+{
+public:
+  template <typename U,
+    typename = decltype(can_match_parameter<detail::remove_reference_t<decltype(std::declval<U>())>>(std::declval<M>()))>
+  operator U() const { return {}; }
+
+  template <typename U>
+  explicit
+  not_matcher(
+    U&& m_)
+    : m( std::forward<U>(m_) )
+  {}
+
+  template <typename U>
+  bool
+  matches(
+    const U& u)
+  const
+  noexcept(noexcept(!std::declval<M>().matches(u)))
+  {
+    return !m.matches(u);
+  }
+
+  friend
+  std::ostream&
+  operator<<(
+    std::ostream& os,
+    not_matcher<M> const& p)
+  {
+    return os << p.m;
+  }
+  friend
+  std::string
+  param_name_prefix(
+    const not_matcher*)
+  {
+    return "not " + param_name_prefix(static_cast<M*>(nullptr));
+  }
+
+private:
+  M m;
+};
+
+
+template <typename M,
+  typename = detail::enable_if_t<::trompeloeil::is_matcher<M>::value>>
+inline
+::trompeloeil::not_matcher<detail::decay_t<M>>
+operator!(
+  M&& m)
+{
+  return ::trompeloeil::not_matcher<detail::decay_t<M>>{std::forward<M>(m)};
+}
+
+}
+#endif //TROMPELOEIL_NOT_HPP
diff --git a/include/trompeloeil/mock.hpp b/include/trompeloeil/mock.hpp
index 0ba6f79b..f0441fba 100644
--- a/include/trompeloeil/mock.hpp
+++ b/include/trompeloeil/mock.hpp
@@ -2244,42 +2244,6 @@ template <typename T>
     M m;
   };
 
-  template <typename M>
-  class neg_matcher : public matcher
-  {
-  public:
-    template <typename U,
-              typename = decltype(can_match_parameter<detail::remove_reference_t<decltype(std::declval<U>())>>(std::declval<M>()))>
-    operator U() const { return {}; }
-
-    template <typename U>
-    explicit
-    neg_matcher(
-      U&& m_)
-      : m( std::forward<U>(m_) )
-    {}
-
-    template <typename U>
-    bool
-    matches(
-      const U& u)
-    const
-    noexcept(noexcept(!std::declval<M>().matches(u)))
-    {
-      return !m.matches(u);
-    }
-
-    friend
-    std::ostream&
-    operator<<(
-      std::ostream& os,
-      neg_matcher<M> const& p)
-    {
-      return os << p.m;
-    }
-  private:
-    M m;
-  };
 
   template <typename MatchType, typename Predicate, typename ... ActualType>
   struct matcher_kind
@@ -2456,16 +2420,9 @@ template <typename T>
   param_name_prefix(
     const ptr_deref<M>*)
   {
-    return "*" + ::trompeloeil::param_name_prefix(static_cast<M*>(nullptr));
+    return "*" + param_name_prefix(static_cast<M*>(nullptr));
   }
 
-  template <typename M>
-  std::string
-  param_name_prefix(
-    const neg_matcher<M>*)
-  {
-    return "not " + ::trompeloeil::param_name_prefix(static_cast<M*>(nullptr));
-  }
 
   template <typename T>
   struct null_on_move
@@ -2992,7 +2949,7 @@ template <typename T>
   {
     if (!::trompeloeil::param_matches(v, p))
     {
-      auto prefix = ::trompeloeil::param_name_prefix(&v) + "_";
+      auto prefix = param_name_prefix(&v) + "_";
       os << "  Expected " << std::setw((num < 9) ? 2 : 1) << prefix << num+1;
       ::trompeloeil::print_expectation(os, v);
     }
@@ -3024,7 +2981,7 @@ template <typename T>
     int i,
     T const& t)
   {
-    auto prefix = ::trompeloeil::param_name_prefix(&t) + "_";
+    auto prefix = param_name_prefix(&t) + "_";
     os << "  param " << std::setw((i < 9) ? 2 : 1) << prefix << i + 1
        << ::trompeloeil::param_compare_operator(&t);
     ::trompeloeil::print(os, t);
@@ -4444,15 +4401,6 @@ template <typename T>
     return ::trompeloeil::ptr_deref<detail::decay_t<M>>{std::forward<M>(m)};
   }
 
-  template <typename M,
-            typename = detail::enable_if_t<::trompeloeil::is_matcher<M>::value>>
-  inline
-  ::trompeloeil::neg_matcher<detail::decay_t<M>>
-  operator!(
-    M&& m)
-  {
-    return ::trompeloeil::neg_matcher<detail::decay_t<M>>{std::forward<M>(m)};
-  }
 
   /*
    * Convert the signature S of a mock function to the signature of
diff --git a/test/compiling_tests_11.cpp b/test/compiling_tests_11.cpp
index e91cc651..4bbcff12 100644
--- a/test/compiling_tests_11.cpp
+++ b/test/compiling_tests_11.cpp
@@ -3470,7 +3470,7 @@ Tried obj.overload\(trompeloeil::re<std::string const&>\("end\$", std::regex_con
 
 #endif /* TROMPELOEIL_TEST_REGEX_BOL_EOL_FAILURES */
 
-// tests of parameter matching using neg_matcher
+// tests of parameter matching using not_matcher
 
 
 TEST_CASE_METHOD(
diff --git a/test/compiling_tests_14.cpp b/test/compiling_tests_14.cpp
index 07856a9e..849ddb9f 100644
--- a/test/compiling_tests_14.cpp
+++ b/test/compiling_tests_14.cpp
@@ -2875,7 +2875,7 @@ Tried obj.overload\(trompeloeil::re<std::string const&>\("end\$", std::regex_con
 
 #endif /* TROMPELOEIL_TEST_REGEX_BOL_EOL_FAILURES */
 
-// tests of parameter matching using neg_matcher
+// tests of parameter matching using not_matcher
 
 TEST_CASE_METHOD(
   Fixture,

From b59e33b4193ab3ea79838a5b27bcd4a066541491 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Fahller?= <bjorn@fahller.se>
Date: Sat, 4 Nov 2023 16:45:34 +0100
Subject: [PATCH 07/20] Break out deref.hpp

---
 docs/reference.md                     |  2 +
 include/trompeloeil.hpp               |  1 +
 include/trompeloeil/matcher/deref.hpp | 81 +++++++++++++++++++++++++++
 include/trompeloeil/mock.hpp          | 56 ------------------
 4 files changed, 84 insertions(+), 56 deletions(-)
 create mode 100644 include/trompeloeil/matcher/deref.hpp

diff --git a/docs/reference.md b/docs/reference.md
index 0fde0812..81cd920f 100644
--- a/docs/reference.md
+++ b/docs/reference.md
@@ -609,6 +609,8 @@ matcher, to match a value pointed to by a pointer. A
 [`nullptr`](http://en.cppreference.com/w/cpp/language/nullptr) value fails the
 matcher.
 
+`#include <trompeloeil/matcher/deref.hpp>`
+
 Example:
 
 ```Cpp
diff --git a/include/trompeloeil.hpp b/include/trompeloeil.hpp
index 552f5b43..99f0c438 100644
--- a/include/trompeloeil.hpp
+++ b/include/trompeloeil.hpp
@@ -29,6 +29,7 @@
 #include "trompeloeil/mock.hpp"
 #include "trompeloeil/lifetime.hpp"
 #include "trompeloeil/matcher/compare.hpp"
+#include "trompeloeil/matcher/deref.hpp"
 #include "trompeloeil/matcher/not.hpp"
 #include "trompeloeil/matcher/re.hpp"
 #include "trompeloeil/stream_tracer.hpp"
diff --git a/include/trompeloeil/matcher/deref.hpp b/include/trompeloeil/matcher/deref.hpp
new file mode 100644
index 00000000..6385f8bc
--- /dev/null
+++ b/include/trompeloeil/matcher/deref.hpp
@@ -0,0 +1,81 @@
+/*
+ * Trompeloeil C++ mocking framework
+ *
+ * Copyright (C) Björn Fahller
+ * Copyright (C) Andrew Paxie
+ *
+ *  Use, modification and distribution is subject to the
+ *  Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy atl
+ *  http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * Project home: https://github.com/rollbear/trompeloeil
+ */
+
+
+#ifndef TROMPELOEIL_DEREF_HPP
+#define TROMPELOEIL_DEREF_HPP
+
+#include "../mock.hpp"
+
+namespace trompeloeil {
+
+template <typename M>
+class ptr_deref : public matcher
+{
+public:
+  template <typename U,
+    typename = decltype(can_match_parameter<detail::remove_reference_t<decltype(*std::declval<U>())>>(std::declval<M>()))>
+  operator U() const;
+
+  template <typename U>
+  explicit
+  ptr_deref(
+    U&& m_)
+    : m( std::forward<U>(m_) )
+  {}
+
+  template <typename U>
+  bool
+  matches(
+    const U& u)
+  const
+  noexcept(noexcept(std::declval<M>().matches(*u)))
+  {
+    return (u != nullptr) && m.matches(*u);
+  }
+
+  friend
+  std::ostream&
+  operator<<(
+    std::ostream& os,
+    ptr_deref<M> const& p)
+  {
+    return os << p.m;
+  }
+  friend
+  std::string
+  param_name_prefix(
+    const ptr_deref*)
+  {
+    return "*" + param_name_prefix(static_cast<M*>(nullptr));
+  }
+
+private:
+  M m;
+};
+
+
+template <typename M,
+  typename = detail::enable_if_t<::trompeloeil::is_matcher<M>::value>>
+inline
+::trompeloeil::ptr_deref<detail::decay_t<M>>
+operator*(
+  M&& m)
+{
+  return ::trompeloeil::ptr_deref<detail::decay_t<M>>{std::forward<M>(m)};
+}
+
+
+}
+#endif //TROMPELOEIL_DEREF_HPP
diff --git a/include/trompeloeil/mock.hpp b/include/trompeloeil/mock.hpp
index f0441fba..9bdcbd82 100644
--- a/include/trompeloeil/mock.hpp
+++ b/include/trompeloeil/mock.hpp
@@ -2207,42 +2207,6 @@ template <typename T>
   template <typename T>
   void can_match_parameter(T&&);
 
-  template <typename M>
-  class ptr_deref : public matcher
-  {
-  public:
-    template <typename U,
-              typename = decltype(can_match_parameter<detail::remove_reference_t<decltype(*std::declval<U>())>>(std::declval<M>()))>
-    operator U() const;
-
-    template <typename U>
-    explicit
-    ptr_deref(
-      U&& m_)
-      : m( std::forward<U>(m_) )
-    {}
-
-    template <typename U>
-    bool
-    matches(
-      const U& u)
-    const
-    noexcept(noexcept(std::declval<M>().matches(*u)))
-    {
-      return (u != nullptr) && m.matches(*u);
-    }
-
-    friend
-    std::ostream&
-    operator<<(
-      std::ostream& os,
-      ptr_deref<M> const& p)
-    {
-      return os << p.m;
-    }
-  private:
-    M m;
-  };
 
 
   template <typename MatchType, typename Predicate, typename ... ActualType>
@@ -2415,15 +2379,6 @@ template <typename T>
     return "";
   }
 
-  template <typename M>
-  std::string
-  param_name_prefix(
-    const ptr_deref<M>*)
-  {
-    return "*" + param_name_prefix(static_cast<M*>(nullptr));
-  }
-
-
   template <typename T>
   struct null_on_move
   {
@@ -4391,17 +4346,6 @@ template <typename T>
                                    tag,
                                    matcher_info<sig>>;
 
-  template <typename M,
-            typename = detail::enable_if_t<::trompeloeil::is_matcher<M>::value>>
-  inline
-  ::trompeloeil::ptr_deref<detail::decay_t<M>>
-  operator*(
-    M&& m)
-  {
-    return ::trompeloeil::ptr_deref<detail::decay_t<M>>{std::forward<M>(m)};
-  }
-
-
   /*
    * Convert the signature S of a mock function to the signature of
    * a member function of class T that takes the same parameters P

From 03a88ba9af0f4939a2c1b97944a522471e467837 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Fahller?= <bjorn@fahller.se>
Date: Sat, 4 Nov 2023 17:34:57 +0100
Subject: [PATCH 08/20] Move C++11 workarounds into separate header

---
 include/trompeloeil/cpp11_shenanigans.hpp | 376 +++++++++++++++++++++
 include/trompeloeil/mock.hpp              | 384 +---------------------
 2 files changed, 387 insertions(+), 373 deletions(-)
 create mode 100644 include/trompeloeil/cpp11_shenanigans.hpp

diff --git a/include/trompeloeil/cpp11_shenanigans.hpp b/include/trompeloeil/cpp11_shenanigans.hpp
new file mode 100644
index 00000000..585d3fb8
--- /dev/null
+++ b/include/trompeloeil/cpp11_shenanigans.hpp
@@ -0,0 +1,376 @@
+/*
+ * Trompeloeil C++ mocking framework
+ *
+ * Copyright (C) Björn Fahller
+ * Copyright (C) Andrew Paxie
+ *
+ *  Use, modification and distribution is subject to the
+ *  Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy atl
+ *  http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * Project home: https://github.com/rollbear/trompeloeil
+ */
+
+#ifndef TROMPELOEIL_CPP11_SHENANIGANS_HPP
+#define TROMPELOEIL_CPP11_SHENANIGANS_HPP
+
+namespace trompeloeil {
+namespace detail
+{
+template <typename T>
+struct unwrap_type
+{
+  using type = T;
+};
+template <typename T>
+struct unwrap_type<std::reference_wrapper<T>>
+{
+using type = T&;
+};
+template <typename ... Ts>
+std::tuple<typename unwrap_type<typename std::decay<Ts>::type>::type...>
+make_tuple(Ts&& ... ts)
+{
+  return { std::forward<Ts>(ts)... };
+}
+
+/* Implement C++14 features using only C++11 entities. */
+
+/* <memory> */
+
+/* Implementation of make_unique is from
+ *
+ * Stephan T. Lavavej, "make_unique (Revision 1),"
+ * ISO/IEC JTC1 SC22 WG21 N3656, 18 April 2013.
+ * Available: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3656.htm
+ * Accessed: 14 June 2017
+ *
+ * Renamed types to avoid the use of reserved identifiers.
+ */
+template <class T>
+struct unique_if
+{
+  typedef std::unique_ptr<T> single_object;
+};
+
+template <class T>
+struct unique_if<T[]>
+{
+  typedef std::unique_ptr<T[]> unknown_bound;
+};
+
+template <class T, size_t N>
+struct unique_if<T[N]>
+{
+  typedef void known_bound;
+};
+
+template <class T, class... Args>
+typename unique_if<T>::single_object
+make_unique(Args&&... args)
+{
+  return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+}
+
+template <class T>
+typename unique_if<T>::unknown_bound
+make_unique(size_t n)
+{
+  typedef typename std::remove_extent<T>::type U;
+  return std::unique_ptr<T>(new U[n]());
+}
+
+template <class T, class... Args>
+typename unique_if<T>::known_bound
+make_unique(Args&&...) = delete;
+
+/* <type_traits> */
+
+/* The implementation of these is from
+ *
+ * Walter E. Brown, "TransformationTraits Redux, v2,"
+ * ISO/IEC JTC1 SC22 WG21 N3655, 18 April 2013.
+ * Available: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3655.pdf
+ * Accessed: 2 November 2017
+ *
+ * Minor changes to capitalize template parameter `bool B` has been made.
+ *
+ * See also:
+ * http://en.cppreference.com/w/cpp/types/conditional
+ * http://en.cppreference.com/w/cpp/types/decay
+ * http://en.cppreference.com/w/cpp/types/enable_if
+ * http://en.cppreference.com/w/cpp/types/remove_pointer
+ * http://en.cppreference.com/w/cpp/types/remove_reference
+ * Accessed: 17 May 2017
+ */
+template <bool B, typename T, typename F>
+using conditional_t = typename std::conditional<B, T, F>::type;
+
+template <typename T>
+using decay_t = typename std::decay<T>::type;
+
+template <bool B, typename T = void>
+using enable_if_t = typename std::enable_if<B, T>::type;
+
+template <typename T>
+using remove_pointer_t = typename std::remove_pointer<T>::type;
+
+template <typename T>
+using remove_reference_t = typename std::remove_reference<T>::type;
+
+/* <utility> */
+
+/* This implementation of exchange is from
+ *
+ * Jeffrey Yasskin, "exchange() utility function, revision 3,"
+ * ISO/IEC JTC1 SC22 WG21 N3688, 19 April 2013.
+ * Available: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3668.html
+ * Accessed: 2 November 2017
+ *
+ * See also:
+ * http://en.cppreference.com/w/cpp/utility/exchange
+ * Accessed: 17 May 2017
+ */
+template<class T, class U = T>
+inline
+T
+exchange(
+  T& obj,
+  U&& new_value)
+{
+  T old_value = std::move(obj);
+  obj = std::forward<U>(new_value);
+  return old_value;
+}
+
+/* integer_sequence and index_sequence implementations are from
+ *
+ * Jonathan Wakely, "Compile-time integer sequences,"
+ * ISO/IEC JTC1 SC22 WG21 N3658, 18 April 2013.
+ * Available: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3658.html
+ * Accessed: 2 November 2017
+ *
+ * See also:
+ * http://en.cppreference.com/w/cpp/utility/integer_sequence
+ * Accessed: 17 May 2017
+ */
+template <typename T, T... I>
+struct integer_sequence
+{
+  // Replaces a typedef used in the definition found in N3658.
+  using value_type = T;
+
+  static constexpr size_t size() noexcept
+  {
+    return sizeof...(I);
+  }
+};
+
+template <size_t... I>
+using index_sequence = integer_sequence<size_t, I...>;
+
+/* This implementation of make_integer_sequence is from boost/mp11,
+ *
+ * Copyright 2015, 2017 Peter Dimov
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ *
+ * Implemented here:
+ *
+ * https://github.com/pdimov/mp11/blob/master/include/boost/
+ *   integer_sequence.hpp
+ * Accessed: 17 May 2017
+ *
+ * (now missing) and here:
+ *
+ * https://github.com/boostorg/mp11/blob/develop/include/boost/
+ *   mp11/integer_sequence.hpp
+ * Accessed: 13 August 2017
+ */
+namespace impl
+{
+// iseq_if_c
+template <bool C, class T, class E>
+struct iseq_if_c_impl;
+
+template <class T, class E>
+struct iseq_if_c_impl<true, T, E>
+{
+  using type = T;
+};
+
+template <class T, class E>
+struct iseq_if_c_impl<false, T, E>
+{
+  using type = E;
+};
+
+template <bool C, class T, class E>
+using iseq_if_c = typename iseq_if_c_impl<C, T, E>::type;
+
+// iseq_identity
+template <class T>
+struct iseq_identity
+{
+  using type = T;
+};
+
+template <class S1, class S2>
+struct append_integer_sequence;
+
+template <class T, T... I, T... J>
+struct append_integer_sequence<integer_sequence<T, I...>, integer_sequence<T, J...>>
+{
+  using type = integer_sequence<T, I..., ( J + sizeof...(I) )...>;
+};
+
+template <class T, T N>
+struct make_integer_sequence_impl;
+
+template <class T, T N>
+struct make_integer_sequence_impl_
+{
+private:
+
+  static_assert( N >= 0, "make_integer_sequence<T, N>: N must not be negative" );
+
+  static T const M = N / 2;
+  static T const R = N % 2;
+
+  using S1 = typename make_integer_sequence_impl<T, M>::type;
+  using S2 = typename append_integer_sequence<S1, S1>::type;
+  using S3 = typename make_integer_sequence_impl<T, R>::type;
+  using S4 = typename append_integer_sequence<S2, S3>::type;
+
+public:
+
+  using type = S4;
+};
+
+template <class T, T N>
+struct make_integer_sequence_impl:
+  iseq_if_c<N == 0,
+    iseq_identity<integer_sequence<T>>,
+    iseq_if_c<N == 1,
+      iseq_identity<integer_sequence<T, 0>>,
+      make_integer_sequence_impl_<T, N>>>
+{
+};
+}
+
+template<class T, T N>
+using make_integer_sequence = typename impl::make_integer_sequence_impl<T, N>::type;
+
+template <size_t N>
+using make_index_sequence = make_integer_sequence<size_t, N>;
+
+template <typename... T>
+using index_sequence_for = make_index_sequence<sizeof...(T)>;
+
+} /* namespace detail */
+
+}
+
+#define TROMPELOEIL_WITH_(capture, arg_s, ...)                                 \
+  with(                                                                        \
+    arg_s,                                                                     \
+    [capture]                                                                  \
+    (typename trompeloeil_e_t::trompeloeil_call_params_type_t const& trompeloeil_x)\
+    {                                                                          \
+      auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                      \
+      auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                      \
+      auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                      \
+      auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                      \
+      auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                      \
+      auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                      \
+      auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                      \
+      auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                      \
+      auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                      \
+      auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                     \
+      auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                     \
+      auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                     \
+      auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                     \
+      auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                     \
+      auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                     \
+      ::trompeloeil::ignore(                                                   \
+        _1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15);                   \
+      return __VA_ARGS__;                                                      \
+    })
+
+#define TROMPELOEIL_SIDE_EFFECT_(capture, ...)                                 \
+  sideeffect(                                                                  \
+    [capture]                                                                  \
+    (typename trompeloeil_e_t::trompeloeil_call_params_type_t& trompeloeil_x)  \
+    {                                                                          \
+      auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                      \
+      auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                      \
+      auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                      \
+      auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                      \
+      auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                      \
+      auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                      \
+      auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                      \
+      auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                      \
+      auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                      \
+      auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                     \
+      auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                     \
+      auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                     \
+      auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                     \
+      auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                     \
+      auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                     \
+      ::trompeloeil::ignore(                                                   \
+        _1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15);                   \
+      __VA_ARGS__;                                                             \
+    })
+
+#define TROMPELOEIL_RETURN_(capture, ...)                                      \
+  handle_return(                                                               \
+    [capture]                                                                  \
+    (typename trompeloeil_e_t::trompeloeil_call_params_type_t& trompeloeil_x)  \
+      -> typename trompeloeil_e_t::trompeloeil_return_of_t                     \
+    {                                                                          \
+      auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                      \
+      auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                      \
+      auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                      \
+      auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                      \
+      auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                      \
+      auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                      \
+      auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                      \
+      auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                      \
+      auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                      \
+      auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                     \
+      auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                     \
+      auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                     \
+      auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                     \
+      auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                     \
+      auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                     \
+      ::trompeloeil::ignore(                                                   \
+        _1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15);                   \
+      return ::trompeloeil::decay_return_type(__VA_ARGS__);                    \
+    })
+#define TROMPELOEIL_THROW_(capture, ...)                                       \
+  handle_throw(                                                                \
+    [capture]                                                                  \
+    (typename trompeloeil_e_t::trompeloeil_call_params_type_t& trompeloeil_x)  \
+    {                                                                          \
+      auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                      \
+      auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                      \
+      auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                      \
+      auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                      \
+      auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                      \
+      auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                      \
+      auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                      \
+      auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                      \
+      auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                      \
+      auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                     \
+      auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                     \
+      auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                     \
+      auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                     \
+      auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                     \
+      auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                     \
+      ::trompeloeil::ignore(                                                   \
+        _1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15);                   \
+      throw __VA_ARGS__;                                                       \
+    })
+
+#endif //TROMPELOEIL_CPP11_SHENANIGANS_HPP
diff --git a/include/trompeloeil/mock.hpp b/include/trompeloeil/mock.hpp
index 9bdcbd82..7c6145d4 100644
--- a/include/trompeloeil/mock.hpp
+++ b/include/trompeloeil/mock.hpp
@@ -417,265 +417,13 @@ namespace trompeloeil
 
   template <template <typename ...> class D, typename ... Ts>
   using is_detected = typename is_detected_<D, void, Ts...>::type;
-
+}
 # if (TROMPELOEIL_CPLUSPLUS == 201103L)
 
-  namespace detail
-  {
-    template <typename T>
-    struct unwrap_type
-    {
-      using type = T;
-    };
-    template <typename T>
-    struct unwrap_type<std::reference_wrapper<T>>
-    {
-      using type = T&;
-    };
-    template <typename ... Ts>
-    std::tuple<typename unwrap_type<typename std::decay<Ts>::type>::type...>
-    make_tuple(Ts&& ... ts)
-    {
-      return { std::forward<Ts>(ts)... };
-    }
-
-    /* Implement C++14 features using only C++11 entities. */
-
-    /* <memory> */
-
-    /* Implementation of make_unique is from
-     *
-     * Stephan T. Lavavej, "make_unique (Revision 1),"
-     * ISO/IEC JTC1 SC22 WG21 N3656, 18 April 2013.
-     * Available: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3656.htm
-     * Accessed: 14 June 2017
-     *
-     * Renamed types to avoid the use of reserved identifiers.
-     */
-    template <class T>
-    struct unique_if
-    {
-      typedef std::unique_ptr<T> single_object;
-    };
-
-    template <class T>
-    struct unique_if<T[]>
-    {
-      typedef std::unique_ptr<T[]> unknown_bound;
-    };
-
-    template <class T, size_t N>
-    struct unique_if<T[N]>
-    {
-      typedef void known_bound;
-    };
-
-    template <class T, class... Args>
-    typename unique_if<T>::single_object
-    make_unique(Args&&... args)
-    {
-      return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
-    }
-
-    template <class T>
-    typename unique_if<T>::unknown_bound
-    make_unique(size_t n)
-    {
-      typedef typename std::remove_extent<T>::type U;
-      return std::unique_ptr<T>(new U[n]());
-    }
-
-    template <class T, class... Args>
-    typename unique_if<T>::known_bound
-    make_unique(Args&&...) = delete;
-
-    /* <type_traits> */
-
-    /* The implementation of these is from
-     *
-     * Walter E. Brown, "TransformationTraits Redux, v2,"
-     * ISO/IEC JTC1 SC22 WG21 N3655, 18 April 2013.
-     * Available: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3655.pdf
-     * Accessed: 2 November 2017
-     *
-     * Minor changes to capitalize template parameter `bool B` has been made.
-     *
-     * See also:
-     * http://en.cppreference.com/w/cpp/types/conditional
-     * http://en.cppreference.com/w/cpp/types/decay
-     * http://en.cppreference.com/w/cpp/types/enable_if
-     * http://en.cppreference.com/w/cpp/types/remove_pointer
-     * http://en.cppreference.com/w/cpp/types/remove_reference
-     * Accessed: 17 May 2017
-     */
-    template <bool B, typename T, typename F>
-    using conditional_t = typename std::conditional<B, T, F>::type;
-
-    template <typename T>
-    using decay_t = typename std::decay<T>::type;
-
-    template <bool B, typename T = void>
-    using enable_if_t = typename std::enable_if<B, T>::type;
-
-    template <typename T>
-    using remove_pointer_t = typename std::remove_pointer<T>::type;
-
-    template <typename T>
-    using remove_reference_t = typename std::remove_reference<T>::type;
-
-    /* <utility> */
-
-    /* This implementation of exchange is from
-     *
-     * Jeffrey Yasskin, "exchange() utility function, revision 3,"
-     * ISO/IEC JTC1 SC22 WG21 N3688, 19 April 2013.
-     * Available: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3668.html
-     * Accessed: 2 November 2017
-     *
-     * See also:
-     * http://en.cppreference.com/w/cpp/utility/exchange
-     * Accessed: 17 May 2017
-     */
-    template<class T, class U = T>
-    inline
-    T
-    exchange(
-      T& obj,
-      U&& new_value)
-    {
-      T old_value = std::move(obj);
-      obj = std::forward<U>(new_value);
-      return old_value;
-    }
-
-    /* integer_sequence and index_sequence implementations are from
-     *
-     * Jonathan Wakely, "Compile-time integer sequences,"
-     * ISO/IEC JTC1 SC22 WG21 N3658, 18 April 2013.
-     * Available: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3658.html
-     * Accessed: 2 November 2017
-     *
-     * See also:
-     * http://en.cppreference.com/w/cpp/utility/integer_sequence
-     * Accessed: 17 May 2017
-     */
-    template <typename T, T... I>
-    struct integer_sequence
-    {
-      // Replaces a typedef used in the definition found in N3658.
-      using value_type = T;
-
-      static constexpr size_t size() noexcept
-      {
-          return sizeof...(I);
-      }
-    };
-
-    template <size_t... I>
-    using index_sequence = integer_sequence<size_t, I...>;
-
-    /* This implementation of make_integer_sequence is from boost/mp11,
-     *
-     * Copyright 2015, 2017 Peter Dimov
-     *
-     * Distributed under the Boost Software License, Version 1.0.
-     *
-     * Implemented here:
-     *
-     * https://github.com/pdimov/mp11/blob/master/include/boost/
-     *   integer_sequence.hpp
-     * Accessed: 17 May 2017
-     *
-     * (now missing) and here:
-     *
-     * https://github.com/boostorg/mp11/blob/develop/include/boost/
-     *   mp11/integer_sequence.hpp
-     * Accessed: 13 August 2017
-     */
-    namespace impl
-    {
-      // iseq_if_c
-      template <bool C, class T, class E>
-      struct iseq_if_c_impl;
-
-      template <class T, class E>
-      struct iseq_if_c_impl<true, T, E>
-      {
-        using type = T;
-      };
-
-      template <class T, class E>
-      struct iseq_if_c_impl<false, T, E>
-      {
-        using type = E;
-      };
-
-      template <bool C, class T, class E>
-      using iseq_if_c = typename iseq_if_c_impl<C, T, E>::type;
-
-      // iseq_identity
-      template <class T>
-      struct iseq_identity
-      {
-        using type = T;
-      };
-
-      template <class S1, class S2>
-      struct append_integer_sequence;
-
-      template <class T, T... I, T... J>
-      struct append_integer_sequence<integer_sequence<T, I...>, integer_sequence<T, J...>>
-      {
-        using type = integer_sequence<T, I..., ( J + sizeof...(I) )...>;
-      };
-
-      template <class T, T N>
-      struct make_integer_sequence_impl;
-
-      template <class T, T N>
-      struct make_integer_sequence_impl_
-      {
-      private:
-
-        static_assert( N >= 0, "make_integer_sequence<T, N>: N must not be negative" );
-
-        static T const M = N / 2;
-        static T const R = N % 2;
-
-        using S1 = typename make_integer_sequence_impl<T, M>::type;
-        using S2 = typename append_integer_sequence<S1, S1>::type;
-        using S3 = typename make_integer_sequence_impl<T, R>::type;
-        using S4 = typename append_integer_sequence<S2, S3>::type;
-
-      public:
-
-        using type = S4;
-      };
-
-      template <class T, T N>
-      struct make_integer_sequence_impl:
-        iseq_if_c<N == 0,
-          iseq_identity<integer_sequence<T>>,
-          iseq_if_c<N == 1,
-            iseq_identity<integer_sequence<T, 0>>,
-            make_integer_sequence_impl_<T, N>>>
-      {
-      };
-    }
-
-    template<class T, T N>
-    using make_integer_sequence = typename impl::make_integer_sequence_impl<T, N>::type;
-
-    template <size_t N>
-    using make_index_sequence = make_integer_sequence<size_t, N>;
-
-    template <typename... T>
-    using index_sequence_for = make_index_sequence<sizeof...(T)>;
-
-  } /* namespace detail */
+#include "cpp11_shenanigans.hpp"
 
 # else /* (TROMPELOEIL_CPLUSPLUS == 201103L) */
-
+namespace trompeloeil {
   /* Only these entities really need to
    * be available in namespace detail, but
    * VS 2015 has a problem with this approach.
@@ -701,9 +449,9 @@ namespace trompeloeil
    * Instead, use a namespace alias.
    */
   namespace detail = std;
-
+}
 # endif /* !(TROMPELOEIL_CPLUSPLUS == 201103L) */
-
+namespace trompeloeil {
 # if TROMPELOEIL_CPLUSPLUS >= 201703L
 #   if TROMPELOEIL_CLANG && TROMPELOEIL_CLANG_VERSION >= 60000
 
@@ -4912,35 +4660,7 @@ template <typename T>
 #define TROMPELOEIL_LR_WITH(...) TROMPELOEIL_WITH_(&,#__VA_ARGS__, __VA_ARGS__)
 
 
-#if (TROMPELOEIL_CPLUSPLUS == 201103L)
-
-#define TROMPELOEIL_WITH_(capture, arg_s, ...)                                 \
-  with(                                                                        \
-    arg_s,                                                                     \
-    [capture]                                                                  \
-    (typename trompeloeil_e_t::trompeloeil_call_params_type_t const& trompeloeil_x)\
-    {                                                                          \
-      auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                      \
-      auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                      \
-      auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                      \
-      auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                      \
-      auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                      \
-      auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                      \
-      auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                      \
-      auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                      \
-      auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                      \
-      auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                     \
-      auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                     \
-      auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                     \
-      auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                     \
-      auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                     \
-      auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                     \
-      ::trompeloeil::ignore(                                                   \
-        _1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15);                   \
-      return __VA_ARGS__;                                                      \
-    })
-
-#else /* (TROMPELOEIL_CPLUSPLUS == 201103L) */
+#if (TROMPELOEIL_CPLUSPLUS != 201103L)
 
 #define TROMPELOEIL_WITH_(capture, arg_s, ...)                                 \
   with(arg_s, [capture](auto const& trompeloeil_x) {                           \
@@ -4963,41 +4683,14 @@ template <typename T>
     return __VA_ARGS__;                                                        \
   })
 
-#endif /* !(TROMPELOEIL_CPLUSPLUS == 201103L) */
+#endif /* !(TROMPELOEIL_CPLUSPLUS != 201103L) */
 
 
 #define TROMPELOEIL_SIDE_EFFECT(...)    TROMPELOEIL_SIDE_EFFECT_(=, __VA_ARGS__)
 #define TROMPELOEIL_LR_SIDE_EFFECT(...) TROMPELOEIL_SIDE_EFFECT_(&, __VA_ARGS__)
 
 
-#if (TROMPELOEIL_CPLUSPLUS == 201103L)
-
-#define TROMPELOEIL_SIDE_EFFECT_(capture, ...)                                 \
-  sideeffect(                                                                  \
-    [capture]                                                                  \
-    (typename trompeloeil_e_t::trompeloeil_call_params_type_t& trompeloeil_x)  \
-    {                                                                          \
-      auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                      \
-      auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                      \
-      auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                      \
-      auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                      \
-      auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                      \
-      auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                      \
-      auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                      \
-      auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                      \
-      auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                      \
-      auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                     \
-      auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                     \
-      auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                     \
-      auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                     \
-      auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                     \
-      auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                     \
-      ::trompeloeil::ignore(                                                   \
-        _1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15);                   \
-      __VA_ARGS__;                                                             \
-    })
-
-#else /* (TROMPELOEIL_CPLUSPLUS == 201103L) */
+#if (TROMPELOEIL_CPLUSPLUS != 201103L)
 
 #define TROMPELOEIL_SIDE_EFFECT_(capture, ...)                                 \
   sideeffect([capture](auto& trompeloeil_x) {                                  \
@@ -5027,35 +4720,7 @@ template <typename T>
 #define TROMPELOEIL_LR_RETURN(...) TROMPELOEIL_RETURN_(&, __VA_ARGS__)
 
 
-#if (TROMPELOEIL_CPLUSPLUS == 201103L)
-
-#define TROMPELOEIL_RETURN_(capture, ...)                                      \
-  handle_return(                                                               \
-    [capture]                                                                  \
-    (typename trompeloeil_e_t::trompeloeil_call_params_type_t& trompeloeil_x)  \
-      -> typename trompeloeil_e_t::trompeloeil_return_of_t                     \
-    {                                                                          \
-      auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                      \
-      auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                      \
-      auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                      \
-      auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                      \
-      auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                      \
-      auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                      \
-      auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                      \
-      auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                      \
-      auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                      \
-      auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                     \
-      auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                     \
-      auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                     \
-      auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                     \
-      auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                     \
-      auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                     \
-      ::trompeloeil::ignore(                                                   \
-        _1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15);                   \
-      return ::trompeloeil::decay_return_type(__VA_ARGS__);                    \
-    })
-
-#else /* (TROMPELOEIL_CPLUSPLUS == 201103L) */
+#if (TROMPELOEIL_CPLUSPLUS != 201103L)
 
 #define TROMPELOEIL_RETURN_(capture, ...)                                      \
   handle_return([capture](auto& trompeloeil_x) -> decltype(auto) {             \
@@ -5106,41 +4771,14 @@ template <typename T>
 
 #endif
 
-#endif /* !(TROMPELOEIL_CPLUSPLUS == 201103L) */
+#endif /* !(TROMPELOEIL_CPLUSPLUS != 201103L) */
 
 
 #define TROMPELOEIL_THROW(...)    TROMPELOEIL_THROW_(=, __VA_ARGS__)
 #define TROMPELOEIL_LR_THROW(...) TROMPELOEIL_THROW_(&, __VA_ARGS__)
 
 
-#if (TROMPELOEIL_CPLUSPLUS == 201103L)
-
-#define TROMPELOEIL_THROW_(capture, ...)                                       \
-  handle_throw(                                                                \
-    [capture]                                                                  \
-    (typename trompeloeil_e_t::trompeloeil_call_params_type_t& trompeloeil_x)  \
-    {                                                                          \
-      auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                      \
-      auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                      \
-      auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                      \
-      auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                      \
-      auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                      \
-      auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                      \
-      auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                      \
-      auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                      \
-      auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                      \
-      auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                     \
-      auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                     \
-      auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                     \
-      auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                     \
-      auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                     \
-      auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                     \
-      ::trompeloeil::ignore(                                                   \
-        _1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15);                   \
-      throw __VA_ARGS__;                                                       \
-    })
-
-#else /* (TROMPELOEIL_CPLUSPLUS == 201103L) */
+#if (TROMPELOEIL_CPLUSPLUS != 201103L)
 
 #define TROMPELOEIL_THROW_(capture, ...)                                       \
   handle_throw([capture](auto& trompeloeil_x)  {                               \

From 3f2d088b91434a7ac815a2ff3288f6d0e8f57980 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Fahller?= <bjorn@fahller.se>
Date: Sun, 5 Nov 2023 07:34:12 +0100
Subject: [PATCH 09/20] Move call_modifier actions out of member funcs

---
 include/trompeloeil/cpp11_shenanigans.hpp |   8 +-
 include/trompeloeil/mock.hpp              | 402 +++++++++++++---------
 2 files changed, 238 insertions(+), 172 deletions(-)

diff --git a/include/trompeloeil/cpp11_shenanigans.hpp b/include/trompeloeil/cpp11_shenanigans.hpp
index 585d3fb8..b6ac238f 100644
--- a/include/trompeloeil/cpp11_shenanigans.hpp
+++ b/include/trompeloeil/cpp11_shenanigans.hpp
@@ -273,7 +273,7 @@ using index_sequence_for = make_index_sequence<sizeof...(T)>;
 }
 
 #define TROMPELOEIL_WITH_(capture, arg_s, ...)                                 \
-  with(                                                                        \
+  template action<trompeloeil::with>(                                          \
     arg_s,                                                                     \
     [capture]                                                                  \
     (typename trompeloeil_e_t::trompeloeil_call_params_type_t const& trompeloeil_x)\
@@ -299,7 +299,7 @@ using index_sequence_for = make_index_sequence<sizeof...(T)>;
     })
 
 #define TROMPELOEIL_SIDE_EFFECT_(capture, ...)                                 \
-  sideeffect(                                                                  \
+  template action<trompeloeil::sideeffect>(                                    \
     [capture]                                                                  \
     (typename trompeloeil_e_t::trompeloeil_call_params_type_t& trompeloeil_x)  \
     {                                                                          \
@@ -324,7 +324,7 @@ using index_sequence_for = make_index_sequence<sizeof...(T)>;
     })
 
 #define TROMPELOEIL_RETURN_(capture, ...)                                      \
-  handle_return(                                                               \
+  template action<trompeloeil::handle_return>(                                 \
     [capture]                                                                  \
     (typename trompeloeil_e_t::trompeloeil_call_params_type_t& trompeloeil_x)  \
       -> typename trompeloeil_e_t::trompeloeil_return_of_t                     \
@@ -349,7 +349,7 @@ using index_sequence_for = make_index_sequence<sizeof...(T)>;
       return ::trompeloeil::decay_return_type(__VA_ARGS__);                    \
     })
 #define TROMPELOEIL_THROW_(capture, ...)                                       \
-  handle_throw(                                                                \
+  template action<trompeloeil::handle_throw>(                                  \
     [capture]                                                                  \
     (typename trompeloeil_e_t::trompeloeil_call_params_type_t& trompeloeil_x)  \
     {                                                                          \
diff --git a/include/trompeloeil/mock.hpp b/include/trompeloeil/mock.hpp
index 7c6145d4..54d7483d 100644
--- a/include/trompeloeil/mock.hpp
+++ b/include/trompeloeil/mock.hpp
@@ -534,6 +534,9 @@ namespace trompeloeil {
 template <typename T>
 using coro_value_type_t = typename coro_value_type<T>::type;
 
+#else
+  template <typename>
+  using is_coroutine = std::false_type;
 #endif
 
   template <typename T>
@@ -3175,6 +3178,62 @@ template <typename T>
     static bool const sequence_set = true;
   };
 
+#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
+  template <typename H, typename signature>
+    struct co_throw_handler_t
+    {
+      using R = decltype(default_return<return_of_t<signature>>());
+      using promise_value_type = trompeloeil::coro_value_type_t<R>;
+      explicit
+      co_throw_handler_t(H&& h_)
+        : h(std::move(h_))
+      {}
+
+      template <typename T>
+      promise_value_type operator()(T& p)
+      {
+        return ((void)h(p), trompeloeil::default_return<promise_value_type>());
+      }
+
+    private:
+      H h;
+    };
+#endif
+
+  template <typename H, typename signature>
+  struct throw_handler_t
+  {
+    using R = decltype(default_return<return_of_t<signature>>());
+
+    explicit
+    throw_handler_t(H&& h_)
+      : h(std::move(h_))
+    {}
+
+    template <typename T>
+    R operator()(T& p)
+    {
+      /* Work around VS 2017 15.7.x C4702 warning by
+       * enclosing the operation in an otherwise
+       * unnecessary try/catch block.
+       */
+      try
+      {
+        h(p);
+        abort();
+      }
+      catch (...)
+      {
+        throw;
+      }
+      return default_return<R>(); // unreachable code
+    }
+
+  private:
+    H h;
+  };
+
+
   template <typename Matcher, typename modifier_tag, typename Parent>
   struct call_modifier : public Parent
   {
@@ -3193,35 +3252,98 @@ template <typename T>
       : matcher{m}
     {}
 
-    template <typename D>
+    template <typename F, typename ... Ts>
+    auto action(Ts&& ... ts) &
+    -> decltype(F::action(*this, std::forward<Ts>(ts)...))
+    {
+        return F::action(*this, std::forward<Ts>(ts)...);
+    }
+    template <typename F, typename ... Ts>
+    auto action(Ts&& ... ts) const &
+    -> decltype(F::action(*this, std::forward<Ts>(ts)...))
+    {
+        return F::action(*this, std::forward<Ts>(ts)...);
+    }
+    template <typename F, typename ... Ts>
+    auto action(Ts&& ... ts) &&
+    -> decltype(F::action(std::move(*this), std::forward<Ts>(ts)...))
+    {
+        return F::action(std::move(*this), std::forward<Ts>(ts)...);
+    }
+    template <typename F, typename ... Ts>
+    auto action(Ts&& ... ts) const &&
+    -> decltype(F::action(std::move(*this), std::forward<Ts>(ts)...))
+    {
+        return F::action(std::move(*this), std::forward<Ts>(ts)...);
+    }
     call_modifier&&
-    with(
-      char const* str,
-      D&& d)
-    &&
+    null_modifier()
     {
-      matcher->add_condition(str, std::forward<D>(d));
       return std::move(*this);
     }
 
-    template <typename A>
+    template <typename ... T,
+              bool b = sequence_set>
+    call_modifier<Matcher, modifier_tag, sequence_injector<Parent>>
+    in_sequence(
+      T&& ... t)
+    {
+      static_assert(!b,
+                    "Multiple IN_SEQUENCE does not make sense."
+                    " You can list several sequence objects at once");
+
+      static_assert(upper_call_limit > 0,
+                    "IN_SEQUENCE for forbidden call does not make sense");
+
+      matcher->set_sequence(std::forward<T>(t)...);
+      return {matcher};
+    }
+    Matcher* matcher;
+  };
+
+  struct with
+  {
+    template <typename Matcher, typename modifier_tag, typename Parent, typename D>
+    static
+    call_modifier<Matcher, modifier_tag, Parent>&&
+    action(
+      call_modifier<Matcher, modifier_tag, Parent>&& m,
+      const char* str,
+      D&& d)
+    {
+      m.matcher->add_condition(str, std::forward<D>(d));
+      return std::move(m);
+    }
+  };
+
+  struct sideeffect
+  {
+    template <typename Matcher, typename modifier_tag, typename Parent, typename A>
+    static
     call_modifier<Matcher, modifier_tag, sideeffect_injector<Parent>>
-    sideeffect(
+    action(
+      call_modifier<Matcher, modifier_tag, Parent>&& m,
       A&& a)
     {
-      constexpr bool forbidden = upper_call_limit == 0U;
+      constexpr bool forbidden = Parent::upper_call_limit == 0U;
       static_assert(!forbidden,
                     "SIDE_EFFECT for forbidden call does not make sense");
-      matcher->add_side_effect(std::forward<A>(a));
-      return {std::move(matcher)};
+      m.matcher->add_side_effect(std::forward<A>(a));
+      return {std::move(m.matcher)};
     }
-    template <typename...> struct S;
+  };
+
 #ifdef TROMPELOEIL_COROUTINES_SUPPORTED
-    template <typename E>
+  struct handle_co_yield
+  {
+    template <typename Matcher, typename modifier_tag, typename Parent, typename E>
+    static
     call_modifier<Matcher, modifier_tag, Parent>
-    handle_co_yield(
+    action(
+      call_modifier<Matcher, modifier_tag, Parent>&& m,
       E&& e)
     {
+      using signature = typename Parent::signature;
       using params_type = call_params_type_t<signature>&;
       using sigret = return_of_t<signature>;
       using ret = std::invoke_result_t<E, params_type>;
@@ -3245,19 +3367,25 @@ template <typename T>
       constexpr auto valid = is_coroutine && !is_void && is_matching_type;
       if constexpr (valid)
       {
-        matcher->add_yield_expr(std::forward<E>(e));
+        m.matcher->add_yield_expr(std::forward<E>(e));
       }
-      return {matcher};
+      return {m.matcher};
     }
-    template <typename H>
-    call_modifier<Matcher, modifier_tag, co_return_injector<return_of_t<signature>, Parent >>
-    handle_co_return(
-      H&& h)
+  };
+  struct handle_co_return
+  {
+    template <typename Matcher, typename modifier_tag, typename Parent, typename H>
+    static
+    call_modifier<Matcher, modifier_tag, co_return_injector<return_of_t<typename Parent::signature>, Parent>>
+    action(call_modifier<Matcher, modifier_tag, Parent>&& m,
+           H&& h)
     {
+      using signature = typename Parent::signature;
+      using return_type = typename Parent::return_type;
+      using co_return_type = typename Parent::co_return_type;
       using params_type = call_params_type_t<signature>&;
       using sigret = return_of_t<signature>;
       using ret = std::invoke_result_t<H, params_type>;
-
       constexpr bool has_return = !std::is_same_v<return_type, void>;
       constexpr bool has_co_return = !std::is_same_v<co_return_type, void>;
       constexpr bool is_coroutine = trompeloeil::is_coroutine<sigret>::value;
@@ -3277,34 +3405,37 @@ template <typename T>
       static_assert(has_return || is_coroutine, "CO_RETURN when return type is not a coroutine");
       static_assert(has_return || has_co_return || !is_coroutine || is_matching_type,
                     "Expression type does not match the coroutine promise type");
-      static_assert(!throws || upper_call_limit == 0,
+      static_assert(!Parent::throws || Parent::upper_call_limit == 0,
                     "CO_THROW and CO_RETURN does not make sense");
-      static_assert(upper_call_limit > 0,
+      static_assert(Parent::upper_call_limit > 0,
                     "CO_RETURN for forbidden call does not make sense");
 
-      constexpr bool valid = !has_return && !has_co_return && is_coroutine && is_matching_type && !throws && upper_call_limit > 0;
+      constexpr bool valid = !has_return && !has_co_return && is_coroutine && is_matching_type && !Parent::throws && Parent::upper_call_limit > 0;
       if constexpr (valid)
       {
-        matcher->set_co_return(std::forward<H>(h));
+        m.matcher->set_co_return(std::forward<H>(h));
       }
-      return {matcher};
+      return {m.matcher};
     }
+  };
 #endif
-    template <typename H>
-    call_modifier<Matcher, modifier_tag, return_injector<return_of_t<signature>, Parent >>
-    handle_return(
-      H&& h)
+  struct handle_return
+  {
+    template <typename Matcher, typename modifier_tag, typename Parent, typename H>
+    static
+    call_modifier<Matcher, modifier_tag, return_injector<return_of_t<typename Parent::signature>, Parent>>
+    action(call_modifier<Matcher, modifier_tag, Parent>&& m,
+           H&& h)
     {
+      using signature = typename Parent::signature;
+      using return_type = typename Parent::return_type;
+      using co_return_type = typename Parent::co_return_type;
       using params_type = call_params_type_t<signature>&;
       using sigret = return_of_t<signature>;
       using ret = decltype(std::declval<H>()(std::declval<params_type>()));
       // don't know why MS VS 2015 RC doesn't like std::result_of
 
-#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
       constexpr bool is_coroutine      = trompeloeil::is_coroutine<sigret>::value;
-#else
-      constexpr bool is_coroutine      = false;
-#endif
       constexpr bool is_illegal_type   = std::is_same<detail::decay_t<ret>, illegal_argument>::value;
       constexpr bool has_co_return     = !std::is_same<co_return_type, void>::value;
       constexpr bool is_first_return   = std::is_same<return_type, void>::value;
@@ -3345,143 +3476,97 @@ template <typename T>
                     "RETURN value is not convertible to the return type of the function");
       static_assert(is_coroutine || is_first_return,
                     "Multiple RETURN does not make sense");
-      static_assert(is_coroutine || !throws || upper_call_limit == 0,
+      static_assert(is_coroutine || !Parent::throws || Parent::upper_call_limit == 0,
                     "THROW and RETURN does not make sense");
-      static_assert(is_coroutine || upper_call_limit > 0,
+      static_assert(is_coroutine || Parent::upper_call_limit > 0,
                     "RETURN for forbidden call does not make sense");
 
-      constexpr bool valid = !is_coroutine && !is_illegal_type && matching_ret_type && is_first_return && !throws && upper_call_limit > 0;
+      constexpr bool valid = !is_coroutine && !is_illegal_type && matching_ret_type && is_first_return && !Parent::throws && Parent::upper_call_limit > 0;
       using tag = std::integral_constant<bool, valid>;
-      matcher->set_return(tag{}, std::forward<H>(h));
-      return {matcher};
-    }
-
-    call_modifier&&
-    null_modifier()
-    {
-      return std::move(*this);
+      m.matcher->set_return(tag{}, std::forward<H>(h));
+      return {m.matcher};
     }
+  };
 
-#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
-
-    template <typename H>
-    struct co_throw_handler_t
-    {
-      using R = decltype(default_return<return_of_t<signature>>());
-      using promise_value_type = trompeloeil::coro_value_type_t<R>;
-      explicit
-      co_throw_handler_t(H&& h_)
-        : h(std::move(h_))
-      {}
-
-      template <typename T>
-      promise_value_type operator()(T& p)
-      {
-        return ((void)h(p), trompeloeil::default_return<promise_value_type>());
-      }
-
-    private:
-      H h;
-    };
-
-    template <typename H>
+  #ifdef TROMPELOEIL_COROUTINES_SUPPORTED
+  struct handle_co_throw
+  {
+    template <typename Matcher, typename modifier_tag, typename Parent, typename H>
+    static
     call_modifier<Matcher, modifier_tag, throw_injector<Parent>>
-    handle_co_throw(
-      H&& h)
+    action(call_modifier<Matcher, modifier_tag, Parent>&& m,
+           H&& h)
     {
+      using signature = typename Parent::signature;
+      using co_return_type = typename Parent::co_return_type;
       using sigret = return_of_t<signature>;
       constexpr bool is_coroutine      = trompeloeil::is_coroutine<sigret>::value;
       static_assert(is_coroutine,
                     "Do not use CO_THROW from a normal function, use THROW");
-      static_assert(!is_coroutine || !throws,
+      static_assert(!is_coroutine || !Parent::throws,
                     "Multiple CO_THROW does not make sense");
       constexpr bool has_return = !std::is_same<co_return_type, void>::value;
       static_assert(!is_coroutine || !has_return,
                     "CO_THROW and CO_RETURN does not make sense");
 
-      constexpr bool forbidden = upper_call_limit == 0U;
+      constexpr bool forbidden = Parent::upper_call_limit == 0U;
 
       static_assert(!is_coroutine || !forbidden,
                     "CO_THROW for forbidden call does not make sense");
 
-      constexpr bool valid = is_coroutine && !throws && !has_return;
+      constexpr bool valid = is_coroutine && !Parent::throws && !has_return;
       if constexpr (valid) {
-        auto handler = co_throw_handler_t<H>(std::forward<H>(h));
-        matcher->set_co_return(std::move(handler));
+        auto handler = co_throw_handler_t<H, signature>(std::forward<H>(h));
+        m.matcher->set_co_return(std::move(handler));
       }
-      return {matcher};
+      return {m.matcher};
     }
-#endif
-    template <typename H>
-    struct throw_handler_t
-    {
-      using R = decltype(default_return<return_of_t<signature>>());
-
-      explicit
-      throw_handler_t(H&& h_)
-        : h(std::move(h_))
-      {}
-
-      template <typename T>
-      R operator()(T& p)
-      {
-        /* Work around VS 2017 15.7.x C4702 warning by
-         * enclosing the operation in an otherwise
-         * unnecessary try/catch block.
-         */
-        try
-        {
-          h(p);
-          abort();
-        }
-        catch (...)
-        {
-          throw;
-        }
-        return default_return<R>(); // unreachable code
-      }
-
-    private:
-      H h;
-    };
+  };
+  #endif
 
-    template <typename H>
+  struct handle_throw
+  {
+    template <typename Matcher, typename modifier_tag, typename Parent, typename H>
+    static
     call_modifier<Matcher, modifier_tag, throw_injector<Parent>>
-    handle_throw(
-      H&& h)
+    action(call_modifier<Matcher, modifier_tag, Parent>&& m,
+           H&& h)
     {
-#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
-      using sigret = return_of_t<signature>;
-      constexpr bool is_coroutine      = trompeloeil::is_coroutine<sigret>::value;
-#else
-      constexpr bool is_coroutine      = false;
-#endif
+      using signature = typename Parent::signature;
+      constexpr bool is_coroutine      = trompeloeil::is_coroutine<return_of_t<signature>>::value;
+
       static_assert(!is_coroutine,
                     "Do not use THROW from a coroutine, use CO_THROW");
-      static_assert(is_coroutine || !throws,
+      static_assert(is_coroutine || !Parent::throws,
                     "Multiple THROW does not make sense");
-      constexpr bool has_return = !std::is_same<return_type, void>::value;
+      constexpr bool has_return = !std::is_same<typename Parent::return_type, void>::value;
       static_assert(!has_return,
                     "THROW and RETURN does not make sense");
 
-      constexpr bool forbidden = upper_call_limit == 0U;
+      constexpr bool forbidden = Parent::upper_call_limit == 0U;
 
       static_assert(is_coroutine || !forbidden,
                     "THROW for forbidden call does not make sense");
 
-      constexpr bool valid = !is_coroutine && !throws && !has_return;
+      constexpr bool valid = !is_coroutine && !Parent::throws && !has_return;
       using tag = std::integral_constant<bool, valid>;
-      auto handler = throw_handler_t<H>(std::forward<H>(h));
-      matcher->set_return(tag{}, std::move(handler));
-      return {matcher};
+      auto handler = throw_handler_t<H, signature>(std::forward<H>(h));
+      m.matcher->set_return(tag{}, std::move(handler));
+      return {m.matcher};
     }
+  };
 
-    template <size_t L,
-              size_t H,
-              bool               times_set = call_limit_set>
+  struct times
+  {
+    template <
+      typename Matcher, typename modifier_tag, typename Parent,
+      size_t L,
+      size_t H,
+      bool times_set = Parent::call_limit_set>
+    static
     call_modifier<Matcher, modifier_tag, call_limit_injector<Parent, H>>
-    times(
-      multiplicity<L, H>)
+    action(call_modifier<Matcher, modifier_tag, Parent>&& m,
+           multiplicity<L, H>)
     {
       static_assert(!times_set,
                     "Only one TIMES call limit is allowed, but it can express an interval");
@@ -3489,39 +3574,21 @@ template <typename T>
       static_assert(H >= L,
                     "In TIMES the first value must not exceed the second");
 
-      static_assert(H > 0 || !throws,
+      static_assert(H > 0 || !Parent::throws,
                     "THROW and TIMES(0) does not make sense");
 
-      static_assert(H > 0 || std::is_same<return_type, void>::value,
+      static_assert(H > 0 || std::is_same<typename Parent::return_type, void>::value,
                     "RETURN and TIMES(0) does not make sense");
 
-      static_assert(H > 0 || !side_effects,
+      static_assert(H > 0 || !Parent::side_effects,
                     "SIDE_EFFECT and TIMES(0) does not make sense");
 
-      static_assert(H > 0 || !sequence_set,
+      static_assert(H > 0 || !Parent::sequence_set,
                     "IN_SEQUENCE and TIMES(0) does not make sense");
 
-      matcher->sequences->set_limits(L, H);
-      return {matcher};
+      m.matcher->sequences->set_limits(L, H);
+      return {m.matcher};
     }
-
-    template <typename ... T,
-              bool b = sequence_set>
-    call_modifier<Matcher, modifier_tag, sequence_injector<Parent>>
-    in_sequence(
-      T&& ... t)
-    {
-      static_assert(!b,
-                    "Multiple IN_SEQUENCE does not make sense."
-                    " You can list several sequence objects at once");
-
-      static_assert(upper_call_limit > 0,
-                    "IN_SEQUENCE for forbidden call does not make sense");
-
-      matcher->set_sequence(std::forward<T>(t)...);
-      return {matcher};
-    }
-    Matcher* matcher;
   };
 
   inline
@@ -3952,11 +4019,7 @@ template <typename T>
       using sigret = return_of_t<typename call::signature>;
       using ret = typename call::return_type;
       using coret = typename call::co_return_type;
-#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
       constexpr bool is_coroutine = trompeloeil::is_coroutine<sigret>::value;
-#else
-      constexpr bool is_coroutine = false;
-#endif
       constexpr bool retmatch = std::is_same<ret, sigret>::value;
       constexpr bool coretmatch = std::is_same<coret, sigret>::value;
       constexpr bool forbidden = call::upper_call_limit == 0;
@@ -4663,7 +4726,8 @@ template <typename T>
 #if (TROMPELOEIL_CPLUSPLUS != 201103L)
 
 #define TROMPELOEIL_WITH_(capture, arg_s, ...)                                 \
-  with(arg_s, [capture](auto const& trompeloeil_x) {                           \
+  template action<trompeloeil::with>(arg_s,                                    \
+                                     [capture](auto const& trompeloeil_x) {    \
     auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                        \
     auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                        \
     auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                        \
@@ -4693,7 +4757,7 @@ template <typename T>
 #if (TROMPELOEIL_CPLUSPLUS != 201103L)
 
 #define TROMPELOEIL_SIDE_EFFECT_(capture, ...)                                 \
-  sideeffect([capture](auto& trompeloeil_x) {                                  \
+  template action<trompeloeil::sideeffect>([capture](auto& trompeloeil_x) {    \
     auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                        \
     auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                        \
     auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                        \
@@ -4723,7 +4787,8 @@ template <typename T>
 #if (TROMPELOEIL_CPLUSPLUS != 201103L)
 
 #define TROMPELOEIL_RETURN_(capture, ...)                                      \
-  handle_return([capture](auto& trompeloeil_x) -> decltype(auto) {             \
+  template action<trompeloeil::handle_return>([capture](auto& trompeloeil_x)   \
+                                              -> decltype(auto) {              \
     auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                        \
     auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                        \
     auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                        \
@@ -4748,8 +4813,9 @@ template <typename T>
 #define TROMPELOEIL_CO_RETURN(...)    TROMPELOEIL_CO_RETURN_(=, __VA_ARGS__)
 #define TROMPELOEIL_LR_CO_RETURN(...) TROMPELOEIL_CO_RETURN_(&, __VA_ARGS__)
 
-#define TROMPELOEIL_CO_RETURN_(capture, ...) \
-  handle_co_return([capture](auto& trompeloeil_x) -> decltype(auto) { \
+#define TROMPELOEIL_CO_RETURN_(capture, ...)                                   \
+  template action<trompeloeil::handle_co_return>([capture](auto& trompeloeil_x)\
+                                                 -> decltype(auto) {           \
     auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                        \
     auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                        \
     auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                        \
@@ -4781,7 +4847,7 @@ template <typename T>
 #if (TROMPELOEIL_CPLUSPLUS != 201103L)
 
 #define TROMPELOEIL_THROW_(capture, ...)                                       \
-  handle_throw([capture](auto& trompeloeil_x)  {                               \
+  template action<trompeloeil::handle_throw>([capture](auto& trompeloeil_x) {  \
     auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                        \
     auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                        \
     auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                        \
@@ -4809,7 +4875,7 @@ template <typename T>
 #define TROMPELOEIL_LR_CO_THROW(...) TROMPELOEIL_CO_THROW_(&, __VA_ARGS__)
 
 #define TROMPELOEIL_CO_THROW_(capture, ...)                                    \
-  handle_co_throw([capture](auto& trompeloeil_x)  {                            \
+  template action<trompeloeil::handle_co_throw>([capture](auto& trompeloeil_x){\
     auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                        \
     auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                        \
     auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                        \
@@ -4833,8 +4899,8 @@ template <typename T>
 #define TROMPELOEIL_LR_CO_YIELD(...) TROMPELOEIL_CO_YIELD_(&, __VA_ARGS__)
 
 
-#define TROMPELOEIL_CO_YIELD_(capture, ...)                                   \
-  handle_co_yield([capture](auto& trompeloeil_x)  {                            \
+#define TROMPELOEIL_CO_YIELD_(capture, ...)                                    \
+  template action<trompeloeil::handle_co_yield>([capture](auto& trompeloeil_x){\
     auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                        \
     auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                        \
     auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                        \
@@ -4856,7 +4922,7 @@ template <typename T>
 #endif
 
 
-#define TROMPELOEIL_TIMES(...) times(::trompeloeil::multiplicity<__VA_ARGS__>{})
+#define TROMPELOEIL_TIMES(...) template action<trompeloeil::times>(::trompeloeil::multiplicity<__VA_ARGS__>{})
 #define TROMPELOEIL_INFINITY_TIMES() TROMPELOEIL_TIMES(0, ~static_cast<size_t>(0))
 
 #define TROMPELOEIL_IN_SEQUENCE(...)                                           \

From 08629bd68fecec2c8cd5bb7ca28228c055f42fc7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Fahller?= <bjorn@fahller.se>
Date: Sun, 5 Nov 2023 09:26:31 +0100
Subject: [PATCH 10/20] Break out coro.hpp

---
 docs/reference.md            |  12 ++
 include/trompeloeil.hpp      |   4 +-
 include/trompeloeil/coro.hpp | 399 ++++++++++++++++++++++++++++++++++
 include/trompeloeil/mock.hpp | 401 ++---------------------------------
 4 files changed, 426 insertions(+), 390 deletions(-)
 create mode 100644 include/trompeloeil/coro.hpp

diff --git a/docs/reference.md b/docs/reference.md
index 81cd920f..3ae66e63 100644
--- a/docs/reference.md
+++ b/docs/reference.md
@@ -796,6 +796,8 @@ Note that when [**`SIDE_EFFECT(...)`**](#SIDE_EFFECT) and
 [**`LR_SIDE_EFFECT(...)`**](#LR_SIDE_EFFECT) are executed depends on the behaviour of the
 coroutine promise  type. This code may alter out-parameters.
 
+`#include <trompeloeil/coro.hpp>`
+
 Coroutine support must be explicitly enabled by defining
 **`TROMPELOEIL_EXPERIMENTAL_COROUTINES`** before including the header.
 
@@ -815,6 +817,8 @@ Note that when any [**`SIDE_EFFECT(...)`**](#SIDE_EFFECT) and
 [**`LR_SIDE_EFFECT(...)`**](#LR_SIDE_EFFECT) are executed depends on the behaviour of the
 coroutine promise type. This code may alter out-parameters.
 
+`#include <trompeloeil/coro.hpp>`
+
 Coroutine support must be explicitly enabled by defining
 **`TROMPELOEIL_EXPERIMENTAL_COROUTINES`** before including the header.
 
@@ -838,6 +842,8 @@ be yielded one at the time, in the order they are listed. Note that
 
 See also [**`LR_CO_YIELD(`** *expr* **`]`**](#LR_CO_YIELD)
 
+`#include <trompeloeil/coro.hpp>`
+
 Coroutine support must be explicitly enabled by defining
 **`TROMPELOEIL_EXPERIMENTAL_COROUTINES`** before including the header.
 
@@ -1126,6 +1132,8 @@ Note that when any [**`SIDE_EFFECT(...)`**](#SIDE_EFFECT) and
 [**`LR_SIDE_EFFECT(...)`**](#LR_SIDE_EFFECT) are executed depends on the behaviour of the
 coroutine promise type. This code may alter out-parameters.
 
+`#include <trompeloeil/coro.hpp>`
+
 Coroutine support must be explicitly enabled by defining
 **`TROMPELOEIL_EXPERIMENTAL_COROUTINES`** before including the header.
 
@@ -1148,6 +1156,8 @@ Note that when any [**`SIDE_EFFECT(...)`**](#SIDE_EFFECT) and
 [**`LR_SIDE_EFFECT(...)`**](#LR_SIDE_EFFECT) are executed depends on the behaviour of the
 coroutine promise type. This code may alter out-parameters.
 
+`#include <trompeloeil/coro.hpp>`
+
 Coroutine support must be explicitly enabled by defining
 **`TROMPELOEIL_EXPERIMENTAL_COROUTINES`** before including the header.
 
@@ -1174,6 +1184,8 @@ be yielded one at the time, in the order they are listed. Note that
 
 See also [**`CO_YIELD(`** *expr* **`]`**](#LR_CO_YIELD)
 
+`#include <trompeloeil/coro.hpp>`
+
 Coroutine support must be explicitly enabled by defining
 **`TROMPELOEIL_EXPERIMENTAL_COROUTINES`** before including the header.
 
diff --git a/include/trompeloeil.hpp b/include/trompeloeil.hpp
index 99f0c438..6a6a4a40 100644
--- a/include/trompeloeil.hpp
+++ b/include/trompeloeil.hpp
@@ -33,5 +33,7 @@
 #include "trompeloeil/matcher/not.hpp"
 #include "trompeloeil/matcher/re.hpp"
 #include "trompeloeil/stream_tracer.hpp"
-
+#ifdef __cpp_impl_coroutine
+#include "trompeloeil/coro.hpp"
+#endif
 #endif // include guard
diff --git a/include/trompeloeil/coro.hpp b/include/trompeloeil/coro.hpp
new file mode 100644
index 00000000..331b8d25
--- /dev/null
+++ b/include/trompeloeil/coro.hpp
@@ -0,0 +1,399 @@
+/*
+ * Trompeloeil C++ mocking framework
+ *
+ * Copyright (C) Björn Fahller
+ *
+ *  Use, modification and distribution is subject to the
+ *  Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy atl
+ *  http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * Project home: https://github.com/rollbear/trompeloeil
+ */
+
+#ifndef TROMPELOEIL_CORO_HPP
+#define TROMPELOEIL_CORO_HPP
+
+#if defined(__cpp_impl_coroutine)
+#  ifdef TROMPELOEIL_EXPERIMENTAL_COROUTINES
+#    define TROMPELOEIL_COROUTINES_SUPPORTED 1
+#  endif
+#else
+#  error "Coroutines are not supported by this compiler"
+#endif
+
+#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
+
+#include "mock.hpp"
+
+namespace trompeloeil
+{
+  template <typename U>
+  struct type_wrapper{
+  template <typename V>
+    static V remove_rvalue_ref(V&&);
+    using type = decltype(remove_rvalue_ref(std::declval<U>()));
+  };
+  template <>
+  struct type_wrapper<void>
+  {
+    using type = void;
+  };
+
+  template <typename T>
+  struct coro_value_type
+  {
+    static auto func()
+    {
+      if constexpr (requires {std::declval<T>().operator co_await();})
+      {
+        return type_wrapper<decltype(std::declval<T>().operator co_await().await_resume())>{};
+      }
+      else
+      {
+        return type_wrapper<decltype(std::declval<T>().await_resume())>{};
+      }
+    }
+    using type = typename decltype(func())::type;
+  };
+
+  template <typename T>
+  using coro_value_type_t = typename coro_value_type<T>::type;
+
+  template <typename Sig>
+
+  struct yield_expr_base<Sig, true> : public list_elem<yield_expr_base<Sig, true>>
+  {
+    ~yield_expr_base() override = default;
+
+    using ret_type = coro_value_type_t<return_of_t<Sig>>;
+    virtual
+    ret_type
+    expr(
+      call_params_type_t<Sig>&)
+    const = 0;
+  };
+
+  template <typename Sig>
+  struct yield_expr_base<Sig, false> : public list_elem<yield_expr_base<Sig, false>>
+  {
+    using ret_type = return_of_t<Sig>;
+    virtual
+    ret_type
+    expr(
+      call_params_type_t<Sig>&)
+    const = 0;
+  };
+
+  template <typename Sig, typename Expr>
+  struct yield_expr : yield_expr_base<Sig>
+  {
+    using ret_type = typename yield_expr_base<Sig>::ret_type;
+    template <typename E>
+    explicit
+    yield_expr(
+      E&& e_)
+      : e(std::forward<E>(e_))
+    {}
+
+    ret_type
+    expr(
+      call_params_type_t<Sig>& t)
+    const
+    override
+    {
+      return e(t);
+    }
+  private:
+    Expr e;
+  };
+
+  template <typename Sig, typename T>
+  class co_return_handler_t : public return_handler<Sig>
+  {
+  public:
+    template <typename U>
+    explicit
+    co_return_handler_t(
+      U&& u,
+      std::shared_ptr<yield_expr_list<Sig>> yields_)
+      : func(std::forward<U>(u))
+      , yields(std::move(yields_))
+    {}
+
+    return_of_t<Sig>
+    call(
+      trace_agent& /*agent*/,
+      call_params_type_t<Sig>& params)
+    override
+    {
+      using coro_type = return_of_t<Sig>;
+      using promise_type = typename std::coroutine_traits<coro_type>::promise_type;
+      using value_type = coro_value_type_t<coro_type>;
+      if constexpr (requires {std::declval<promise_type&>().yield_value(std::declval<value_type>());})
+      {
+        for (auto & e : *yields)
+        {
+          co_yield e.expr(params);
+        }
+      }
+      co_return func(params);
+    }
+  private:
+    T func;
+    std::shared_ptr<yield_expr_list<Sig>> yields;
+  };
+
+  template <typename H, typename signature>
+  struct co_throw_handler_t
+  {
+    using R = decltype(default_return<return_of_t<signature>>());
+    using promise_value_type = trompeloeil::coro_value_type_t<R>;
+    explicit
+    co_throw_handler_t(H&& h_)
+      : h(std::move(h_))
+    {}
+
+    template <typename T>
+    promise_value_type operator()(T& p)
+    {
+      return ((void)h(p), trompeloeil::default_return<promise_value_type>());
+    }
+  private:
+    H h;
+  };
+
+  struct handle_co_yield
+  {
+    template <typename Matcher, typename modifier_tag, typename Parent, typename E>
+    static
+    call_modifier<Matcher, modifier_tag, Parent>
+    action(
+      call_modifier<Matcher, modifier_tag, Parent>&& m,
+      E&& e)
+    {
+      using signature = typename Parent::signature;
+      using params_type = call_params_type_t<signature>&;
+      using sigret = return_of_t<signature>;
+      using ret = std::invoke_result_t<E, params_type>;
+
+      constexpr bool is_void = std::is_same_v<ret, void>;
+      constexpr bool is_coroutine = trompeloeil::is_coroutine<sigret>::value;
+      constexpr bool is_matching_type = std::invoke([]{
+        if constexpr (is_coroutine && !is_void) {
+          using promise = typename std::coroutine_traits<sigret>::promise_type;
+          return requires(promise p, ret r){ p.yield_value(r); };
+        } else {
+          return false;
+        }
+      });
+
+      static_assert(is_coroutine,
+                    "CO_YIELD when return type is not a coroutine");
+      static_assert(!is_coroutine || !is_void,
+                    "You cannot CO_YIELD void");
+      static_assert(!is_coroutine || is_void || is_matching_type,
+                    "CO_YIELD is incompatible with the promise type");
+      constexpr auto valid = is_coroutine && !is_void && is_matching_type;
+      if constexpr (valid)
+      {
+	if (!m.matcher->yield_expressions)
+	{
+	  m.matcher->yield_expressions = std::make_shared<yield_expr_list<signature>>();
+	}
+        auto expr = new yield_expr<signature, E>(std::forward<E>(e));
+        m.matcher->yield_expressions->push_back(expr);
+      }
+      return {m.matcher};
+    }
+  };
+
+  struct handle_co_return
+  {
+    template <typename Matcher, typename modifier_tag, typename Parent, typename H>
+    static
+    call_modifier<Matcher, modifier_tag, co_return_injector<return_of_t<typename Parent::signature>, Parent>>
+    action(
+      call_modifier<Matcher, modifier_tag, Parent>&& m,
+      H&& h)
+    {
+      using signature = typename Parent::signature;
+      using return_type = typename Parent::return_type;
+      using co_return_type = typename Parent::co_return_type;
+      using params_type = call_params_type_t<signature>&;
+      using sigret = return_of_t<signature>;
+      using ret = std::invoke_result_t<H, params_type>;
+      constexpr bool has_return = !std::is_same_v<return_type, void>;
+      constexpr bool has_co_return = !std::is_same_v<co_return_type, void>;
+      constexpr bool is_coroutine = trompeloeil::is_coroutine<sigret>::value;
+      constexpr bool is_matching_type = std::invoke([]{if constexpr (is_coroutine) {
+        using promise = typename std::coroutine_traits<sigret>::promise_type;
+        if constexpr (std::is_same_v<void, ret>) {
+          return requires (promise p){p.return_void();};
+        } else {
+          return requires(promise p) { p.return_value(std::declval<ret>()); };
+        }}
+        return true;});
+
+      static_assert(!has_return,
+                    "CO_RETURN and RETURN cannot be combined");
+      static_assert(has_return || !has_co_return,
+                    "Multiple CO_RETURN does not make sense");
+      static_assert(has_return || is_coroutine, "CO_RETURN when return type is not a coroutine");
+      static_assert(has_return || has_co_return || !is_coroutine || is_matching_type,
+                    "Expression type does not match the coroutine promise type");
+      static_assert(!Parent::throws || Parent::upper_call_limit == 0,
+                    "CO_THROW and CO_RETURN does not make sense");
+      static_assert(Parent::upper_call_limit > 0,
+                    "CO_RETURN for forbidden call does not make sense");
+
+      constexpr bool valid = !has_return && !has_co_return && is_coroutine && is_matching_type && !Parent::throws && Parent::upper_call_limit > 0;
+      if constexpr (valid)
+      {
+        using basic_t = typename std::remove_reference<H>::type;
+        using handler = co_return_handler_t<signature, basic_t>;
+	if (!m.matcher->yield_expressions)
+	{
+	  m.matcher->yield_expressions = std::make_shared<yield_expr_list<signature>>();
+	}
+        m.matcher->return_handler_obj.reset(
+          new handler(std::forward<H>(h),
+          m.matcher->yield_expressions)
+        );
+      }
+      return {m.matcher};
+    }
+  };
+
+  struct handle_co_throw
+  {
+    template <typename Matcher, typename modifier_tag, typename Parent, typename H>
+    static
+    call_modifier<Matcher, modifier_tag, throw_injector<Parent>>
+    action(
+      call_modifier<Matcher, modifier_tag, Parent>&& m,
+      H&& h)
+    {
+      using signature = typename Parent::signature;
+      using co_return_type = typename Parent::co_return_type;
+      using sigret = return_of_t<signature>;
+      constexpr bool is_coroutine      = trompeloeil::is_coroutine<sigret>::value;
+      static_assert(is_coroutine,
+                    "Do not use CO_THROW from a normal function, use THROW");
+      static_assert(!is_coroutine || !Parent::throws,
+                    "Multiple CO_THROW does not make sense");
+      constexpr bool has_return = !std::is_same<co_return_type, void>::value;
+      static_assert(!is_coroutine || !has_return,
+                    "CO_THROW and CO_RETURN does not make sense");
+
+      constexpr bool forbidden = Parent::upper_call_limit == 0U;
+
+      static_assert(!is_coroutine || !forbidden,
+                    "CO_THROW for forbidden call does not make sense");
+
+      constexpr bool valid = is_coroutine && !Parent::throws && !has_return;
+      if constexpr (valid) {
+        if (!m.matcher->yield_expressions)
+        {
+          m.matcher->yield_expressions = std::make_shared<yield_expr_list<signature>>();
+        }
+        using throw_handler_t = co_throw_handler_t<H, signature>;
+        auto handler = throw_handler_t(std::forward<H>(h));
+        using ret_handler = co_return_handler_t<signature, throw_handler_t>;
+        m.matcher->return_handler_obj.reset(new ret_handler(std::move(handler),
+                                                            m.matcher->yield_expressions));
+      }
+      return {m.matcher};
+    }
+  };
+
+}
+
+#define TROMPELOEIL_CO_RETURN(...)    TROMPELOEIL_CO_RETURN_(=, __VA_ARGS__)
+#define TROMPELOEIL_LR_CO_RETURN(...) TROMPELOEIL_CO_RETURN_(&, __VA_ARGS__)
+
+#define TROMPELOEIL_CO_RETURN_(capture, ...)                                   \
+  template action<trompeloeil::handle_co_return>([capture](auto& trompeloeil_x)\
+                                                 -> decltype(auto) {           \
+    auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                        \
+    auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                        \
+    auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                        \
+    auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                        \
+    auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                        \
+    auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                        \
+    auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                        \
+    auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                        \
+    auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                        \
+    auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                       \
+    auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                       \
+    auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                       \
+    auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                       \
+    auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                       \
+    auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                       \
+    ::trompeloeil::ignore(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15); \
+    return ::trompeloeil::decay_return_type(__VA_ARGS__);                      \
+  })
+
+#define TROMPELOEIL_CO_THROW(...)    TROMPELOEIL_CO_THROW_(=, __VA_ARGS__)
+#define TROMPELOEIL_LR_CO_THROW(...) TROMPELOEIL_CO_THROW_(&, __VA_ARGS__)
+
+#define TROMPELOEIL_CO_THROW_(capture, ...)                                    \
+  template action<trompeloeil::handle_co_throw>([capture](auto& trompeloeil_x){\
+    auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                        \
+    auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                        \
+    auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                        \
+    auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                        \
+    auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                        \
+    auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                        \
+    auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                        \
+    auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                        \
+    auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                        \
+    auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                       \
+    auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                       \
+    auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                       \
+    auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                       \
+    auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                       \
+    auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                       \
+    ::trompeloeil::ignore(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15); \
+    throw __VA_ARGS__;                                                         \
+ })
+
+#define TROMPELOEIL_CO_YIELD(...)    TROMPELOEIL_CO_YIELD_(=, __VA_ARGS__)
+#define TROMPELOEIL_LR_CO_YIELD(...) TROMPELOEIL_CO_YIELD_(&, __VA_ARGS__)
+
+
+#define TROMPELOEIL_CO_YIELD_(capture, ...)                                    \
+  template action<trompeloeil::handle_co_yield>([capture](auto& trompeloeil_x){\
+    auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                        \
+    auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                        \
+    auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                        \
+    auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                        \
+    auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                        \
+    auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                        \
+    auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                        \
+    auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                        \
+    auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                        \
+    auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                       \
+    auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                       \
+    auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                       \
+    auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                       \
+    auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                       \
+    auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                       \
+    ::trompeloeil::ignore(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15); \
+    return __VA_ARGS__;                                                         \
+ })
+
+#ifndef TROMPELOEIL_LONG_MACROS
+
+#define CO_RETURN                 TROMPELOEIL_CO_RETURN
+#define LR_CO_RETURN              TROMPELOEIL_LR_CO_RETURN
+#define CO_THROW                  TROMPELOEIL_CO_THROW
+#define LR_CO_THROW               TROMPELOEIL_LR_CO_THROW
+#define CO_YIELD                  TROMPELOEIL_CO_YIELD
+#define LR_CO_YIELD               TROMPELOEIL_LR_CO_YIELD
+
+#endif
+
+#endif
+
+#endif //TROMPELOEIL_CORO_HPP
diff --git a/include/trompeloeil/mock.hpp b/include/trompeloeil/mock.hpp
index 54d7483d..c164ea02 100644
--- a/include/trompeloeil/mock.hpp
+++ b/include/trompeloeil/mock.hpp
@@ -29,13 +29,6 @@
 // * Mocking function templates is not supported
 // * If a macro kills a kitten, this threatens extinction of all felines!
 
-#if defined(TROMPELOEIL_EXPERIMENTAL_COROUTINES)
-#  if defined(__cpp_impl_coroutine)
-#    define TROMPELOEIL_COROUTINES_SUPPORTED 1
-#  else
-#    error "Coroutines are not supported by this compiler"
-#  endif
-#endif
 
 #if defined(_MSC_VER)
 
@@ -145,6 +138,9 @@
 #include <type_traits>
 #include <utility>
 
+#ifdef __cpp_impl_coroutine
+#include <coroutine>
+#endif
 
 #ifndef TROMPELOEIL_CUSTOM_ATOMIC
 #include <atomic>
@@ -159,9 +155,6 @@ namespace trompeloeil { using std::unique_lock; }
 #include <trompeloeil/custom_unique_lock.hpp>
 #endif
 
-#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
-#include <coroutine>
-#endif
 
 #ifdef TROMPELOEIL_SANITY_CHECKS
 #include <cassert>
@@ -495,45 +488,12 @@ namespace trompeloeil {
 
 # endif
 
-#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
+#if defined(__cpp_impl_coroutine)
   template <typename Sig, typename = void>
   struct is_coroutine : std::false_type {};
 
   template <typename Sig>
   struct is_coroutine<Sig, std::void_t<decltype(&std::coroutine_traits<Sig>::promise_type::initial_suspend)>> : std::true_type {};
-
-  template <typename U>
-  struct type_wrapper{
-    template <typename V>
-    static V remove_rvalue_ref(V&&);
-    using type = decltype(remove_rvalue_ref(std::declval<U>()));
-  };
-  template <>
-  struct type_wrapper<void>
-  {
-    using type = void;
-  };
-
-  template <typename T>
-  struct coro_value_type
-  {
-    static auto func()
-    {
-      if constexpr (requires {std::declval<T>().operator co_await();})
-      {
-        return type_wrapper<decltype(std::declval<T>().operator co_await().await_resume())>{};
-      }
-      else
-      {
-        return type_wrapper<decltype(std::declval<T>().await_resume())>{};
-      }
-    }
-    using type = typename decltype(func())::type;
-  };
-
-template <typename T>
-using coro_value_type_t = typename coro_value_type<T>::type;
-
 #else
   template <typename>
   using is_coroutine = std::false_type;
@@ -1656,6 +1616,7 @@ template <typename T>
     return iterator{t};
   }
 
+
   class sequence_matcher;
 
   class sequence_type
@@ -2458,6 +2419,12 @@ template <typename T>
     }
   };
 
+  template <typename Sig, bool = is_coroutine<return_of_t<Sig>>::value>
+  struct yield_expr_base;
+
+  template <typename Sig>
+  using yield_expr_list = list<yield_expr_base<Sig>, delete_disposer>;
+
 #if TROMPELOEIL_MSVC
 #pragma warning(push)
 #pragma warning(disable : 4702)
@@ -2952,93 +2919,6 @@ template <typename T>
     T func;
   };
 
-#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
-  template <typename Sig, bool = trompeloeil::is_coroutine<return_of_t<Sig>>::value>
-  struct yield_expr_base : public list_elem<yield_expr_base<Sig, true>>
-  {
-    ~yield_expr_base() override = default;
-
-    using ret_type = coro_value_type_t<return_of_t<Sig>>;
-    virtual
-    ret_type
-    expr(
-      call_params_type_t<Sig>&)
-    const = 0;
-  };
-  template <typename Sig>
-  struct yield_expr_base<Sig, false> : public list_elem<yield_expr_base<Sig, false>>
-  {
-    using ret_type = return_of_t<Sig>;
-    virtual
-    ret_type
-    expr(
-      call_params_type_t<Sig>&)
-    const = 0;
-  };
-
-  template <typename Sig>
-  using yield_expr_list = list<yield_expr_base<Sig>, delete_disposer>;
-
-  template <typename Sig, typename Expr>
-  struct yield_expr : yield_expr_base<Sig>
-  {
-    using ret_type = typename yield_expr_base<Sig>::ret_type;
-    template <typename E>
-    explicit
-    yield_expr(
-      E&& e_)
-      : e(std::forward<E>(e_))
-    {}
-
-    ret_type
-    expr(
-      call_params_type_t<Sig>& t)
-    const
-    override
-    {
-      return e(t);
-    }
-  private:
-    Expr e;
-  };
-
-  template <typename Sig, typename T>
-  class co_return_handler_t : public return_handler<Sig>
-  {
-  public:
-    template <typename U>
-    explicit
-    co_return_handler_t(
-      U&& u,
-      std::shared_ptr<yield_expr_list<Sig>> yields_)
-      : func(std::forward<U>(u))
-      , yields(std::move(yields_))
-    {}
-
-    return_of_t<Sig>
-    call(
-      trace_agent& /*agent*/,
-      call_params_type_t<Sig>& params)
-    override
-    {
-      using coro_type = return_of_t<Sig>;
-      using promise_type = typename std::coroutine_traits<coro_type>::promise_type;
-      using value_type = coro_value_type_t<coro_type>;
-      if constexpr (requires {std::declval<promise_type&>().yield_value(std::declval<value_type>());})
-      {
-        for (auto & e : *yields)
-        {
-          co_yield e.expr(params);
-        }
-      }
-      co_return func(params);
-    }
-  private:
-    T func;
-    std::shared_ptr<yield_expr_list<Sig>> yields;
-  };
-#endif
-
   template <typename Sig>
   class condition_base : public list_elem<condition_base<Sig>>
   {
@@ -3178,28 +3058,6 @@ template <typename T>
     static bool const sequence_set = true;
   };
 
-#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
-  template <typename H, typename signature>
-    struct co_throw_handler_t
-    {
-      using R = decltype(default_return<return_of_t<signature>>());
-      using promise_value_type = trompeloeil::coro_value_type_t<R>;
-      explicit
-      co_throw_handler_t(H&& h_)
-        : h(std::move(h_))
-      {}
-
-      template <typename T>
-      promise_value_type operator()(T& p)
-      {
-        return ((void)h(p), trompeloeil::default_return<promise_value_type>());
-      }
-
-    private:
-      H h;
-    };
-#endif
-
   template <typename H, typename signature>
   struct throw_handler_t
   {
@@ -3333,92 +3191,6 @@ template <typename T>
     }
   };
 
-#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
-  struct handle_co_yield
-  {
-    template <typename Matcher, typename modifier_tag, typename Parent, typename E>
-    static
-    call_modifier<Matcher, modifier_tag, Parent>
-    action(
-      call_modifier<Matcher, modifier_tag, Parent>&& m,
-      E&& e)
-    {
-      using signature = typename Parent::signature;
-      using params_type = call_params_type_t<signature>&;
-      using sigret = return_of_t<signature>;
-      using ret = std::invoke_result_t<E, params_type>;
-
-      constexpr bool is_void = std::is_same_v<ret, void>;
-      constexpr bool is_coroutine = trompeloeil::is_coroutine<sigret>::value;
-      constexpr bool is_matching_type = std::invoke([]{
-        if constexpr (is_coroutine && !is_void) {
-          using promise = typename std::coroutine_traits<sigret>::promise_type;
-          return requires(promise p, ret r){ p.yield_value(r); };
-        } else {
-          return false;
-        }
-      });
-      static_assert(is_coroutine,
-                    "CO_YIELD when return type is not a coroutine");
-      static_assert(!is_coroutine || !is_void,
-                    "You cannot CO_YIELD void");
-      static_assert(!is_coroutine || is_void || is_matching_type,
-                    "CO_YIELD is incompatible with the promise type");
-      constexpr auto valid = is_coroutine && !is_void && is_matching_type;
-      if constexpr (valid)
-      {
-        m.matcher->add_yield_expr(std::forward<E>(e));
-      }
-      return {m.matcher};
-    }
-  };
-  struct handle_co_return
-  {
-    template <typename Matcher, typename modifier_tag, typename Parent, typename H>
-    static
-    call_modifier<Matcher, modifier_tag, co_return_injector<return_of_t<typename Parent::signature>, Parent>>
-    action(call_modifier<Matcher, modifier_tag, Parent>&& m,
-           H&& h)
-    {
-      using signature = typename Parent::signature;
-      using return_type = typename Parent::return_type;
-      using co_return_type = typename Parent::co_return_type;
-      using params_type = call_params_type_t<signature>&;
-      using sigret = return_of_t<signature>;
-      using ret = std::invoke_result_t<H, params_type>;
-      constexpr bool has_return = !std::is_same_v<return_type, void>;
-      constexpr bool has_co_return = !std::is_same_v<co_return_type, void>;
-      constexpr bool is_coroutine = trompeloeil::is_coroutine<sigret>::value;
-      constexpr bool is_matching_type = std::invoke([]{if constexpr (is_coroutine) {
-        using promise = typename std::coroutine_traits<sigret>::promise_type;
-        if constexpr (std::is_same_v<void, ret>) {
-          return requires (promise p){p.return_void();};
-        } else {
-          return requires(promise p) { p.return_value(std::declval<ret>()); };
-        }}
-        return true;});
-
-      static_assert(!has_return,
-                    "CO_RETURN and RETURN cannot be combined");
-      static_assert(has_return || !has_co_return,
-                    "Multiple CO_RETURN does not make sense");
-      static_assert(has_return || is_coroutine, "CO_RETURN when return type is not a coroutine");
-      static_assert(has_return || has_co_return || !is_coroutine || is_matching_type,
-                    "Expression type does not match the coroutine promise type");
-      static_assert(!Parent::throws || Parent::upper_call_limit == 0,
-                    "CO_THROW and CO_RETURN does not make sense");
-      static_assert(Parent::upper_call_limit > 0,
-                    "CO_RETURN for forbidden call does not make sense");
-
-      constexpr bool valid = !has_return && !has_co_return && is_coroutine && is_matching_type && !Parent::throws && Parent::upper_call_limit > 0;
-      if constexpr (valid)
-      {
-        m.matcher->set_co_return(std::forward<H>(h));
-      }
-      return {m.matcher};
-    }
-  };
-#endif
   struct handle_return
   {
     template <typename Matcher, typename modifier_tag, typename Parent, typename H>
@@ -3488,42 +3260,6 @@ template <typename T>
     }
   };
 
-  #ifdef TROMPELOEIL_COROUTINES_SUPPORTED
-  struct handle_co_throw
-  {
-    template <typename Matcher, typename modifier_tag, typename Parent, typename H>
-    static
-    call_modifier<Matcher, modifier_tag, throw_injector<Parent>>
-    action(call_modifier<Matcher, modifier_tag, Parent>&& m,
-           H&& h)
-    {
-      using signature = typename Parent::signature;
-      using co_return_type = typename Parent::co_return_type;
-      using sigret = return_of_t<signature>;
-      constexpr bool is_coroutine      = trompeloeil::is_coroutine<sigret>::value;
-      static_assert(is_coroutine,
-                    "Do not use CO_THROW from a normal function, use THROW");
-      static_assert(!is_coroutine || !Parent::throws,
-                    "Multiple CO_THROW does not make sense");
-      constexpr bool has_return = !std::is_same<co_return_type, void>::value;
-      static_assert(!is_coroutine || !has_return,
-                    "CO_THROW and CO_RETURN does not make sense");
-
-      constexpr bool forbidden = Parent::upper_call_limit == 0U;
-
-      static_assert(!is_coroutine || !forbidden,
-                    "CO_THROW for forbidden call does not make sense");
-
-      constexpr bool valid = is_coroutine && !Parent::throws && !has_return;
-      if constexpr (valid) {
-        auto handler = co_throw_handler_t<H, signature>(std::forward<H>(h));
-        m.matcher->set_co_return(std::move(handler));
-      }
-      return {m.matcher};
-    }
-  };
-  #endif
-
   struct handle_throw
   {
     template <typename Matcher, typename modifier_tag, typename Parent, typename H>
@@ -3885,16 +3621,6 @@ template <typename T>
                                               std::forward<T>(t)...);
       sequences = std::move(seq);
     }
-#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
-    template <typename E>
-    void
-    add_yield_expr(
-      E&& e)
-    {
-      auto expr = new yield_expr<Sig, E>(std::forward<E>(e));
-      yield_expressions->push_back(expr);
-    }
-#endif
     template <typename T>
     inline
     void
@@ -3913,24 +3639,10 @@ template <typename T>
     set_return(std::false_type, T&&t)//   RETURN
       noexcept;                      //   THROW
 
-#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
-    template <typename T>
-    inline
-    void
-    set_co_return(
-      T&& h)
-    {
-      using basic_t = typename std::remove_reference<T>::type;
-      using handler = co_return_handler_t<Sig, basic_t>;
-      return_handler_obj.reset(new handler(std::forward<T>(h), yield_expressions));
-    }
-#endif
 
     condition_list<Sig>                    conditions;
     side_effect_list<Sig>                  actions;
-#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
-    std::shared_ptr<yield_expr_list<Sig>>  yield_expressions = std::make_shared<yield_expr_list<Sig>>();
-#endif
+    std::shared_ptr<yield_expr_list<Sig>>  yield_expressions;
 
     std::unique_ptr<return_handler<Sig>>   return_handler_obj;
     std::unique_ptr<sequence_handler_base> sequences = detail::make_unique<sequence_handler<0>>();
@@ -4808,35 +4520,6 @@ template <typename T>
     return ::trompeloeil::decay_return_type(__VA_ARGS__);                      \
   })
 
-#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
-
-#define TROMPELOEIL_CO_RETURN(...)    TROMPELOEIL_CO_RETURN_(=, __VA_ARGS__)
-#define TROMPELOEIL_LR_CO_RETURN(...) TROMPELOEIL_CO_RETURN_(&, __VA_ARGS__)
-
-#define TROMPELOEIL_CO_RETURN_(capture, ...)                                   \
-  template action<trompeloeil::handle_co_return>([capture](auto& trompeloeil_x)\
-                                                 -> decltype(auto) {           \
-    auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                        \
-    auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                        \
-    auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                        \
-    auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                        \
-    auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                        \
-    auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                        \
-    auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                        \
-    auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                        \
-    auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                        \
-    auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                       \
-    auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                       \
-    auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                       \
-    auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                       \
-    auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                       \
-    auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                       \
-    ::trompeloeil::ignore(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15); \
-    return ::trompeloeil::decay_return_type(__VA_ARGS__);                      \
-  })
-
-#endif
-
 #endif /* !(TROMPELOEIL_CPLUSPLUS != 201103L) */
 
 
@@ -4869,58 +4552,6 @@ template <typename T>
 
 #endif /* !(TROMPELOEIL_CPLUSPLUS == 201103L) */
 
-#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
-
-#define TROMPELOEIL_CO_THROW(...)    TROMPELOEIL_CO_THROW_(=, __VA_ARGS__)
-#define TROMPELOEIL_LR_CO_THROW(...) TROMPELOEIL_CO_THROW_(&, __VA_ARGS__)
-
-#define TROMPELOEIL_CO_THROW_(capture, ...)                                    \
-  template action<trompeloeil::handle_co_throw>([capture](auto& trompeloeil_x){\
-    auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                        \
-    auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                        \
-    auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                        \
-    auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                        \
-    auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                        \
-    auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                        \
-    auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                        \
-    auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                        \
-    auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                        \
-    auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                       \
-    auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                       \
-    auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                       \
-    auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                       \
-    auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                       \
-    auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                       \
-    ::trompeloeil::ignore(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15); \
-    throw __VA_ARGS__;                                                         \
- })
-
-#define TROMPELOEIL_CO_YIELD(...)    TROMPELOEIL_CO_YIELD_(=, __VA_ARGS__)
-#define TROMPELOEIL_LR_CO_YIELD(...) TROMPELOEIL_CO_YIELD_(&, __VA_ARGS__)
-
-
-#define TROMPELOEIL_CO_YIELD_(capture, ...)                                    \
-  template action<trompeloeil::handle_co_yield>([capture](auto& trompeloeil_x){\
-    auto&& _1 = ::trompeloeil::mkarg<1>(trompeloeil_x);                        \
-    auto&& _2 = ::trompeloeil::mkarg<2>(trompeloeil_x);                        \
-    auto&& _3 = ::trompeloeil::mkarg<3>(trompeloeil_x);                        \
-    auto&& _4 = ::trompeloeil::mkarg<4>(trompeloeil_x);                        \
-    auto&& _5 = ::trompeloeil::mkarg<5>(trompeloeil_x);                        \
-    auto&& _6 = ::trompeloeil::mkarg<6>(trompeloeil_x);                        \
-    auto&& _7 = ::trompeloeil::mkarg<7>(trompeloeil_x);                        \
-    auto&& _8 = ::trompeloeil::mkarg<8>(trompeloeil_x);                        \
-    auto&& _9 = ::trompeloeil::mkarg<9>(trompeloeil_x);                        \
-    auto&&_10 = ::trompeloeil::mkarg<10>(trompeloeil_x);                       \
-    auto&&_11 = ::trompeloeil::mkarg<11>(trompeloeil_x);                       \
-    auto&&_12 = ::trompeloeil::mkarg<12>(trompeloeil_x);                       \
-    auto&&_13 = ::trompeloeil::mkarg<13>(trompeloeil_x);                       \
-    auto&&_14 = ::trompeloeil::mkarg<14>(trompeloeil_x);                       \
-    auto&&_15 = ::trompeloeil::mkarg<15>(trompeloeil_x);                       \
-    ::trompeloeil::ignore(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15); \
-    return __VA_ARGS__;                                                         \
- })
-#endif
-
 
 #define TROMPELOEIL_TIMES(...) template action<trompeloeil::times>(::trompeloeil::multiplicity<__VA_ARGS__>{})
 #define TROMPELOEIL_INFINITY_TIMES() TROMPELOEIL_TIMES(0, ~static_cast<size_t>(0))
@@ -5029,14 +4660,6 @@ template <typename T>
 #define LR_RETURN                 TROMPELOEIL_LR_RETURN
 #define THROW                     TROMPELOEIL_THROW
 #define LR_THROW                  TROMPELOEIL_LR_THROW
-#ifdef TROMPELOEIL_COROUTINES_SUPPORTED
-#define CO_RETURN                 TROMPELOEIL_CO_RETURN
-#define LR_CO_RETURN              TROMPELOEIL_LR_CO_RETURN
-#define CO_THROW                  TROMPELOEIL_CO_THROW
-#define LR_CO_THROW               TROMPELOEIL_LR_CO_THROW
-#define CO_YIELD                  TROMPELOEIL_CO_YIELD
-#define LR_CO_YIELD               TROMPELOEIL_LR_CO_YIELD
-#endif
 #define TIMES                     TROMPELOEIL_TIMES
 #define IN_SEQUENCE               TROMPELOEIL_IN_SEQUENCE
 #define ANY                       TROMPELOEIL_ANY

From a5d1120c6ee28b438f40bb558194cea1fe77dd07 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Fahller?= <bjorn@fahller.se>
Date: Sun, 5 Nov 2023 10:46:08 +0100
Subject: [PATCH 11/20] Removed unneeded #include:s

---
 include/trompeloeil/mock.hpp | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/include/trompeloeil/mock.hpp b/include/trompeloeil/mock.hpp
index c164ea02..7d8de8fa 100644
--- a/include/trompeloeil/mock.hpp
+++ b/include/trompeloeil/mock.hpp
@@ -129,10 +129,8 @@
 #include <exception>
 #include <functional>
 #include <memory>
-#include <cstring>
-#include <regex>
+#include <vector>
 #include <mutex>
-#include <atomic>
 #include <array>
 #include <initializer_list>
 #include <type_traits>

From f1d119cca0e9c840bbd3d978cd7e0abdbf704b5c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Fahller?= <bjorn@fahller.se>
Date: Sun, 5 Nov 2023 10:46:33 +0100
Subject: [PATCH 12/20] Reduced header inclusion in coro tests

---
 test/test_co_mock.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/test/test_co_mock.cpp b/test/test_co_mock.cpp
index f8d89dfb..912e36f2 100644
--- a/test/test_co_mock.cpp
+++ b/test/test_co_mock.cpp
@@ -1,7 +1,8 @@
 #ifdef __cpp_impl_coroutine
 
 #define TROMPELOEIL_EXPERIMENTAL_COROUTINES
-#include <trompeloeil.hpp>
+#include <trompeloeil/mock.hpp>
+#include <trompeloeil/coro.hpp>
 
 #if defined(CATCH2_VERSION) && CATCH2_VERSION == 3
 #include <catch2/catch_test_macros.hpp>

From c3c04b897c89558ccd45e3bd17466eb6eda42423 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Fahller?= <bjorn@fahller.se>
Date: Sun, 5 Nov 2023 11:34:02 +0100
Subject: [PATCH 13/20] Document recent changes in ChangeLog

---
 ChangeLog | 25 +++++++++++++++++++++++--
 1 file changed, 23 insertions(+), 2 deletions(-)

diff --git a/ChangeLog b/ChangeLog
index dd854699..635e72e7 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,16 @@
+	* Split the monolithinc "trompeloeil.hpp" into several smaller
+	  headers. You can continue to #include <trompeloeil.hpp> as usual,
+	  but you can also do more fine grained #include:s, which may
+	  improve build times. E.g.:
+
+	    #include <trompeloeil/mock.hpp> // basic mock functionality
+	    #include <trompeloeil/lifetime.hpp> // REQUIRE_DESTRUCTION etc.
+	    #include <trompeloeil/matcher/re.hpp> // regular expressions
+
+	  The reference manual says which header to include to get the
+	  functionality for each item. If no header is mentioned, it is in
+	  <trompeleil/mock.hpp>
+
 v46 2023-11-06
 
 	* Experimental support for coroutines. Use CO_RETURN (or LR_CO_RETURN)
@@ -11,7 +24,14 @@ v46 2023-11-06
 	    #define TROMPELOEIL_EXPERIMENTAL_COROUTINES
 	    #include <trompeloeil.hpp>
 
-	  trompeloeil::stream_tracer does not produce correct result for coroutines
+	  alternatively
+
+	    #define TROMPELOEIL_EXPERIMENTAL_COROUTINES
+	    #include <trompeloeil/mock.hpp>
+	    #include <trompeloeil/coro.hpp>
+
+	  trompeloeil::stream_tracer does not produce correct result for
+	  coroutines
 
 	* Corrected output of input-range like types. Thank you Dominic Koepke for
 	  the fix.
@@ -22,7 +42,8 @@ v46 2023-11-06
 	* Self test programs are only build when explicitly setting
 	  -DTROMPELOEIL_BUILD_TESTS=yes to the CMake command line.
 
-	* The self test programs require a higher version of CMake (3.19 currently)
+	* The self test programs require a higher version of CMake (3.19
+	  currently)
 
 v45 2023-07-21
 

From 1d1ce7acea8f9620139e78997e2bc5140c24b512 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Fahller?= <bjorn@fahller.se>
Date: Mon, 6 Nov 2023 09:45:59 +0100
Subject: [PATCH 14/20] Break out sequence.hpp

---
 docs/reference.md                |   8 +-
 include/trompeloeil.hpp          |   1 +
 include/trompeloeil/mock.hpp     | 345 ++-------------------------
 include/trompeloeil/sequence.hpp | 391 +++++++++++++++++++++++++++++++
 4 files changed, 421 insertions(+), 324 deletions(-)
 create mode 100644 include/trompeloeil/sequence.hpp

diff --git a/docs/reference.md b/docs/reference.md
index 3ae66e63..7530d955 100644
--- a/docs/reference.md
+++ b/docs/reference.md
@@ -1019,7 +1019,9 @@ Several sequences can be parallel and interleaved. A sequence for an
 [expectation](#expectation) can move forward to the next once the lower
 limit from [**`TIMES(...)`**](#TIMES) is reached (defaults to 1). This means
 that if the lower limit is 0 (see [**`ALLOW_CALL(...)`**](#ALLOW_CALL)), the
-the expectation may be skipped in the sequence.
+expectation may be skipped in the sequence.
+
+`#include <trompeloeil/sequence.hpp>`
 
 Example:
 
@@ -2315,6 +2317,8 @@ which (if any) [expectations](#expectation) there are on the
 Type of object used for fine-tuned control of sequencing of matched
 [expectations](#expectation).
 
+`#include <trompeloeil/sequence.hpp>`
+
 Example:
 
 ```Cpp
@@ -2584,6 +2588,8 @@ unit test frame works.
 Member function of [`sequence`](#sequence_type) object, used to query if
 the sequence it describes is completed or not.
 
+`#include <trompeloeil/sequence.hpp>`
+
 Example:
 
 ```Cpp
diff --git a/include/trompeloeil.hpp b/include/trompeloeil.hpp
index 6a6a4a40..af67d79c 100644
--- a/include/trompeloeil.hpp
+++ b/include/trompeloeil.hpp
@@ -32,6 +32,7 @@
 #include "trompeloeil/matcher/deref.hpp"
 #include "trompeloeil/matcher/not.hpp"
 #include "trompeloeil/matcher/re.hpp"
+#include "trompeloeil/sequence.hpp"
 #include "trompeloeil/stream_tracer.hpp"
 #ifdef __cpp_impl_coroutine
 #include "trompeloeil/coro.hpp"
diff --git a/include/trompeloeil/mock.hpp b/include/trompeloeil/mock.hpp
index 7d8de8fa..219269ce 100644
--- a/include/trompeloeil/mock.hpp
+++ b/include/trompeloeil/mock.hpp
@@ -129,7 +129,6 @@
 #include <exception>
 #include <functional>
 #include <memory>
-#include <vector>
 #include <mutex>
 #include <array>
 #include <initializer_list>
@@ -1617,299 +1616,42 @@ template <typename T>
 
   class sequence_matcher;
 
-  class sequence_type
-  {
-  public:
-    sequence_type() noexcept = default;
-    sequence_type(sequence_type&&) noexcept = delete;
-    sequence_type(const sequence_type&) = delete;
-    sequence_type& operator=(sequence_type&&) noexcept = delete;
-    sequence_type& operator=(const sequence_type&) = delete;
-    ~sequence_type();
-
-    bool
-    is_completed()
-    const
-    noexcept;
-
-    bool
-    is_first(
-      sequence_matcher const *m)
-    const
-    noexcept;
-
-    unsigned
-    cost(
-      sequence_matcher const *m)
-    const
-    noexcept;
-
-    void
-    retire_until(
-      sequence_matcher const* m)
-    noexcept;
-
-    void
-    add_last(
-      sequence_matcher *m)
-    noexcept;
-
-    void
-    validate_match(
-      severity s,
-      sequence_matcher const *matcher,
-      char const *seq_name,
-      char const *match_name,
-      location loc)
-    const;
-
-  private:
-    list<sequence_matcher> matchers;
-  };
-
-  class sequence
-  {
-  public:
-    sequence_type& operator*() { return *obj; }
-    bool is_completed() const { return obj->is_completed(); }
-  private:
-    std::unique_ptr<sequence_type> obj{detail::make_unique<sequence_type>()};
-  };
 
+  class sequence;
   struct sequence_handler_base;
 
-  class sequence_matcher : public list_elem<sequence_matcher>
-  {
-  public:
-    using init_type = std::pair<char const*, sequence&>;
-
-    sequence_matcher(
-      char const *exp,
-      location loc,
-      const sequence_handler_base& handler,
-      init_type i)
-    noexcept
-    : seq_name(i.first)
-    , exp_name(exp)
-    , exp_loc(loc)
-    , sequence_handler(handler)
-    , seq(*i.second)
-    {
-      auto lock = get_lock();
-      seq.add_last(this);
-    }
+  template <size_t N>
+  struct sequence_matchers;
 
+  template <>
+  struct sequence_matchers<0>
+  {
     void
-    validate_match(
-      severity s,
-      char const *match_name,
-      location loc)
-    const
+    validate(
+      severity,
+      char const*,
+      location)
     {
-      seq.validate_match(s, this, seq_name, match_name, loc);
     }
-
     unsigned
-    cost()
-    const
-    noexcept
+    order()
+      const
+      noexcept
     {
-      return seq.cost(this);
+      return 0;
     }
-
-    bool
-    is_satisfied()
-      const
-      noexcept;
-
-    bool
-    is_optional()
-      const
-      noexcept;
-
     void
     retire()
-    noexcept
+      noexcept
     {
-      this->unlink();
     }
-
     void
     retire_predecessors()
-    noexcept
-    {
-      seq.retire_until(this);
-    }
-
-    void
-    print_expectation(std::ostream& os)
-    const
-    {
-      os << exp_name << " at " << exp_loc;
-    }
-
-    char const*
-    sequence_name()
-    const
-    noexcept
+      noexcept
     {
-      return seq_name;
     }
-  private:
-    char const *seq_name;
-    char const *exp_name;
-    location    exp_loc;
-    const sequence_handler_base& sequence_handler;
-    sequence_type& seq;
   };
 
-  inline
-  bool
-  sequence_type::is_completed()
-  const
-  noexcept
-  {
-    for (const auto& matcher : matchers)
-    {
-      if (!matcher.is_satisfied())
-      {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  inline
-  bool
-  sequence_type::is_first(
-    sequence_matcher const *m)
-  const
-  noexcept
-  {
-    return !matchers.empty() && &*matchers.begin() == m;
-  }
-
-  inline
-  unsigned
-  sequence_type::cost(
-    sequence_matcher const* m)
-  const
-  noexcept
-  {
-    unsigned sequence_cost = 0U;
-    for (auto const& e : matchers)
-    {
-      if (&e == m) return sequence_cost;
-      if (!e.is_satisfied())
-      {
-        return ~0U;
-      }
-      ++sequence_cost;
-    }
-    return ~0U;
-  }
-
-  inline
-  void
-  sequence_type::retire_until(
-    sequence_matcher const* m)
-  noexcept
-  {
-    while (!matchers.empty())
-    {
-      auto first = &*matchers.begin();
-      if (first == m) return;
-      first->retire();
-    }
-  }
-
-  inline
-  void
-  sequence_type::validate_match(
-    severity s,
-    sequence_matcher const *matcher,
-    char const* seq_name,
-    char const* match_name,
-    location loc)
-  const
-  {
-    if (is_first(matcher)) return;
-    if (matchers.empty())
-    {
-      std::ostringstream os;
-      os << "Sequence mismatch for sequence \"" << seq_name
-         << "\" with matching call of " << match_name
-         << " at " << loc
-         << ". Sequence \"" << seq_name
-         << "\" has no more pending expectations\n";
-      send_report<specialized>(s, loc, os.str());
-    }
-    bool first = true;
-    std::ostringstream os;
-    os << "Sequence mismatch for sequence \"" << seq_name
-       << "\" with matching call of " << match_name
-       << " at " << loc << ".\n";
-    for (auto const& m : matchers)
-    {
-      if (first || !m.is_optional())
-      {
-        if (first)
-        {
-          os << "Sequence \"" << seq_name << "\" has ";
-        }
-        else
-        {
-          os << "and has ";
-        }
-        m.print_expectation(os);
-        if (m.is_optional())
-        {
-          os << " first in line\n";
-        }
-        else
-        {
-          os << " as first required expectation\n";
-          break;
-        }
-      }
-      first = false;
-    }
-    send_report<specialized>(s, loc, os.str());
-  }
-
-  inline
-  sequence_type::~sequence_type()
-  {
-    bool touched = false;
-    std::ostringstream os;
-    while (!matchers.empty())
-    {
-      auto m = matchers.begin();
-      if (!touched)
-      {
-        os << "Sequence expectations not met at destruction of sequence object \""
-           << m->sequence_name() << "\":";
-        touched = true;
-      }
-      os << "\n  missing ";
-      m->print_expectation(os);
-      m->unlink();
-    }
-    if (touched)
-    {
-      os << "\n";
-      send_report<specialized>(severity::nonfatal, location{}, os.str());
-    }
-  }
-
-  inline
-  void
-  sequence_type::add_last(
-    sequence_matcher *m)
-  noexcept
-  {
-    matchers.push_back(m);
-  }
 
   template <typename T>
   void can_match_parameter(T&);
@@ -2267,23 +2009,6 @@ template <typename T>
     sequence_handler_base(const sequence_handler_base&) = default;
   };
 
-  inline
-  bool
-  sequence_matcher::is_satisfied()
-  const
-  noexcept
-  {
-    return sequence_handler.is_satisfied();
-  }
-
-  inline
-  bool
-  sequence_matcher::is_optional()
-  const
-  noexcept
-  {
-    return sequence_handler.get_min_calls() == 0;
-  }
 
   template <size_t N>
   struct sequence_handler : public sequence_handler_base
@@ -2302,7 +2027,7 @@ template <typename T>
       S&& ... s)
     noexcept
       : sequence_handler_base(base)
-      , matchers{{sequence_matcher{name, loc, *this, std::forward<S>(s)}...}}
+      , matchers{{{sequence_matcher{name, loc, *this, std::forward<S>(s)}...}}}
     {
     }
 
@@ -2313,10 +2038,7 @@ template <typename T>
       location loc)
     override
     {
-      for (auto& e : matchers)
-      {
-        e.validate_match(s, match_name, loc);
-      }
+      matchers.validate(s, match_name, loc);
     }
 
     unsigned
@@ -2325,16 +2047,7 @@ template <typename T>
     noexcept
     override
     {
-      unsigned highest_order = 0U;
-      for (auto& m : matchers)
-      {
-        auto cost = m.cost();
-        if (cost > highest_order)
-        {
-          highest_order = cost;
-        }
-      }
-      return highest_order;
+      return matchers.order();
     }
 
     bool
@@ -2351,10 +2064,7 @@ template <typename T>
     noexcept
     override
     {
-      for (auto& e : matchers)
-      {
-        e.retire();
-      }
+      matchers.retire();
     }
 
     void
@@ -2362,17 +2072,10 @@ template <typename T>
     noexcept
       override
     {
-      for (auto& e : matchers)
-      {
-        e.retire_predecessors();
-      }
+      matchers.retire_predecessors();
     }
   private:
-    // work around for MS STL issue 942
-    // https://github.com/microsoft/STL/issues/942
-    detail::conditional_t<N == 0,
-                          std::vector<sequence_matcher>,
-                          std::array<sequence_matcher, N>> matchers;
+    sequence_matchers<N> matchers;
   };
 
 
@@ -4554,9 +4257,6 @@ template <typename T>
 #define TROMPELOEIL_TIMES(...) template action<trompeloeil::times>(::trompeloeil::multiplicity<__VA_ARGS__>{})
 #define TROMPELOEIL_INFINITY_TIMES() TROMPELOEIL_TIMES(0, ~static_cast<size_t>(0))
 
-#define TROMPELOEIL_IN_SEQUENCE(...)                                           \
-  in_sequence(TROMPELOEIL_INIT_WITH_STR(::trompeloeil::sequence_matcher::init_type, __VA_ARGS__))
-
 #define TROMPELOEIL_ANY(type) ::trompeloeil::any_matcher<type>(#type)
 
 #define TROMPELOEIL_AT_LEAST(num) num, ~static_cast<size_t>(0)
@@ -4659,7 +4359,6 @@ template <typename T>
 #define THROW                     TROMPELOEIL_THROW
 #define LR_THROW                  TROMPELOEIL_LR_THROW
 #define TIMES                     TROMPELOEIL_TIMES
-#define IN_SEQUENCE               TROMPELOEIL_IN_SEQUENCE
 #define ANY                       TROMPELOEIL_ANY
 #define AT_LEAST                  TROMPELOEIL_AT_LEAST
 #define AT_MOST                   TROMPELOEIL_AT_MOST
diff --git a/include/trompeloeil/sequence.hpp b/include/trompeloeil/sequence.hpp
new file mode 100644
index 00000000..9e11a1fb
--- /dev/null
+++ b/include/trompeloeil/sequence.hpp
@@ -0,0 +1,391 @@
+/*
+ * Trompeloeil C++ mocking framework
+ *
+ * Copyright (C) Björn Fahller
+ * Copyright (C) Andrew Paxie
+ *
+ *  Use, modification and distribution is subject to the
+ *  Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy atl
+ *  http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * Project home: https://github.com/rollbear/trompeloeil
+ */
+
+#ifndef TROMPELOEIL_SEQUENCE_HPP
+#define TROMPELOEIL_SEQUENCE_HPP
+
+#include "mock.hpp"
+
+namespace trompeloeil {
+
+  class sequence_type
+  {
+  public:
+    sequence_type() noexcept = default;
+    sequence_type(sequence_type&&) noexcept = delete;
+    sequence_type(const sequence_type&) = delete;
+    sequence_type& operator=(sequence_type&&) noexcept = delete;
+    sequence_type& operator=(const sequence_type&) = delete;
+    ~sequence_type();
+
+    bool
+    is_completed()
+    const
+    noexcept;
+
+    bool
+    is_first(
+      sequence_matcher const *m)
+    const
+    noexcept;
+
+    unsigned
+    cost(
+      sequence_matcher const *m)
+    const
+    noexcept;
+
+    void
+    retire_until(
+      sequence_matcher const* m)
+    noexcept;
+
+    void
+    add_last(
+      sequence_matcher *m)
+    noexcept;
+
+    void
+    validate_match(
+      severity s,
+      sequence_matcher const *matcher,
+      char const *seq_name,
+      char const *match_name,
+      location loc)
+    const;
+
+  private:
+    list<sequence_matcher> matchers;
+  };
+
+  class sequence
+  {
+  public:
+    sequence_type& operator*() { return *obj; }
+    bool is_completed() const { return obj->is_completed(); }
+  private:
+    std::unique_ptr<sequence_type> obj{detail::make_unique<sequence_type>()};
+  };
+
+  class sequence_matcher : public list_elem<sequence_matcher>
+  {
+  public:
+    using init_type = std::pair<char const*, sequence&>;
+
+    sequence_matcher(
+      char const *exp,
+      location loc,
+      const sequence_handler_base& handler,
+      init_type i)
+    noexcept
+      : seq_name(i.first)
+      , exp_name(exp)
+      , exp_loc(loc)
+      , sequence_handler(handler)
+      , seq(*i.second)
+    {
+      auto lock = get_lock();
+      seq.add_last(this);
+    }
+
+    void
+    validate_match(
+      severity s,
+      char const *match_name,
+      location loc)
+    const
+    {
+      seq.validate_match(s, this, seq_name, match_name, loc);
+    }
+
+    unsigned
+    cost()
+    const
+    noexcept
+    {
+      return seq.cost(this);
+    }
+
+    bool
+    is_satisfied()
+    const
+    noexcept;
+
+    bool
+    is_optional()
+    const
+    noexcept;
+
+    void
+    retire()
+    noexcept
+    {
+      this->unlink();
+    }
+
+    void
+    retire_predecessors()
+    noexcept
+    {
+      seq.retire_until(this);
+    }
+
+    void
+    print_expectation(std::ostream& os)
+    const
+    {
+      os << exp_name << " at " << exp_loc;
+    }
+
+    char const*
+    sequence_name()
+    const
+    noexcept
+    {
+      return seq_name;
+    }
+  private:
+    char const *seq_name;
+    char const *exp_name;
+    location    exp_loc;
+    const sequence_handler_base& sequence_handler;
+    sequence_type& seq;
+  };
+
+  inline
+  bool
+  sequence_type::is_completed()
+  const
+  noexcept
+  {
+    for (const auto& matcher : matchers)
+    {
+      if (!matcher.is_satisfied())
+      {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  inline
+  bool
+  sequence_type::is_first(
+    sequence_matcher const *m)
+  const
+  noexcept
+  {
+    return !matchers.empty() && &*matchers.begin() == m;
+  }
+
+  inline
+  unsigned
+  sequence_type::cost(
+    sequence_matcher const* m)
+  const
+  noexcept
+  {
+    unsigned sequence_cost = 0U;
+    for (auto const& e : matchers)
+    {
+      if (&e == m) return sequence_cost;
+      if (!e.is_satisfied())
+      {
+        return ~0U;
+      }
+      ++sequence_cost;
+    }
+    return ~0U;
+  }
+
+  inline
+  void
+  sequence_type::retire_until(
+    sequence_matcher const* m)
+  noexcept
+  {
+    while (!matchers.empty())
+    {
+      auto first = &*matchers.begin();
+      if (first == m) return;
+      first->retire();
+    }
+  }
+
+  inline
+  void
+  sequence_type::validate_match(
+    severity s,
+    sequence_matcher const *matcher,
+    char const* seq_name,
+    char const* match_name,
+    location loc)
+  const
+  {
+    if (is_first(matcher)) return;
+    if (matchers.empty())
+    {
+      std::ostringstream os;
+      os << "Sequence mismatch for sequence \"" << seq_name
+         << "\" with matching call of " << match_name
+         << " at " << loc
+         << ". Sequence \"" << seq_name
+         << "\" has no more pending expectations\n";
+      send_report<specialized>(s, loc, os.str());
+    }
+    bool first = true;
+    std::ostringstream os;
+    os << "Sequence mismatch for sequence \"" << seq_name
+       << "\" with matching call of " << match_name
+       << " at " << loc << ".\n";
+    for (auto const& m : matchers)
+    {
+      if (first || !m.is_optional())
+      {
+        if (first)
+        {
+          os << "Sequence \"" << seq_name << "\" has ";
+        }
+        else
+        {
+          os << "and has ";
+        }
+        m.print_expectation(os);
+        if (m.is_optional())
+        {
+          os << " first in line\n";
+        }
+        else
+        {
+          os << " as first required expectation\n";
+          break;
+        }
+      }
+      first = false;
+    }
+    send_report<specialized>(s, loc, os.str());
+  }
+
+  inline
+  sequence_type::~sequence_type()
+  {
+    bool touched = false;
+    std::ostringstream os;
+    while (!matchers.empty())
+    {
+      auto m = matchers.begin();
+      if (!touched)
+      {
+        os << "Sequence expectations not met at destruction of sequence object \""
+           << m->sequence_name() << "\":";
+        touched = true;
+      }
+      os << "\n  missing ";
+      m->print_expectation(os);
+      m->unlink();
+    }
+    if (touched)
+    {
+      os << "\n";
+      send_report<specialized>(severity::nonfatal, location{}, os.str());
+    }
+  }
+
+  inline
+  void
+  sequence_type::add_last(
+    sequence_matcher *m)
+  noexcept
+  {
+    matchers.push_back(m);
+  }
+
+  inline
+  bool
+  sequence_matcher::is_satisfied()
+  const
+  noexcept
+  {
+    return sequence_handler.is_satisfied();
+  }
+
+  inline
+  bool
+  sequence_matcher::is_optional()
+  const
+  noexcept
+  {
+    return sequence_handler.get_min_calls() == 0;
+  }
+
+  template <size_t N>
+  struct sequence_matchers
+  {
+    void
+    validate(
+      severity s,
+      char const *match_name,
+      location loc)
+    {
+      for (auto& e : matchers)
+      {
+        e.validate_match(s, match_name, loc);
+      }
+    }
+
+    unsigned
+    order()
+      const
+      noexcept
+    {
+      unsigned highest_order = 0U;
+      for (auto &m: matchers) {
+        auto cost = m.cost();
+        if (cost > highest_order) {
+          highest_order = cost;
+        }
+      }
+      return highest_order;
+    }
+    void
+    retire()
+    noexcept
+    {
+      for (auto& e : matchers)
+      {
+        e.retire();
+      }
+    }
+    void
+    retire_predecessors()
+      noexcept
+    {
+      for (auto& e : matchers)
+      {
+        e.retire_predecessors();
+      }
+    }
+
+    std::array<sequence_matcher, N> matchers;
+  };
+}
+
+#define TROMPELOEIL_IN_SEQUENCE(...)                                           \
+  in_sequence(TROMPELOEIL_INIT_WITH_STR(::trompeloeil::sequence_matcher::init_type, __VA_ARGS__))
+
+#ifndef TROMPELOEIL_LONG_MACRCOS
+#define IN_SEQUENCE               TROMPELOEIL_IN_SEQUENCE
+#endif
+
+#endif //TROMPELOEIL_SEQUENCE_HPP

From 302734f38848067e8902ee12e7f4c682f135a295 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Fahller?= <bjorn@fahller.se>
Date: Mon, 6 Nov 2023 11:27:56 +0100
Subject: [PATCH 15/20] Removed dead code

---
 include/trompeloeil/cpp11_shenanigans.hpp |  6 ---
 include/trompeloeil/mock.hpp              | 60 ++---------------------
 2 files changed, 3 insertions(+), 63 deletions(-)

diff --git a/include/trompeloeil/cpp11_shenanigans.hpp b/include/trompeloeil/cpp11_shenanigans.hpp
index b6ac238f..37e0ee7c 100644
--- a/include/trompeloeil/cpp11_shenanigans.hpp
+++ b/include/trompeloeil/cpp11_shenanigans.hpp
@@ -28,12 +28,6 @@ struct unwrap_type<std::reference_wrapper<T>>
 {
 using type = T&;
 };
-template <typename ... Ts>
-std::tuple<typename unwrap_type<typename std::decay<Ts>::type>::type...>
-make_tuple(Ts&& ... ts)
-{
-  return { std::forward<Ts>(ts)... };
-}
 
 /* Implement C++14 features using only C++11 entities. */
 
diff --git a/include/trompeloeil/mock.hpp b/include/trompeloeil/mock.hpp
index 219269ce..ee6d5773 100644
--- a/include/trompeloeil/mock.hpp
+++ b/include/trompeloeil/mock.hpp
@@ -373,17 +373,11 @@ namespace trompeloeil
 
   template <typename R, typename C, typename ... Args>
   identity_type<R(Args...)>
-  nonconst_member_signature(R (C::*)(Args...))
-  {
-    return {};
-  }
+  nonconst_member_signature(R (C::*)(Args...));
 
   template <typename R, typename C, typename ... Args>
   identity_type<R(Args...)>
-  const_member_signature(R (C::*)(Args...) const)
-  {
-    return {};
-  }
+  const_member_signature(R (C::*)(Args...) const);
 
   template <typename ...>
   struct void_t_
@@ -1078,17 +1072,6 @@ template <typename T>
     return false;
   }
 
-  template <typename T>
-  constexpr
-  bool
-  is_null(
-    T const &,
-    std::false_type)
-  noexcept
-  {
-    return false;
-  }
-
   template <typename T>
   constexpr
   bool
@@ -2811,30 +2794,12 @@ template <typename T>
       : matcher{m}
     {}
 
-    template <typename F, typename ... Ts>
-    auto action(Ts&& ... ts) &
-    -> decltype(F::action(*this, std::forward<Ts>(ts)...))
-    {
-        return F::action(*this, std::forward<Ts>(ts)...);
-    }
-    template <typename F, typename ... Ts>
-    auto action(Ts&& ... ts) const &
-    -> decltype(F::action(*this, std::forward<Ts>(ts)...))
-    {
-        return F::action(*this, std::forward<Ts>(ts)...);
-    }
     template <typename F, typename ... Ts>
     auto action(Ts&& ... ts) &&
     -> decltype(F::action(std::move(*this), std::forward<Ts>(ts)...))
     {
         return F::action(std::move(*this), std::forward<Ts>(ts)...);
     }
-    template <typename F, typename ... Ts>
-    auto action(Ts&& ... ts) const &&
-    -> decltype(F::action(std::move(*this), std::forward<Ts>(ts)...))
-    {
-        return F::action(std::move(*this), std::forward<Ts>(ts)...);
-    }
     call_modifier&&
     null_modifier()
     {
@@ -3559,7 +3524,7 @@ template <typename T>
 
   template <typename ... U>
   struct param_helper {
-    using type = decltype(detail::make_tuple(std::declval<U>()...));
+    using type = decltype(std::make_tuple(std::declval<U>()...));
   };
 
   template <typename ... U>
@@ -3570,25 +3535,6 @@ template <typename T>
                                    tag,
                                    matcher_info<sig>>;
 
-  /*
-   * Convert the signature S of a mock function to the signature of
-   * a member function of class T that takes the same parameters P
-   * but returns R.
-   *
-   * The member function has the same constness as the mock function.
-   */
-  template <typename T, typename R, typename S>
-  struct signature_to_member_function;
-
-  template <typename T, typename R, typename R_of_S, typename... P>
-  struct signature_to_member_function<T, R, R_of_S(P...)>
-  {
-    using type = detail::conditional_t<
-      std::is_const<T>::value,
-      R (T::*)(P...) const,
-      R (T::*)(P...)>;
-  };
-
   template <typename T>
   struct mock_interface : public T
   {

From 07ed3e7dcfa36f37b2d4b3935b3c28e5c10abd14 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Fahller?= <bjorn@fahller.se>
Date: Thu, 9 Nov 2023 08:50:25 +0100
Subject: [PATCH 16/20] More compiler-explorer friendly use of #include guards

---
 include/trompeloeil/coro.hpp            | 2 ++
 include/trompeloeil/lifetime.hpp        | 2 ++
 include/trompeloeil/matcher/compare.hpp | 2 ++
 include/trompeloeil/matcher/deref.hpp   | 2 ++
 include/trompeloeil/matcher/not.hpp     | 2 ++
 include/trompeloeil/matcher/re.hpp      | 2 ++
 include/trompeloeil/sequence.hpp        | 2 ++
 include/trompeloeil/stream_tracer.hpp   | 2 ++
 8 files changed, 16 insertions(+)

diff --git a/include/trompeloeil/coro.hpp b/include/trompeloeil/coro.hpp
index 331b8d25..89e850ba 100644
--- a/include/trompeloeil/coro.hpp
+++ b/include/trompeloeil/coro.hpp
@@ -24,7 +24,9 @@
 
 #ifdef TROMPELOEIL_COROUTINES_SUPPORTED
 
+#ifndef TROMPELOEIL_MOCK_HPP_
 #include "mock.hpp"
+#endif
 
 namespace trompeloeil
 {
diff --git a/include/trompeloeil/lifetime.hpp b/include/trompeloeil/lifetime.hpp
index c4b3fa26..207d0cb7 100644
--- a/include/trompeloeil/lifetime.hpp
+++ b/include/trompeloeil/lifetime.hpp
@@ -15,7 +15,9 @@
 #ifndef TROMPELOEIL_LIFETIME_HPP
 #define TROMPELOEIL_LIFETIME_HPP
 
+#ifndef TROMPELOEIL_MOCK_HPP_
 #include "mock.hpp"
+#endif
 
 #if defined(__cxx_rtti) || defined(__GXX_RTTI) || defined(_CPPRTTI)
 #  define TROMPELOEIL_TYPE_ID_NAME(x) typeid(x).name()
diff --git a/include/trompeloeil/matcher/compare.hpp b/include/trompeloeil/matcher/compare.hpp
index b06f8ba2..ea276065 100644
--- a/include/trompeloeil/matcher/compare.hpp
+++ b/include/trompeloeil/matcher/compare.hpp
@@ -15,7 +15,9 @@
 #ifndef TROMPELOEIL_COMPARE_HPP
 #define TROMPELOEIL_COMPARE_HPP
 
+#ifndef TROMPELOEIL_MOCK_HPP_
 #include "../mock.hpp"
+#endif
 
 namespace trompeloeil
 {
diff --git a/include/trompeloeil/matcher/deref.hpp b/include/trompeloeil/matcher/deref.hpp
index 6385f8bc..0811d564 100644
--- a/include/trompeloeil/matcher/deref.hpp
+++ b/include/trompeloeil/matcher/deref.hpp
@@ -16,7 +16,9 @@
 #ifndef TROMPELOEIL_DEREF_HPP
 #define TROMPELOEIL_DEREF_HPP
 
+#ifndef TROMPELOEIL_MOCK_HPP_
 #include "../mock.hpp"
+#endif
 
 namespace trompeloeil {
 
diff --git a/include/trompeloeil/matcher/not.hpp b/include/trompeloeil/matcher/not.hpp
index 2731621c..827456b6 100644
--- a/include/trompeloeil/matcher/not.hpp
+++ b/include/trompeloeil/matcher/not.hpp
@@ -15,7 +15,9 @@
 #ifndef TROMPELOEIL_NOT_HPP
 #define TROMPELOEIL_NOT_HPP
 
+#ifndef TROMPELOEIL_MOCK_HPP_
 #include "../mock.hpp"
+#endif
 
 namespace trompeloeil
 {
diff --git a/include/trompeloeil/matcher/re.hpp b/include/trompeloeil/matcher/re.hpp
index ca49ae07..d9f12470 100644
--- a/include/trompeloeil/matcher/re.hpp
+++ b/include/trompeloeil/matcher/re.hpp
@@ -15,7 +15,9 @@
 #ifndef TROMPELOEIL_RE_HPP
 #define TROMPELOEIL_RE_HPP
 
+#ifndef TROMPELOEIL_MOCK_HPP_
 #include "../mock.hpp"
+#endif
 
 #include <regex>
 #include <cstring>
diff --git a/include/trompeloeil/sequence.hpp b/include/trompeloeil/sequence.hpp
index 9e11a1fb..45ea9a51 100644
--- a/include/trompeloeil/sequence.hpp
+++ b/include/trompeloeil/sequence.hpp
@@ -15,7 +15,9 @@
 #ifndef TROMPELOEIL_SEQUENCE_HPP
 #define TROMPELOEIL_SEQUENCE_HPP
 
+#ifndef TROMPELOEIL_MOCK_HPP_
 #include "mock.hpp"
+#endif
 
 namespace trompeloeil {
 
diff --git a/include/trompeloeil/stream_tracer.hpp b/include/trompeloeil/stream_tracer.hpp
index 7cbf5b63..5a03d018 100644
--- a/include/trompeloeil/stream_tracer.hpp
+++ b/include/trompeloeil/stream_tracer.hpp
@@ -1,7 +1,9 @@
 #ifndef TROMPELOEIL_STREAM_TRACER_HPP
 #define TROMPELOEIL_STREAM_TRACER_HPP
 
+#ifndef TROMPELOEIL_MOCK_HPP_
 #include "mock.hpp"
+#endif
 
 namespace trompeloeil {
 

From 3df9151045e1c3204052982ebde21a7cb1d72fb5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Fahller?= <bjorn@fahller.se>
Date: Thu, 9 Nov 2023 09:26:09 +0100
Subject: [PATCH 17/20] Document which header to use for all
 types/macros/functions

---
 docs/reference.md | 86 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 86 insertions(+)

diff --git a/docs/reference.md b/docs/reference.md
index 7530d955..0238e82d 100644
--- a/docs/reference.md
+++ b/docs/reference.md
@@ -231,6 +231,8 @@ You can also provide [your own matchers](CookBook.md/#custom_matchers).
 Used in the parameter list of an [expectation](#expectation), `trompeloeil::_`
 matches any value of any type.
 
+`#include <trompeloeil/mock.hpp>`
+
 Example:
 
 ```Cpp
@@ -673,6 +675,8 @@ that describes matching calls.
 This is the same as
 [**`REQUIRE_CALL(...)`**](#REQUIRE_CALL).[**`TIMES(`**](#TIMES) 0,infinity **`)`**.
 
+`#include <trompeloeil/mock.hpp>`
+
 Matches any number of times, but is not required to match. (_actually the limit is
 0..~0ULL, but that is for all practical purposes "infinity"_)
 
@@ -719,6 +723,8 @@ A [matcher](#matcher) for use in the parameter list of an
 [expectation](#expectation) to disambiguate overloaded functions on type when
 the exact value is unimportant. See the matcher [**`ANY(`** *type* **`)`**](#ANY) above.
 
+`#include <trompeloeil/mock.hpp>`
+
 <A name="AT_LEAST"/>
 
 ### **`AT_LEAST(`** *number* **`)`**
@@ -727,6 +733,8 @@ Used in [**`TIMES(...)`**](#TIMES) to set the range *number*..infinity.
 *number* must be
 [`constexpr`](http://en.cppreference.com/w/cpp/language/constexpr).
 
+`#include <trompeloeil/mock.hpp>`
+
 Example:
 
 ```Cpp
@@ -762,6 +770,9 @@ Used in [**`TIMES(...)`**](#TIMES) to set the range 0..*number*.
 *number* must be
 [`constexpr`](http://en.cppreference.com/w/cpp/language/constexpr).
 
+`#include <trompeloeil/mock.hpp>`
+
+
 Example:
 
 ```Cpp
@@ -869,6 +880,8 @@ where the wider scope would allow the call. [**`LR_RETURN(...)`**](#LR_RETURN),
 [**`RETURN(...)`**](#RETURN), [**`LR_THROW(...)`**](#LR_THROW) and
 [**`THROW(...)`**](#THROW) are illegal in a **`FORBID_CALL(...)`**.
 
+`#include <trompeloeil/mock.hpp>`
+
 Example:
 
 ```Cpp
@@ -919,6 +932,8 @@ is only usable with `virtual` non-`final` functions, and only when used with
 *specifiers* is an optional list which may include attributes or specifiers like
 [`noexcept`](https://en.cppreference.com/w/cpp/language/noexcept_spec).
 
+`#include <trompeloeil/mock.hpp>`
+
 Example:
 
 ```Cpp
@@ -970,6 +985,8 @@ is only usable with `virtual` non-`final` functions, and only when used with
 *specifiers* is an optional list which may include attributes or specifiers like
 [`noexcept`](https://en.cppreference.com/w/cpp/language/noexcept_spec).
 
+`#include <trompeloeil/mock.hpp>`
+
 Example:
 
 ```Cpp
@@ -1214,6 +1231,8 @@ exactly one of [**`RETURN(...)`**](#RETURN), **`LR_RETURN(...)`**,
 `_2`, etc.
 This code may alter out-parameters.
 
+`#include <trompeloeil/mock.hpp>`
+
 If you need to return an
 [lvalue-reference](http://en.cppreference.com/w/cpp/language/reference),
 to a variable, use
@@ -1267,6 +1286,8 @@ may alter out-parameters. Several **`LR_SIDE_EFFECT(...)`** and
 clauses can be added to a single [expectation](#expectation), and they are
 evaluated in order.
 
+`#include <trompeloeil/mock.hpp>`
+
 Example:
 
 ```Cpp
@@ -1311,6 +1332,8 @@ Used in [expectations](#expectation) to throw after having evaluated every
 [**`LR_RETURN(...)`**](#LR_RETURN) or [**`RETURN(...)`**](#RETURN). Named local
 objects are accessed by reference so lifetime management is important.
 
+`#include <trompeloeil/mock.hpp>`
+
 Example:
 
 ```Cpp
@@ -1357,6 +1380,8 @@ have passed.
 Named local objects are accessed by reference so lifetime management is
 important.
 
+`#include <trompeloeil/mock.hpp>`
+
 Example:
 
 ```Cpp
@@ -1403,6 +1428,8 @@ it is not a requirement. `n` is the number of parameters in *signature*.
 [`override`](http://en.cppreference.com/w/cpp/language/override) or
 [`noexcept`](https://en.cppreference.com/w/cpp/language/noexcept_spec).
 
+`#include <trompeloeil/mock.hpp>`
+
 Example:
 
 ```Cpp
@@ -1449,6 +1476,8 @@ it is not a requirement. `n` is the number of parameters in *signature*.
 [`override`](http://en.cppreference.com/w/cpp/language/override) or
 [`noexcept`](https://en.cppreference.com/w/cpp/language/noexcept_spec).
 
+`#include <trompeloeil/mock.hpp>`
+
 Example:
 
 ```Cpp
@@ -1505,6 +1534,8 @@ Matches any number of times, but is not required to match. (_Actually the limit
 [**`LR_RETURN(...)`**](#LR_RETURN) and [**`LR_THROW(...)`**](#LR_THROW) are
 captured by reference so lifetime management is important.
 
+`#include <trompeloeil/mock.hpp>`
+
 Example:
 
 ```Cpp
@@ -1565,6 +1596,8 @@ scope would allow the call. [**`RETURN(...)`**](#RETURN),
 [**`LR_WITH(...)`**](#LR_WITH) are captured by reference so lifetime management
 is important.
 
+`#include <trompeloeil/mock.hpp>`
+
 Example:
 
 ```Cpp
@@ -1627,6 +1660,8 @@ is destroyed can be changed with an optional [**`TIMES(...)`**](#TIMES) clause.
 [**`LR_RETURN(...)`**](#LR_RETURN) and [**`LR_THROW(...)`**](#LR_THROW) are
 captured by reference so lifetime management is important.
 
+`#include <trompeloeil/mock.hpp>`
+
 Example:
 
 ```Cpp
@@ -1735,6 +1770,8 @@ or [matchers](#matcher) that describes matching parameter values for the
 The number of matches required before the [expectation](#expectation) object
 is destroyed can be changed with an optional [**`TIMES(...)`**](#TIMES) clause.
 
+`#include <trompeloeil/mock.hpp>`
+
 Example:
 
 ```Cpp
@@ -1845,6 +1882,8 @@ This code may alter out-parameters.
 
 Named local objects accessed here refers to a immutable copies.
 
+`#include <trompeloeil/mock.hpp>`
+
 Example:
 
 ```Cpp
@@ -1898,6 +1937,8 @@ evaluated in order.
 
 Named local objects accessed here refers to immutable copies.
 
+`#include <trompeloeil/mock.hpp>`
+
 Example:
 
 ```Cpp
@@ -1946,6 +1987,8 @@ Used in [expectations](#expectation) to throw after having evaluated every
 
 Named local objects here refers to immutable copies.
 
+`#include <trompeloeil/mock.hpp>`
+
 Example:
 
 ```Cpp
@@ -1999,6 +2042,8 @@ If the maximum number of matching calls is exceeded, a violation is reported.
 [**`REQUIRE_CALL(..)`**](#REQUIRE_CALL) or
 [**`NAMED_REQUIRE_CALL(...)`**](#NAMED_REQUIRE_CALL).
 
+`#include <trompeloeil/mock.hpp>`
+
 Example:
 
 ```Cpp
@@ -2045,6 +2090,8 @@ and they are tried in the order until one has failed, or they all have passed.
 
 Named local objects here refers to immutable copies.
 
+`#include <trompeloeil/mock.hpp>`
+
 Example:
 
 ```Cpp
@@ -2142,6 +2189,8 @@ Base class for all [expectations](#expectation). The macros
 [`std::unique_ptr<trompeloeil::expectation>`](http://en.cppreference.com/w/cpp/memory/unique_ptr)
 which you can hold in a variable.
 
+`#include <trompeloeil/mock.hpp>`
+
 ### <A name="expectation_violation_type"/>`trompeloeil::expectation_violation`
 
 The exception type used by default to report violations.
@@ -2156,6 +2205,8 @@ public:
 
 The `what()` string contains the violation report message.
 
+`#include <trompeloeil/mock.hpp>`
+
 ### <A name="lifetime_monitor_type"/>`trompeloeil::lifetime_monitor`
 
 The macro [**`NAMED_REQUIRE_DESTRUCTION(...)`**](#NAMED_REQUIRE_DESTRUCTION)
@@ -2204,6 +2255,8 @@ and [tag dispatch](http://www.generic-programming.org/languages/cpp/techniques.p
 Use it, or [`trompeloeil::typed_matcher<T>`](#typed_matcher), as the base class
 when writing custom [matchers](CookBook.md/#custom_matchers).
 
+`#include <trompeloeil/mock.hpp>`
+
 ### <A name="mock_interface"/>`trompeloeil::mock_interface<T>`
 
 `trompeloeil::mock_interface<T>` is a template useful when creating a mock from
@@ -2217,6 +2270,8 @@ The [**`MAKE_MOCKn(...)`**](#MAKE_MOCKn) and
 
 The interface type `T` must not be final.
 
+`#include <trompeloeil/mock.hpp>`
+
 Example:
 
 ```Cpp
@@ -2254,6 +2309,8 @@ A type used to pass information to the unit testing frame work that a call to a
 using trompeloeil::ok_reporter_func = std::function<const char*>;
 ```
 
+`#include <trompeloeil/mock.hpp>`
+
 The string passed is the parameters to the expectation. E.g.
 
 ```Cpp
@@ -2294,6 +2351,8 @@ second template parameter, which must be `void` if present, is a chance to add
 SFINAE constraints on the T.
 See example in the [Cook Book](CookBook.md/#custom_formatting).
 
+`#include <trompeloeil/mock.hpp>`
+
 ### <A name="reporter_func"/>`trompeloeil::reporter_func`
 
 A type used to pass information to the unit testing frame work that a call has
@@ -2312,6 +2371,8 @@ The parameter `msg` contains detailed information about the violation and
 which (if any) [expectations](#expectation) there are on the
 [mock function](#mock_function).
 
+`#include <trompeloeil/mock.hpp>`
+
 ### <A name="sequence_type"/>`trompeloeil::sequence`
 
 Type of object used for fine-tuned control of sequencing of matched
@@ -2384,6 +2445,8 @@ is called from stack rollback and must not throw, lest
 [`std::terminate`](http://en.cppreference.com/w/cpp/error/terminate) is
 called.
 
+`#include <trompeloeil/mock.hpp>`
+
 ### <A name="stream_tracer"/>`trompeloeil::stream_tracer`
 
 An instance of `trompeloeil::stream_tracer` prints information about
@@ -2412,6 +2475,8 @@ See "[Using `trompeloeil::stream_tracer`](CookBook.md/#stream_tracer)" in the
 
 Base class for tracers. Inherit from it when writing custom tracers.
 
+`#include <trompeloeil/stream_tracer.hpp>`
+
 ```Cpp
 namespace trompeloeil {
 class tracer
@@ -2438,6 +2503,8 @@ type. It inherits from [`trompeloeil::matcher`](#matcher_type).
 See "[Writing custom matchers](CookBook.md/#custom_matchers)" in the
 [Cook Book](CookBook.md) for examples.
 
+`#include <trompeloeil/mock.hpp>`
+
 ## <A name="functions"/>Functions
 
 ### <A name="is_satisfied"/> `trompeloeil::expectation::is_satisfied() const`
@@ -2447,6 +2514,8 @@ it will not report a missing call if it is destroyed. If
 [**`.TIMES()`**](#TIMES) is used, this is true if the minimum number of calls
 has been reached.
 
+`#include <trompeloeil/mock.hpp>`
+
 ```Cpp
 test(...)
 {
@@ -2469,6 +2538,8 @@ Query an [expectation object](#expectation_type) if it is saturated, i.e. if
 another call will report an unexpected call. If [**`.TIMES()`**](#TIMES) is
 used, this is true if the maximum number of calls has been reached.
 
+`#include <trompeloeil/mock.hpp>`
+
 ```Cpp
   ...
   auto e = NAMED_REQUIRE_CALL(mock_obj, func())
@@ -2492,6 +2563,8 @@ Get the global
 [`recursive_mutex`](http://en.cppreference.com/w/cpp/thread/recursive_mutex)
 used by *Trompeloeil*. The mutex is held until the end of the scope.
 
+`#include <trompeloeil/mock.hpp>`
+
 ### <A name="print"/>`trompeloeil::print(std::ostream& os, T const& t)`
 
 By default `print()` uses the type [`printer<T>`](#printer) to format
@@ -2504,12 +2577,18 @@ You can write specializations of
 specializations.  See example in the
 [Cook Book](CookBook.md/#custom_formatting).
 
+`#include <trompeloeil/mock.hpp>`
+
+
 ### <A name="is_null"/>`trompeloeil::is_null(T const&)`
 
 Null check that works for all types. If `T` is not comparable with
 `nullptr` the value is false. This is mostly used when writing
 [duck typed matchers](CookBook.md/#custom_matchers).
 
+`#include <trompeloeil/mock.hpp>`
+
+
 ### <A name="make_matcher"/>`trompeloeil::make_matcher<Type>(...)`
 
 ```Cpp
@@ -2537,6 +2616,9 @@ stored values `T&&...` in order as `const&`.
 Examples are found in the Cook Book under
 [Writing custom matchers](CookBook.md/#custom_matchers)
 
+`#include <trompeloeil/mock.hpp>`
+
+
 ### <A name="set_reporter"/>`trompeloeil::set_reporter(...)`
 
 These functions are used to adapt *Trompeloeil* to your unit test framework
@@ -2549,6 +2631,8 @@ all reports, with the violation message in the `what()` string.
 If this is not suitable, you can change the report mechanism by
 calling `trompeloeil::set_reporter(...)`
 
+`#include <trompeloeil/mock.hpp>`
+
 ```Cpp
 reporter_func
 trompeloeil::set_reporter(std::function<void(trompeloeil::severity,
@@ -2626,6 +2710,8 @@ created lambdas associated with
 to member variables in the mock objects, they will continue to refer the old
 moved from object.
 
+`#include <trompeloeil/mock.hpp>`
+
 ```Cpp
 class immobile
 {

From 49463e685c17b9e95d99b3da70be5e2f0926bc25 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Fahller?= <bjorn@fahller.se>
Date: Sun, 19 Nov 2023 19:36:29 +0100
Subject: [PATCH 18/20] copyright in coro tests

---
 include/trompeloeil/stream_tracer.hpp | 13 +++++++++++++
 test/micro_coro.hpp                   | 13 +++++++++++++
 test/test_co_mock.cpp                 | 13 +++++++++++++
 3 files changed, 39 insertions(+)

diff --git a/include/trompeloeil/stream_tracer.hpp b/include/trompeloeil/stream_tracer.hpp
index 5a03d018..d37291cd 100644
--- a/include/trompeloeil/stream_tracer.hpp
+++ b/include/trompeloeil/stream_tracer.hpp
@@ -1,3 +1,16 @@
+/*
+ * Trompeloeil C++ mocking framework
+ *
+ * Copyright (C) Björn Fahller
+ *
+ *  Use, modification and distribution is subject to the
+ *  Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy atl
+ *  http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * Project home: https://github.com/rollbear/trompeloeil
+ */
+
 #ifndef TROMPELOEIL_STREAM_TRACER_HPP
 #define TROMPELOEIL_STREAM_TRACER_HPP
 
diff --git a/test/micro_coro.hpp b/test/micro_coro.hpp
index 829e9e52..c390cd0b 100644
--- a/test/micro_coro.hpp
+++ b/test/micro_coro.hpp
@@ -1,3 +1,16 @@
+/*
+ * Trompeloeil C++ mocking framework
+ *
+ * Copyright (C) Björn Fahller
+ *
+ *  Use, modification and distribution is subject to the
+ *  Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy atl
+ *  http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * Project home: https://github.com/rollbear/trompeloeil
+ */
+
 #ifndef TROMPELOEIL_MICRO_CORO_HPP
 #define TROMPELOEIL_MICRO_CORO_HPP
 
diff --git a/test/test_co_mock.cpp b/test/test_co_mock.cpp
index 912e36f2..a1f088e1 100644
--- a/test/test_co_mock.cpp
+++ b/test/test_co_mock.cpp
@@ -1,3 +1,16 @@
+/*
+ * Trompeloeil C++ mocking framework
+ *
+ * Copyright (C) Björn Fahller
+ *
+ *  Use, modification and distribution is subject to the
+ *  Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy atl
+ *  http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * Project home: https://github.com/rollbear/trompeloeil
+ */
+
 #ifdef __cpp_impl_coroutine
 
 #define TROMPELOEIL_EXPERIMENTAL_COROUTINES

From 1fe6dbab482f3291acd2b9cfc9c1b1ab2754897d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Fahller?= <bjorn@fahller.se>
Date: Sun, 19 Nov 2023 20:20:15 +0100
Subject: [PATCH 19/20] Break out matcher.hpp

---
 docs/reference.md                       |   8 +-
 include/trompeloeil.hpp                 |   1 +
 include/trompeloeil/matcher.hpp         | 291 ++++++++++++++++++++++++
 include/trompeloeil/matcher/compare.hpp |   4 +-
 include/trompeloeil/matcher/deref.hpp   |   4 +-
 include/trompeloeil/matcher/not.hpp     |   4 +-
 include/trompeloeil/matcher/re.hpp      |   4 +-
 include/trompeloeil/mock.hpp            | 254 ---------------------
 8 files changed, 305 insertions(+), 265 deletions(-)
 create mode 100644 include/trompeloeil/matcher.hpp

diff --git a/docs/reference.md b/docs/reference.md
index 0238e82d..b443cb13 100644
--- a/docs/reference.md
+++ b/docs/reference.md
@@ -267,6 +267,8 @@ of a specified type. This can be used as an alternative to
 [`trompeloeil::_`](#wildcard) when it is important to disambiguate between
 overloads.
 
+`#include <trompeloeil/matcher.hpp>`
+
 Example:
 
 ```Cpp
@@ -723,7 +725,7 @@ A [matcher](#matcher) for use in the parameter list of an
 [expectation](#expectation) to disambiguate overloaded functions on type when
 the exact value is unimportant. See the matcher [**`ANY(`** *type* **`)`**](#ANY) above.
 
-`#include <trompeloeil/mock.hpp>`
+`#include <trompeloeil/matcher.hpp>`
 
 <A name="AT_LEAST"/>
 
@@ -2503,7 +2505,7 @@ type. It inherits from [`trompeloeil::matcher`](#matcher_type).
 See "[Writing custom matchers](CookBook.md/#custom_matchers)" in the
 [Cook Book](CookBook.md) for examples.
 
-`#include <trompeloeil/mock.hpp>`
+`#include <trompeloeil/matcher.hpp>`
 
 ## <A name="functions"/>Functions
 
@@ -2616,7 +2618,7 @@ stored values `T&&...` in order as `const&`.
 Examples are found in the Cook Book under
 [Writing custom matchers](CookBook.md/#custom_matchers)
 
-`#include <trompeloeil/mock.hpp>`
+`#include <trompeloeil/matcher.hpp>`
 
 
 ### <A name="set_reporter"/>`trompeloeil::set_reporter(...)`
diff --git a/include/trompeloeil.hpp b/include/trompeloeil.hpp
index af67d79c..6c40d63c 100644
--- a/include/trompeloeil.hpp
+++ b/include/trompeloeil.hpp
@@ -28,6 +28,7 @@
 
 #include "trompeloeil/mock.hpp"
 #include "trompeloeil/lifetime.hpp"
+#include "trompeloeil/matcher.hpp"
 #include "trompeloeil/matcher/compare.hpp"
 #include "trompeloeil/matcher/deref.hpp"
 #include "trompeloeil/matcher/not.hpp"
diff --git a/include/trompeloeil/matcher.hpp b/include/trompeloeil/matcher.hpp
new file mode 100644
index 00000000..0e6a242d
--- /dev/null
+++ b/include/trompeloeil/matcher.hpp
@@ -0,0 +1,291 @@
+/*
+ * Trompeloeil C++ mocking framework
+ *
+ * Copyright (C) Björn Fahller
+ * Copyright (C) Andrew Paxie
+ *
+ *  Use, modification and distribution is subject to the
+ *  Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy atl
+ *  http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * Project home: https://github.com/rollbear/trompeloeil
+ */
+
+#ifndef TROMPELOEIL_MATCHER_HPP
+#define TROMPELOEIL_MATCHER_HPP
+
+#ifndef TROMPELOEIL_MOCK_HPP_
+#include "mock.hpp"
+#endif
+
+namespace trompeloeil
+{
+  template <typename T>
+  struct typed_matcher : matcher
+  {
+    template <bool b = false>
+    operator T() const {
+        static_assert(b,
+                      "Getting a value from a typed matcher is not allowed.\n"
+                      "See https://github.com/rollbear/trompeloeil/issues/270\n"
+                      "and https://github.com/rollbear/trompeloeil/issues/290");
+        return {};
+    }
+  };
+
+  template <>
+  struct typed_matcher<std::nullptr_t> : matcher
+  {
+    template <
+      typename T,
+      typename = decltype(std::declval<T>() == nullptr)
+    >
+    operator T&&() const
+    {
+      static_assert(std::is_same<T, void>{},
+                    "Getting a value from a typed matcher is not allowed.\n"
+                    "See https://github.com/rollbear/trompeloeil/issues/270\n"
+                    "https://github.com/rollbear/trompeloeil/issues/290");
+      return *this;
+    }
+
+    template <
+      typename T,
+      typename = decltype(std::declval<T>() == nullptr)
+    >
+    operator T&()const volatile
+    {
+      static_assert(std::is_same<T, void>{},
+                    "Getting a value from a typed matcher is not allowed.\n"
+                    "See https://github.com/rollbear/trompeloeil/issues/270\n"
+                    "and https://github.com/rollbear/trompeloeil/issues/290");
+      return *this;
+    }
+
+    template <typename T, typename C>
+    operator T C::*() const
+    {
+      static_assert(std::is_same<C, void>{},
+                    "Getting a value from a typed matcher is not allowed.\n"
+                    "See https://github.com/rollbear/trompeloeil/issues/270\n"
+                    "and https://github.com/rollbear/trompeloeil/issues/290");
+      return *this;
+    }
+  };
+
+  template <typename Pred, typename ... T>
+  class duck_typed_matcher : public matcher
+  {
+  public:
+#if (!TROMPELOEIL_GCC) || \
+    (TROMPELOEIL_GCC && TROMPELOEIL_GCC_VERSION >= 40900)
+
+    // g++ 4.8 gives a "conversion from <T> to <U> is ambiguous" error
+    // if this operator is defined.
+    template <
+      typename V,
+      typename = detail::enable_if_t<!is_matcher<V>{}>,
+      typename = invoke_result_type<Pred, V&&, T...>
+    >
+    operator V&&() const {
+#if !TROMPELOEIL_CLANG || TROMPELOEIL_CLANG_VERSION >= 40000
+      // clang 3.x instantiates the function even when it's only used
+      // for compile time signature checks and never actually called.
+      static_assert(std::is_same<V, void>{},
+                    "Getting a value from a duck typed matcher is not allowed.\n"
+                    "See https://github.com/rollbear/trompeloeil/issues/270\n"
+                    "and https://github.com/rollbear/trompeloeil/issues/290");
+#endif
+      return *this;
+    }
+
+#endif
+
+    template <
+      typename V,
+      typename = detail::enable_if_t<!is_matcher<V>{}>,
+      typename = invoke_result_type<Pred, V&, T...>
+    >
+    operator V&() const volatile
+    {
+      static_assert(std::is_same<V, void>{},
+                    "Getting a value from a duck typed matcher is not allowed.\n"
+                    "See https://github.com/rollbear/trompeloeil/issues/270\n"
+                    "and https://github.com/rollbear/trompeloeil/issues/290");
+
+      return *this;
+    }
+  };
+
+  template <typename MatchType, typename Predicate, typename ... ActualType>
+  struct matcher_kind
+  {
+    using type = typed_matcher<MatchType>;
+  };
+
+  template <typename Predicate, typename ... ActualType>
+  struct matcher_kind<wildcard, Predicate, ActualType...>
+  {
+    using type = duck_typed_matcher<Predicate, ActualType...>;
+  };
+
+  template <typename MatchType, typename Predicate, typename ... ActualType>
+  using matcher_kind_t =
+    typename matcher_kind<MatchType, Predicate, ActualType...>::type;
+
+  template <typename Predicate, typename Printer, typename MatcherType, typename ... T>
+  class predicate_matcher
+    : private Predicate
+      , private Printer
+      , public MatcherType
+  {
+  public:
+    template <typename ... U>
+    constexpr
+    predicate_matcher(
+      Predicate&& pred,
+      Printer&& printer,
+      U&& ... v)
+    noexcept(noexcept(std::tuple<T...>(std::declval<U>()...)) && noexcept(Predicate(std::declval<Predicate&&>())) && noexcept(Printer(std::declval<Printer&&>())))
+      : Predicate(std::move(pred))
+        , Printer(std::move(printer))
+        , value(std::forward<U>(v)...)
+    {}
+
+    template <typename V>
+    constexpr
+    bool
+    matches(
+      V&& v)
+    const
+    noexcept(noexcept(std::declval<Predicate const&>()(std::declval<V&&>(), std::declval<const T&>()...)))
+    {
+      return matches_(std::forward<V>(v), detail::make_index_sequence<sizeof...(T)>{});
+    }
+
+    friend
+    std::ostream&
+    operator<<(
+      std::ostream& os,
+      predicate_matcher const& v)
+    {
+      return v.print_(os, detail::make_index_sequence<sizeof...(T)>{});
+    }
+  private:
+    // The below function call operator must be declared to
+    // work around gcc bug 78446
+    //
+    // For some reason microsoft compiler from VS2015 update 3
+    // requires the function call operator to be private to avoid
+    // ambiguities.
+    template <typename ... U>
+    void operator()(U&&...) const = delete;
+
+    template <typename V, size_t ... I>
+    bool matches_(V&& v, detail::index_sequence<I...>) const
+    {
+      return Predicate::operator()(std::forward<V>(v), std::get<I>(value)...);
+    }
+
+    template <size_t ... I>
+    std::ostream& print_(std::ostream& os_, detail::index_sequence<I...>) const
+    {
+      Printer::operator()(os_, std::get<I>(value)...);
+      return os_;
+    }
+
+    std::tuple<T...> value;
+  };
+
+  template <typename MatchType, typename Predicate, typename Printer, typename ... T>
+  using make_matcher_return =
+    predicate_matcher<Predicate,
+      Printer,
+      matcher_kind_t<MatchType, Predicate, detail::decay_t<T>...>,
+      detail::decay_t<T>...>;
+
+  namespace lambdas {
+
+    struct any_predicate
+    {
+      template <typename T>
+      bool
+      operator()(
+        T&&)
+      const
+      {
+        return true;
+      }
+    };
+
+
+    // Define `struct` with `operator()` to replace generic lambdas.
+
+    struct any_printer
+    {
+      explicit
+      any_printer(
+        char const* type_name_)
+        : type_name(type_name_)
+      {}
+
+      void
+      operator()(
+        std::ostream& os)
+      const
+      {
+        os << " matching ANY(" << type_name << ")";
+      }
+
+    private:
+      char const* type_name;
+    };
+
+  }
+
+  template <typename MatchType, typename Predicate, typename Printer, typename ... T>
+  inline
+  make_matcher_return<MatchType, Predicate, Printer, T...>
+  make_matcher(Predicate pred, Printer print, T&& ... t)
+  {
+    return {std::move(pred), std::move(print), std::forward<T>(t)...};
+  }
+
+
+  template <
+    typename T,
+    typename R = make_matcher_return<T, lambdas::any_predicate, lambdas::any_printer>>
+  inline
+  auto
+  any_matcher_impl(char const* type_name, std::false_type)
+  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+  {
+    return make_matcher<T>(lambdas::any_predicate(), lambdas::any_printer(type_name));
+  }
+
+  template <typename T>
+  wildcard
+  any_matcher_impl(char const*, std::true_type);
+
+  template <typename T>
+  inline
+  auto
+  any_matcher(char const* name)
+  TROMPELOEIL_TRAILING_RETURN_TYPE(decltype(any_matcher_impl<T>(name, std::is_array<T>{})))
+  {
+    static_assert(!std::is_array<T>::value,
+                  "array parameter type decays to pointer type for ANY()"
+                  " matcher. Please rephrase as pointer instead");
+    return any_matcher_impl<T>(name, std::is_array<T>{});
+  }
+
+}
+
+#define TROMPELOEIL_ANY(type) ::trompeloeil::any_matcher<type>(#type)
+
+#ifndef TROMPELOEIL_LONG_MACROS
+#define ANY                       TROMPELOEIL_ANY
+#endif
+
+#endif //TROMPELOEIL_MATCHER_HPP
diff --git a/include/trompeloeil/matcher/compare.hpp b/include/trompeloeil/matcher/compare.hpp
index ea276065..0f1285fa 100644
--- a/include/trompeloeil/matcher/compare.hpp
+++ b/include/trompeloeil/matcher/compare.hpp
@@ -15,8 +15,8 @@
 #ifndef TROMPELOEIL_COMPARE_HPP
 #define TROMPELOEIL_COMPARE_HPP
 
-#ifndef TROMPELOEIL_MOCK_HPP_
-#include "../mock.hpp"
+#ifndef TROMPELOEIL_MATCHER_HPP
+#include "../matcher.hpp"
 #endif
 
 namespace trompeloeil
diff --git a/include/trompeloeil/matcher/deref.hpp b/include/trompeloeil/matcher/deref.hpp
index 0811d564..7104cc02 100644
--- a/include/trompeloeil/matcher/deref.hpp
+++ b/include/trompeloeil/matcher/deref.hpp
@@ -16,8 +16,8 @@
 #ifndef TROMPELOEIL_DEREF_HPP
 #define TROMPELOEIL_DEREF_HPP
 
-#ifndef TROMPELOEIL_MOCK_HPP_
-#include "../mock.hpp"
+#ifndef TROMPELOEIL_MATCHER_HPP
+#include "../matcher.hpp"
 #endif
 
 namespace trompeloeil {
diff --git a/include/trompeloeil/matcher/not.hpp b/include/trompeloeil/matcher/not.hpp
index 827456b6..96323b4b 100644
--- a/include/trompeloeil/matcher/not.hpp
+++ b/include/trompeloeil/matcher/not.hpp
@@ -15,8 +15,8 @@
 #ifndef TROMPELOEIL_NOT_HPP
 #define TROMPELOEIL_NOT_HPP
 
-#ifndef TROMPELOEIL_MOCK_HPP_
-#include "../mock.hpp"
+#ifndef TROMPELOEIL_MATCHER_HPP
+#include "../matcher.hpp"
 #endif
 
 namespace trompeloeil
diff --git a/include/trompeloeil/matcher/re.hpp b/include/trompeloeil/matcher/re.hpp
index d9f12470..9d902abd 100644
--- a/include/trompeloeil/matcher/re.hpp
+++ b/include/trompeloeil/matcher/re.hpp
@@ -15,8 +15,8 @@
 #ifndef TROMPELOEIL_RE_HPP
 #define TROMPELOEIL_RE_HPP
 
-#ifndef TROMPELOEIL_MOCK_HPP_
-#include "../mock.hpp"
+#ifndef TROMPELOEIL_MATCHER_HPP
+#include "../matcher.hpp"
 #endif
 
 #include <regex>
diff --git a/include/trompeloeil/mock.hpp b/include/trompeloeil/mock.hpp
index ee6d5773..8152ee93 100644
--- a/include/trompeloeil/mock.hpp
+++ b/include/trompeloeil/mock.hpp
@@ -877,94 +877,6 @@ template <typename T>
   template <typename T>
   using is_matcher = typename is_detected<matcher_access, T>::type;
 
-  template <typename T>
-  struct typed_matcher : matcher
-  {
-    template <bool b = false>
-    operator T() const {
-        static_assert(b,
-                      "Getting a value from a typed matcher is not allowed.\n"
-                      "See https://github.com/rollbear/trompeloeil/issues/270\n"
-                      "and https://github.com/rollbear/trompeloeil/issues/290");
-        return {};
-    }
-  };
-
-  template <>
-  struct typed_matcher<std::nullptr_t> : matcher
-  {
-    template <typename T,
-              typename = decltype(std::declval<T>() == nullptr)>
-    operator T&&() const
-    {
-      static_assert(std::is_same<T, void>{},
-                    "Getting a value from a typed matcher is not allowed.\n"
-                    "See https://github.com/rollbear/trompeloeil/issues/270\n"
-                    "https://github.com/rollbear/trompeloeil/issues/290");
-      return *this;
-    }
-
-    template <typename T,
-              typename = decltype(std::declval<T>() == nullptr)>
-    operator T&()const volatile
-    {
-      static_assert(std::is_same<T, void>{},
-                    "Getting a value from a typed matcher is not allowed.\n"
-                    "See https://github.com/rollbear/trompeloeil/issues/270\n"
-                    "and https://github.com/rollbear/trompeloeil/issues/290");
-      return *this;
-    }
-
-    template <typename T, typename C>
-    operator T C::*() const
-    {
-      static_assert(std::is_same<C, void>{},
-          "Getting a value from a typed matcher is not allowed.\n"
-          "See https://github.com/rollbear/trompeloeil/issues/270\n"
-          "and https://github.com/rollbear/trompeloeil/issues/290");
-      return *this;
-    }
-  };
-
-  template <typename Pred, typename ... T>
-  class duck_typed_matcher : public matcher
-  {
-  public:
-#if (!TROMPELOEIL_GCC) || \
-    (TROMPELOEIL_GCC && TROMPELOEIL_GCC_VERSION >= 40900)
-
-    // g++ 4.8 gives a "conversion from <T> to <U> is ambiguous" error
-    // if this operator is defined.
-    template <typename V,
-              typename = detail::enable_if_t<!is_matcher<V>{}>,
-              typename = invoke_result_type<Pred, V&&, T...>>
-    operator V&&() const {
-#if !TROMPELOEIL_CLANG || TROMPELOEIL_CLANG_VERSION >= 40000
-      // clang 3.x instantiates the function even when it's only used
-      // for compile time signature checks and never actually called.
-      static_assert(std::is_same<V, void>{},
-                    "Getting a value from a duck typed matcher is not allowed.\n"
-                    "See https://github.com/rollbear/trompeloeil/issues/270\n"
-                    "and https://github.com/rollbear/trompeloeil/issues/290");
-#endif
-      return *this;
-    }
-
-#endif
-
-    template <typename V,
-              typename = detail::enable_if_t<!is_matcher<V>{}>,
-              typename = invoke_result_type<Pred, V&, T...>>
-    operator V&() const volatile
-    {
-      static_assert(std::is_same<V, void>{},
-                    "Getting a value from a duck typed matcher is not allowed.\n"
-                    "See https://github.com/rollbear/trompeloeil/issues/270\n"
-                    "and https://github.com/rollbear/trompeloeil/issues/290");
-
-      return *this;
-    }
-  };
 
   template <typename T>
   using ostream_insertion = decltype(std::declval<std::ostream&>() << std::declval<T>());
@@ -1643,169 +1555,6 @@ template <typename T>
   void can_match_parameter(T&&);
 
 
-
-  template <typename MatchType, typename Predicate, typename ... ActualType>
-  struct matcher_kind
-  {
-    using type = typed_matcher<MatchType>;
-  };
-
-  template <typename Predicate, typename ... ActualType>
-  struct matcher_kind<wildcard, Predicate, ActualType...>
-  {
-    using type = duck_typed_matcher<Predicate, ActualType...>;
-  };
-
-  template <typename MatchType, typename Predicate, typename ... ActualType>
-  using matcher_kind_t =
-    typename matcher_kind<MatchType, Predicate, ActualType...>::type;
-
-  template <typename Predicate, typename Printer, typename MatcherType, typename ... T>
-  class predicate_matcher
-    : private Predicate
-    , private Printer
-    , public MatcherType
-  {
-  public:
-    template <typename ... U>
-    constexpr
-    predicate_matcher(
-      Predicate&& pred,
-      Printer&& printer,
-      U&& ... v)
-      noexcept(noexcept(std::tuple<T...>(std::declval<U>()...)) && noexcept(Predicate(std::declval<Predicate&&>())) && noexcept(Printer(std::declval<Printer&&>())))
-      : Predicate(std::move(pred))
-      , Printer(std::move(printer))
-      , value(std::forward<U>(v)...)
-    {}
-
-    template <typename V>
-    constexpr
-    bool
-    matches(
-      V&& v)
-      const
-      noexcept(noexcept(std::declval<Predicate const&>()(std::declval<V&&>(), std::declval<const T&>()...)))
-    {
-      return matches_(std::forward<V>(v), detail::make_index_sequence<sizeof...(T)>{});
-    }
-
-    friend
-    std::ostream&
-    operator<<(
-      std::ostream& os,
-      predicate_matcher const& v)
-    {
-      return v.print_(os, detail::make_index_sequence<sizeof...(T)>{});
-    }
-  private:
-    // The below function call operator must be declared to
-    // work around gcc bug 78446
-    //
-    // For some reason microsoft compiler from VS2015 update 3
-    // requires the function call operator to be private to avoid
-    // ambiguities.
-    template <typename ... U>
-    void operator()(U&&...) const = delete;
-
-    template <typename V, size_t ... I>
-    bool matches_(V&& v, detail::index_sequence<I...>) const
-    {
-      return Predicate::operator()(std::forward<V>(v), std::get<I>(value)...);
-    }
-
-    template <size_t ... I>
-    std::ostream& print_(std::ostream& os_, detail::index_sequence<I...>) const
-    {
-      Printer::operator()(os_, std::get<I>(value)...);
-      return os_;
-    }
-
-    std::tuple<T...> value;
-  };
-
-  template <typename MatchType, typename Predicate, typename Printer, typename ... T>
-  using make_matcher_return =
-    predicate_matcher<Predicate,
-      Printer,
-      matcher_kind_t<MatchType, Predicate, detail::decay_t<T>...>,
-      detail::decay_t<T>...>;
-
-  namespace lambdas {
-
-    struct any_predicate
-    {
-      template <typename T>
-      bool
-      operator()(
-        T&&)
-      const
-      {
-        return true;
-      }
-    };
-
-
-    // Define `struct` with `operator()` to replace generic lambdas.
-
-    struct any_printer
-    {
-      explicit
-      any_printer(
-        char const* type_name_)
-        : type_name(type_name_)
-      {}
-
-      void
-      operator()(
-        std::ostream& os)
-      const
-      {
-        os << " matching ANY(" << type_name << ")";
-      }
-
-    private:
-      char const* type_name;
-    };
-
-  }
-
-  template <typename MatchType, typename Predicate, typename Printer, typename ... T>
-  inline
-  make_matcher_return<MatchType, Predicate, Printer, T...>
-  make_matcher(Predicate pred, Printer print, T&& ... t)
-  {
-    return {std::move(pred), std::move(print), std::forward<T>(t)...};
-  }
-
-
-  template <
-    typename T,
-    typename R = make_matcher_return<T, lambdas::any_predicate, lambdas::any_printer>>
-  inline
-  auto
-  any_matcher_impl(char const* type_name, std::false_type)
-  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
-  {
-    return make_matcher<T>(lambdas::any_predicate(), lambdas::any_printer(type_name));
-  }
-
-  template <typename T>
-  wildcard
-  any_matcher_impl(char const*, std::true_type);
-
-  template <typename T>
-  inline
-  auto
-  any_matcher(char const* name)
-  TROMPELOEIL_TRAILING_RETURN_TYPE(decltype(any_matcher_impl<T>(name, std::is_array<T>{})))
-  {
-    static_assert(!std::is_array<T>::value,
-                  "array parameter type decays to pointer type for ANY()"
-                  " matcher. Please rephrase as pointer instead");
-    return any_matcher_impl<T>(name, std::is_array<T>{});
-  }
-
   inline
   std::string
   param_name_prefix(
@@ -4203,8 +3952,6 @@ template <typename T>
 #define TROMPELOEIL_TIMES(...) template action<trompeloeil::times>(::trompeloeil::multiplicity<__VA_ARGS__>{})
 #define TROMPELOEIL_INFINITY_TIMES() TROMPELOEIL_TIMES(0, ~static_cast<size_t>(0))
 
-#define TROMPELOEIL_ANY(type) ::trompeloeil::any_matcher<type>(#type)
-
 #define TROMPELOEIL_AT_LEAST(num) num, ~static_cast<size_t>(0)
 #define TROMPELOEIL_AT_MOST(num) 0, num
 
@@ -4305,7 +4052,6 @@ template <typename T>
 #define THROW                     TROMPELOEIL_THROW
 #define LR_THROW                  TROMPELOEIL_LR_THROW
 #define TIMES                     TROMPELOEIL_TIMES
-#define ANY                       TROMPELOEIL_ANY
 #define AT_LEAST                  TROMPELOEIL_AT_LEAST
 #define AT_MOST                   TROMPELOEIL_AT_MOST
 

From 56c5c3e94c3dafb9ecc46613d5e9ddd3244afe70 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Fahller?= <bjorn@fahller.se>
Date: Sun, 19 Nov 2023 20:53:08 +0100
Subject: [PATCH 20/20] Break out of matcher/any.hpp

---
 docs/reference.md                   |  4 +-
 include/trompeloeil.hpp             |  1 +
 include/trompeloeil/matcher.hpp     | 70 ---------------------
 include/trompeloeil/matcher/any.hpp | 98 +++++++++++++++++++++++++++++
 4 files changed, 101 insertions(+), 72 deletions(-)
 create mode 100644 include/trompeloeil/matcher/any.hpp

diff --git a/docs/reference.md b/docs/reference.md
index b443cb13..09f13ab5 100644
--- a/docs/reference.md
+++ b/docs/reference.md
@@ -267,7 +267,7 @@ of a specified type. This can be used as an alternative to
 [`trompeloeil::_`](#wildcard) when it is important to disambiguate between
 overloads.
 
-`#include <trompeloeil/matcher.hpp>`
+`#include <trompeloeil/matcher/any.hpp>`
 
 Example:
 
@@ -725,7 +725,7 @@ A [matcher](#matcher) for use in the parameter list of an
 [expectation](#expectation) to disambiguate overloaded functions on type when
 the exact value is unimportant. See the matcher [**`ANY(`** *type* **`)`**](#ANY) above.
 
-`#include <trompeloeil/matcher.hpp>`
+`#include <trompeloeil/matcher/any.hpp>`
 
 <A name="AT_LEAST"/>
 
diff --git a/include/trompeloeil.hpp b/include/trompeloeil.hpp
index 6c40d63c..4f2ed76f 100644
--- a/include/trompeloeil.hpp
+++ b/include/trompeloeil.hpp
@@ -29,6 +29,7 @@
 #include "trompeloeil/mock.hpp"
 #include "trompeloeil/lifetime.hpp"
 #include "trompeloeil/matcher.hpp"
+#include "trompeloeil/matcher/any.hpp"
 #include "trompeloeil/matcher/compare.hpp"
 #include "trompeloeil/matcher/deref.hpp"
 #include "trompeloeil/matcher/not.hpp"
diff --git a/include/trompeloeil/matcher.hpp b/include/trompeloeil/matcher.hpp
index 0e6a242d..d8c20ab5 100644
--- a/include/trompeloeil/matcher.hpp
+++ b/include/trompeloeil/matcher.hpp
@@ -205,44 +205,6 @@ namespace trompeloeil
       matcher_kind_t<MatchType, Predicate, detail::decay_t<T>...>,
       detail::decay_t<T>...>;
 
-  namespace lambdas {
-
-    struct any_predicate
-    {
-      template <typename T>
-      bool
-      operator()(
-        T&&)
-      const
-      {
-        return true;
-      }
-    };
-
-
-    // Define `struct` with `operator()` to replace generic lambdas.
-
-    struct any_printer
-    {
-      explicit
-      any_printer(
-        char const* type_name_)
-        : type_name(type_name_)
-      {}
-
-      void
-      operator()(
-        std::ostream& os)
-      const
-      {
-        os << " matching ANY(" << type_name << ")";
-      }
-
-    private:
-      char const* type_name;
-    };
-
-  }
 
   template <typename MatchType, typename Predicate, typename Printer, typename ... T>
   inline
@@ -253,39 +215,7 @@ namespace trompeloeil
   }
 
 
-  template <
-    typename T,
-    typename R = make_matcher_return<T, lambdas::any_predicate, lambdas::any_printer>>
-  inline
-  auto
-  any_matcher_impl(char const* type_name, std::false_type)
-  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
-  {
-    return make_matcher<T>(lambdas::any_predicate(), lambdas::any_printer(type_name));
-  }
-
-  template <typename T>
-  wildcard
-  any_matcher_impl(char const*, std::true_type);
-
-  template <typename T>
-  inline
-  auto
-  any_matcher(char const* name)
-  TROMPELOEIL_TRAILING_RETURN_TYPE(decltype(any_matcher_impl<T>(name, std::is_array<T>{})))
-  {
-    static_assert(!std::is_array<T>::value,
-                  "array parameter type decays to pointer type for ANY()"
-                  " matcher. Please rephrase as pointer instead");
-    return any_matcher_impl<T>(name, std::is_array<T>{});
-  }
 
 }
 
-#define TROMPELOEIL_ANY(type) ::trompeloeil::any_matcher<type>(#type)
-
-#ifndef TROMPELOEIL_LONG_MACROS
-#define ANY                       TROMPELOEIL_ANY
-#endif
-
 #endif //TROMPELOEIL_MATCHER_HPP
diff --git a/include/trompeloeil/matcher/any.hpp b/include/trompeloeil/matcher/any.hpp
new file mode 100644
index 00000000..3d499523
--- /dev/null
+++ b/include/trompeloeil/matcher/any.hpp
@@ -0,0 +1,98 @@
+/*
+ * Trompeloeil C++ mocking framework
+ *
+ * Copyright (C) Björn Fahller
+ * Copyright (C) Andrew Paxie
+ *
+ *  Use, modification and distribution is subject to the
+ *  Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy atl
+ *  http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * Project home: https://github.com/rollbear/trompeloeil
+ */
+
+#ifndef TROMPELOEIL_ANY_HPP
+#define TROMPELOEIL_ANY_HPP
+
+#ifndef TROMPELOEIL_MATCHER_HPP
+#include "../matcher.hpp"
+#endif
+
+
+namespace trompeloeil
+{
+  namespace lambdas {
+
+    struct any_predicate
+    {
+      template <typename T>
+      bool
+      operator()(
+        T&&)
+      const
+      {
+        return true;
+      }
+    };
+
+
+    // Define `struct` with `operator()` to replace generic lambdas.
+    struct any_printer
+    {
+      explicit
+      any_printer(
+        char const* type_name_)
+        : type_name(type_name_)
+      {}
+
+      void
+      operator()(
+        std::ostream& os)
+      const
+      {
+        os << " matching ANY(" << type_name << ")";
+      }
+
+    private:
+      char const* type_name;
+    };
+
+  }
+
+  template <
+    typename T,
+    typename R = make_matcher_return<T, lambdas::any_predicate, lambdas::any_printer>>
+  inline
+  auto
+  any_matcher_impl(char const* type_name, std::false_type)
+  TROMPELOEIL_TRAILING_RETURN_TYPE(R)
+  {
+    return make_matcher<T>(lambdas::any_predicate(), lambdas::any_printer(type_name));
+  }
+
+  template <typename T>
+  wildcard
+  any_matcher_impl(char const*, std::true_type);
+
+  template <typename T>
+  inline
+  auto
+  any_matcher(char const* name)
+  TROMPELOEIL_TRAILING_RETURN_TYPE(decltype(any_matcher_impl<T>(name, std::is_array<T>{})))
+  {
+    static_assert(!std::is_array<T>::value,
+                  "array parameter type decays to pointer type for ANY()"
+                  " matcher. Please rephrase as pointer instead");
+    return any_matcher_impl<T>(name, std::is_array<T>{});
+  }
+
+}
+
+#define TROMPELOEIL_ANY(type) ::trompeloeil::any_matcher<type>(#type)
+
+#ifndef TROMPELOEIL_LONG_MACROS
+#define ANY                       TROMPELOEIL_ANY
+#endif
+
+#endif //TROMPELOEIL_ANY_HPP