diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000..38ad09f
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,31 @@
+---
+
+BasedOnStyle: LLVM
+
+ColumnLimit: 120          # Arbitrary, feel free to adjust locally. 0 to ignore.
+PenaltyExcessCharacter: 1 # Softest limit on line length.
+ReflowComments: false     # Best we don't do this without a consistent length limit.
+
+AlwaysBreakTemplateDeclarations: true
+
+AllowShortFunctionsOnASingleLine: Empty
+
+SpaceAfterTemplateKeyword: false
+
+ConstructorInitializerIndentWidth: 2
+ContinuationIndentWidth: 2
+IndentWidth: 2
+
+AllowShortCaseLabelsOnASingleLine: true
+
+DerivePointerAlignment: true
+
+IndentCaseLabels: true
+
+BinPackArguments: false
+BinPackParameters: false
+
+---
+Language: Cpp
+
+...
diff --git a/.gitignore b/.gitignore
index 7c9deb6..596d073 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
 .idea
 cmake-build*
 .DS_Store
+/win_build
diff --git a/CMakeLists.txt b/CMakeLists.txt
index fb95b6a..05f8911 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -7,12 +7,21 @@ cmake_minimum_required(VERSION 3.12)
 project(libstdaudio)
 
 set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
+
+if (MSVC)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4 /WX")
+else ()
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
+endif ()
 
 if (APPLE)
     set(CMAKE_EXE_LINKER_FLAGS "-framework CoreAudio")
 endif ()
 
+if (MSVC)
+    set(CMAKE_EXE_LINKER_FLAGS "winmm.lib")
+endif ()
+
 include_directories(include)
 
 add_executable(white_noise examples/white_noise.cpp)
@@ -24,4 +33,10 @@ add_executable(level_meter examples/level_meter.cpp)
 add_executable(test
         test/test_main.cpp
         test/audio_buffer_test.cpp
-        test/audio_device_test.cpp)
\ No newline at end of file
+        test/audio_device_test.cpp)
+
+if (MSVC)
+add_executable(test_asio
+        test/test_main.cpp
+        test/asio_test.cpp)
+endif ()
\ No newline at end of file
diff --git a/examples/level_meter.cpp b/examples/level_meter.cpp
index 1fc0cae..07c2409 100644
--- a/examples/level_meter.cpp
+++ b/examples/level_meter.cpp
@@ -30,9 +30,9 @@ int main() {
 
     auto& in = *io.input_buffer;
 
-    for (int frame = 0; frame < in.size_frames(); ++frame) {
-      for (int channel = 0; channel < in.size_channels(); ++channel) {
-        float abs_value = std::abs(in(frame, channel));
+    for (size_t frame = 0; frame < in.size_frames(); ++frame) {
+      for (size_t channel = 0; channel < in.size_channels(); ++channel) {
+        const float abs_value = std::abs(in(frame, channel));
 
         if (abs_value > max_abs_value)
           max_abs_value.store(abs_value);
@@ -45,4 +45,4 @@ int main() {
     std::this_thread::sleep_for(std::chrono::milliseconds(250));
     std::cout << gain_to_db(max_abs_value.exchange(0)) << " dB\n";
   }
-}
\ No newline at end of file
+}
diff --git a/examples/melody.cpp b/examples/melody.cpp
index 440260c..70cf61a 100644
--- a/examples/melody.cpp
+++ b/examples/melody.cpp
@@ -3,9 +3,14 @@
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
 
+#ifdef WIN32
+#define _USE_MATH_DEFINES
+#endif
+
 #include <cmath>
 #include <array>
 #include <thread>
+#include <atomic>
 #include <audio>
 
 // This example app plays a short melody using a simple square wave synthesiser.
@@ -21,7 +26,7 @@ constexpr float bpm = 260.0;
 
 float note_to_frequency_hz(int note) {
   constexpr float pitch_standard_hz = 440.0f;
-  return pitch_standard_hz * std::pow(2.0f, float(note - 69) / 12.0f);
+  return pitch_standard_hz * std::pow(2.0f, static_cast<float>(note - 69) / 12.0f);
 }
 
 std::atomic<bool> stop = false;
@@ -30,7 +35,7 @@ struct synthesiser {
   float get_next_sample() {
     assert (_sample_rate > 0);
 
-    _ms_counter += 1000. / _sample_rate;
+    _ms_counter += 1000.0f / _sample_rate;
     if (_ms_counter >= _note_duration_ms) {
       _ms_counter = 0;
       if (++_current_note_index < notes.size()) {
@@ -42,8 +47,8 @@ struct synthesiser {
       }
     }
 
-    auto next_sample = std::copysign(0.1f, std::sin(_phase));
-    _phase = std::fmod(_phase + _delta, 2.0f * float(M_PI));
+    const auto next_sample = std::copysign(0.1f, std::sin(_phase));
+    _phase = std::fmod(_phase + _delta, 2.0f * static_cast<float>(M_PI));
     return next_sample;
   }
 
@@ -54,7 +59,7 @@ struct synthesiser {
 
 private:
   void update() noexcept {
-    float frequency_hz = note_to_frequency_hz(notes.at(_current_note_index));
+    const float frequency_hz = note_to_frequency_hz(notes.at(_current_note_index));
     _delta = 2.0f * frequency_hz * static_cast<float>(M_PI / _sample_rate);
   }
 
@@ -63,7 +68,7 @@ struct synthesiser {
   float _phase = 0;
   float _ms_counter = 0;
   float _note_duration_ms = 60'000.0f / bpm;
-  int _current_note_index = 0;
+  size_t _current_note_index = 0;
 };
 
 
@@ -75,7 +80,7 @@ int main() {
     return 1;
 
   auto synth = synthesiser();
-  synth.set_sample_rate(float(device->get_sample_rate()));
+  synth.set_sample_rate(static_cast<float>(device->get_sample_rate()));
 
   device->connect([=](audio_device&, audio_device_io<float>& io) mutable noexcept {
     if (!io.output_buffer.has_value())
@@ -83,10 +88,10 @@ int main() {
 
     auto& out = *io.output_buffer;
 
-    for (int frame = 0; frame < out.size_frames(); ++frame) {
+    for (size_t frame = 0; frame < out.size_frames(); ++frame) {
       auto next_sample = synth.get_next_sample();
 
-      for (int channel = 0; channel < out.size_channels(); ++channel)
+      for (size_t channel = 0; channel < out.size_channels(); ++channel)
         out(frame, channel) = next_sample;
     }
   });
@@ -95,4 +100,4 @@ int main() {
   while (!stop.load()) {
     std::this_thread::sleep_for(std::chrono::milliseconds(50));
   }
-}
\ No newline at end of file
+}
diff --git a/examples/print_devices.cpp b/examples/print_devices.cpp
index f41aff6..b4a5ac4 100644
--- a/examples/print_devices.cpp
+++ b/examples/print_devices.cpp
@@ -28,7 +28,7 @@ void print_device_info(const audio_device& d) {
   std::cout << "buffer size = " << d.get_buffer_size_frames() << " frames, ";
   std::cout << (d.is_input() ? d.get_num_input_channels() : d.get_num_output_channels()) << " channels";
   std::cout << (is_default_device(d) ? " [DEFAULT DEVICE]\n" : "\n");
-};
+}
 
 void print_device_list(const audio_device_list& list) {
   for (auto& item : list) {
diff --git a/examples/sine_wave.cpp b/examples/sine_wave.cpp
index 92a4682..5360532 100644
--- a/examples/sine_wave.cpp
+++ b/examples/sine_wave.cpp
@@ -3,6 +3,10 @@
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
 
+#ifdef WIN32
+#define _USE_MATH_DEFINES
+#endif
+
 #include <cmath>
 #include <thread>
 #include <audio>
@@ -16,25 +20,25 @@ int main() {
   if (!device)
     return 1;
 
-  float frequency_hz = 440.0f;
-  float delta = 2.0f * frequency_hz * float(M_PI / device->get_sample_rate());
+  constexpr float frequency_hz = 440.0f;
+  const float delta = 2.0f * frequency_hz * static_cast<float>(M_PI / device->get_sample_rate());
   float phase = 0;
 
-  device->connect([=](audio_device& device, audio_device_io<float>& io) mutable noexcept {
+  device->connect([=](audio_device&, audio_device_io<float>& io) mutable noexcept {
     if (!io.output_buffer.has_value())
       return;
 
     auto& out = *io.output_buffer;
 
-    for (int frame = 0; frame < out.size_frames(); ++frame) {
-      float next_sample = std::sin(phase);
-      phase = std::fmod(phase + delta, 2.0f * M_PI);
+    for (size_t frame = 0; frame < out.size_frames(); ++frame) {
+      const float next_sample = std::sin(phase);
+      phase = std::fmod(phase + delta, 2.0f * static_cast<float>(M_PI));
 
-      for (int channel = 0; channel < out.size_channels(); ++channel)
+      for (size_t channel = 0; channel < out.size_channels(); ++channel)
         out(frame, channel) = 0.2f * next_sample;
     }
   });
 
   device->start();
   std::this_thread::sleep_for(std::chrono::seconds(5));
-}
\ No newline at end of file
+}
diff --git a/examples/white_noise.cpp b/examples/white_noise.cpp
index a6d21ce..a587a8a 100644
--- a/examples/white_noise.cpp
+++ b/examples/white_noise.cpp
@@ -23,8 +23,8 @@ int main() {
 
       auto &out = *io.output_buffer;
 
-      for (int frame = 0; frame < out.size_frames(); ++frame)
-        for (int channel = 0; channel < out.size_channels(); ++channel)
+      for (size_t frame = 0; frame < out.size_frames(); ++frame)
+        for (size_t channel = 0; channel < out.size_channels(); ++channel)
           out(frame, channel) = white_noise(gen);
     });
 
diff --git a/include/__audio_buffer.h b/include/__audio_buffer.h
index 6629d07..ddf12e1 100644
--- a/include/__audio_buffer.h
+++ b/include/__audio_buffer.h
@@ -5,6 +5,8 @@
 
 #pragma once
 
+#include <cassert>
+
 #include <chrono>
 
 _LIBSTDAUDIO_NAMESPACE_BEGIN
@@ -30,7 +32,7 @@ class audio_buffer {
       _stride(_num_channels),
       _is_contiguous(true) {
     assert (num_channels <= _max_num_channels);
-    for (auto i = 0; i < _num_channels; ++i) {
+    for (index_type i = 0; i < _num_channels; ++i) {
       _channels[i] = data + i;
     }
   }
@@ -41,12 +43,12 @@ class audio_buffer {
         _stride(1),
         _is_contiguous(true) {
     assert (num_channels <= _max_num_channels);
-    for (auto i = 0; i < _num_channels; ++i) {
+    for (index_type i = 0; i < _num_channels; ++i) {
       _channels[i] = data + (i * _num_frames);
     }
   }
 
-  audio_buffer(sample_type** data, index_type num_frames, index_type num_channels,ptr_to_ptr_deinterleaved_t)
+  audio_buffer(sample_type** data, index_type num_frames, index_type num_channels, ptr_to_ptr_deinterleaved_t)
       : _num_frames(num_frames),
         _num_channels(num_channels),
         _stride(1),
diff --git a/include/audio b/include/audio
index 7e0f98c..2fa467b 100644
--- a/include/audio
+++ b/include/audio
@@ -7,10 +7,6 @@
 
 #include <optional>
 
-// TODO: this is a temporary measure until std::span becomes available
-#include "cpp/span.hpp"
-using namespace TCB_SPAN_NAMESPACE_NAME;
-
 #define _LIBSTDAUDIO_NAMESPACE std::experimental
 
 #define _LIBSTDAUDIO_NAMESPACE_BEGIN namespace _LIBSTDAUDIO_NAMESPACE {
@@ -21,6 +17,8 @@ using namespace TCB_SPAN_NAMESPACE_NAME;
 
 #ifdef __APPLE__
   #include <audio_backend/__coreaudio_backend.h>
+#elif defined _WIN32
+  #include <audio_backend/__asio_backend.h>
 #else
   #include <audio_backend/__null_backend.h>
 #endif // __APPLE__
diff --git a/include/audio_backend/__asio_backend.h b/include/audio_backend/__asio_backend.h
new file mode 100644
index 0000000..8de00a5
--- /dev/null
+++ b/include/audio_backend/__asio_backend.h
@@ -0,0 +1,631 @@
+// libstdaudio
+// Copyright (c) 2019 Andy Saul
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#define NOMINMAX
+#include "iasiodrv.h"
+
+#include <array>
+#include <cassert>
+#include <chrono>
+#include <forward_list>
+#include <functional>
+#include <numeric>
+#include <string_view>
+#include <vector>
+
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+#include <atlbase.h>
+
+_LIBSTDAUDIO_NAMESPACE_BEGIN
+
+using __asio_common_sample_t = float;
+
+struct audio_device_exception : public runtime_error {
+  explicit audio_device_exception(const char* what) : runtime_error(what) {}
+};
+
+template<class _SampleType>
+class __asio_sample {
+public:
+  __asio_sample() = default;
+  explicit __asio_sample(_SampleType value) : _value{value} {}
+
+  template<class _IntegralType = _SampleType, enable_if_t<is_integral<_IntegralType>::value, int> = 0>
+  explicit __asio_sample(float value)
+    : __asio_sample(static_cast<_SampleType>(value * static_cast<double>(numeric_limits<_SampleType>::max()))) {}
+
+  int32_t int_value() const {
+    return _value;
+  }
+
+  template<class _IntegralType = _SampleType, enable_if_t<is_integral<_IntegralType>::value, int> = 0>
+  float float_value() const {
+    return static_cast<float>(_value) / numeric_limits<_SampleType>::max();
+  }
+
+  template<class _FloatType = _SampleType, enable_if_t<is_floating_point<_FloatType>::value, int> = 0>
+  float float_value() const {
+    return static_cast<float>(_value);
+  }
+
+private:
+  _SampleType _value;
+};
+
+struct packed24_t {};
+
+template<>
+class alignas(1) __asio_sample<packed24_t> {
+public:
+  static constexpr int32_t _scale = 0x7f'ffff;
+  __asio_sample() = default;
+  explicit __asio_sample(const uint32_t value)
+    : data{static_cast<int8_t>(value & 0xffu), static_cast<int8_t>((value >> 8u) & 0xffu), static_cast<int8_t>((value >> 16u) & 0xffu)} {
+  }
+  explicit __asio_sample(const float value) : __asio_sample{static_cast<uint32_t>(value * _scale)} {}
+
+  int32_t int_value() const {
+    return ((data[2] << 24) >> 8) | ((data[1] << 8) & 0xff00) | (data[0] & 0xff); // NOLINT(hicpp-signed-bitwise)
+  }
+
+  float float_value() const {
+    return static_cast<float>(int_value()) / _scale;
+  }
+
+private:
+  array<int8_t, 3> data;
+};
+
+enum class audio_direction { in, out, full_duplex };
+
+class audio_device final {
+public:
+  using device_id_t = int;
+
+  explicit audio_device(device_id_t id, string name, IASIO* asio, audio_direction direction)
+    : _name(std::move(name)), _id(id), _asio(asio) {
+    prepare_asio(direction);
+  }
+
+  ~audio_device() {
+    stop();
+    if (!_asio_buffers.empty()) {
+      _asio->disposeBuffers();
+    }
+    instance(nullptr);
+  }
+
+  string_view name() const noexcept {
+    return _name;
+  }
+
+  device_id_t device_id() const noexcept {
+    return _id;
+  }
+
+  bool is_input() const noexcept {
+    return _num_inputs > 0;
+  }
+
+  bool is_output() const noexcept {
+    return _num_outputs > 0;
+  }
+
+  int get_num_input_channels() const noexcept {
+    return _num_inputs;
+  }
+
+  int get_num_output_channels() const noexcept {
+    return _num_outputs;
+  }
+
+  using sample_rate_t = ASIOSampleRate;
+
+  sample_rate_t get_sample_rate() const noexcept {
+    sample_rate_t sample_rate = 0;
+    _asio->getSampleRate(&sample_rate);
+    return sample_rate;
+  }
+
+  bool set_sample_rate(sample_rate_t sample_rate) {
+    const auto result = _asio->setSampleRate(sample_rate);
+    return result == ASE_OK;
+  }
+
+  using buffer_size_t = long;
+
+  buffer_size_t get_buffer_size_frames() const noexcept {
+    return _buffer_size;
+  }
+
+  bool set_buffer_size_frames(const buffer_size_t buffer_size) {
+    if (find(begin(_buffer_sizes), end(_buffer_sizes), buffer_size) == end(_buffer_sizes)) {
+      return false;
+    }
+    _buffer_size = buffer_size;
+    return true;
+  }
+
+  template<class _SampleType>
+  constexpr bool supports_sample_type() const noexcept {
+    return is_same_v<_SampleType, __asio_common_sample_t>;
+  }
+
+  constexpr bool can_connect() const noexcept {
+    return true;
+  }
+
+  constexpr bool can_process() const noexcept {
+    return false;
+  }
+
+  // TODO: remove std::function as soon as C++20 default-ctable lambda and lambda in unevaluated contexts become available
+  using no_op_t = std::function<void(audio_device&)>;
+
+  template<class _StartCallbackType = no_op_t,
+           class _StopCallbackType = no_op_t,
+           // TODO: is_nothrow_invocable_t does not compile, temporarily replaced with is_invocable_t
+           class = enable_if_t<is_invocable_v<_StartCallbackType, audio_device&> && is_invocable_v<_StopCallbackType, audio_device&>>>
+  bool start(_StartCallbackType&& start_callback = [](audio_device&) noexcept {},
+             _StopCallbackType&& stop_callback = [](audio_device&) noexcept {}) {
+
+    // TODO: Implement as per P1386R2 (when published)
+    const auto success = start();
+    if (success) {
+      start_callback(*this);
+    } else {
+      stop_callback(*this);
+    }
+    return success;
+  }
+
+  bool start() {
+    if (_asio_buffers.empty()) {
+      return false;
+    }
+    instance(this);
+    _sample_position = 0;
+    const auto result = _asio->start();
+    _running = result == ASE_OK;
+    return _running;
+  }
+
+  bool stop() {
+    const auto result = _asio->stop();
+    _running = false;
+    return result == ASE_OK;
+  }
+
+  bool is_running() const noexcept {
+    return _running;
+  }
+
+  void wait() const {
+    assert(false);
+  }
+
+  template<class _CallbackType>
+  void process(_CallbackType&) {
+    assert(false);
+  }
+
+  template<class _CallbackType, class = enable_if_t<is_nothrow_invocable_v<_CallbackType, audio_device&, audio_device_io<float>&>>>
+  void connect(_CallbackType callback) {
+    if (_running) {
+      throw audio_device_exception("cannot connect to running audio_device");
+    }
+    _user_callback = move(callback);
+    allocate_buffers();
+  }
+
+private:
+  void prepare_asio(const audio_direction direction) {
+    set_callbacks();
+    query_io(direction);
+    query_sample_rates();
+  }
+
+  void set_callbacks() {
+    _asio_callbacks.bufferSwitch = &audio_device::buffer_switch;
+    _asio_callbacks.bufferSwitchTimeInfo = &audio_device::buffer_switch_time_info;
+    _asio_callbacks.asioMessage = &audio_device::asio_message;
+    _asio_callbacks.sampleRateDidChange = &audio_device::sample_rate_changed;
+  }
+
+  void query_io(const audio_direction direction) {
+    auto result = _asio->getChannels(&_num_inputs, &_num_outputs);
+    if (result != ASE_OK) {
+      return;
+    }
+    switch (direction) {
+      case audio_direction::in: _num_outputs = 0; break;
+      case audio_direction::out: _num_inputs = 0; break;
+      default: break;
+    }
+    long min;
+    long max;
+    long granularity;
+    result = _asio->getBufferSize(&min, &max, &_buffer_size, &granularity);
+    if (result != ASE_OK) {
+      return;
+    }
+    switch (granularity) {
+      default: set_buffers(min, max, granularity); break;
+      case -1: set_buffers_as_powers_of_two(min, max); break;
+      case 0: set_buffers_as_default_size_only(); break;
+    }
+    set_buffer_size_frames(_buffer_size);
+
+    ASIOChannelInfo info{0, is_input()};
+    _asio->getChannelInfo(&info);
+    _sample_type = info.type;
+  }
+
+  void set_buffers(long min, long max, long granularity) {
+    for (long size = min; size <= max; size += granularity) {
+      _buffer_sizes.push_back(size);
+    }
+  }
+
+  void set_buffers_as_powers_of_two(long min, long max) {
+    for (long size = min; size <= max; size *= 2) {
+      _buffer_sizes.push_back(size);
+    }
+  }
+
+  void set_buffers_as_default_size_only() {
+    _buffer_sizes.push_back(_buffer_size);
+  }
+
+  void query_sample_rates() {
+    for (const auto sample_rate : {44'100, 48'000, 88'200, 96'000, 176'400, 192'000}) {
+      if (ASE_OK == _asio->canSampleRate(sample_rate)) {
+        _sample_rates.push_back(sample_rate);
+      }
+    }
+    if (0 == get_sample_rate()) {
+      set_sample_rate(_sample_rates[0]);
+    }
+  }
+
+  void allocate_buffers() {
+    for (int i = 0; i < _num_inputs; ++i) {
+      _asio_buffers.emplace_back(ASIOBufferInfo{true, i});
+    }
+    for (int i = 0; i < _num_outputs; ++i) {
+      _asio_buffers.emplace_back(ASIOBufferInfo{false, i});
+    }
+
+    const long num_channels = _num_inputs + _num_outputs;
+    const auto result = _asio->createBuffers(_asio_buffers.data(), num_channels, _buffer_size, &_asio_callbacks);
+
+    if (result != ASE_OK) {
+      throw audio_device_exception("failed to create ASIO buffers");
+    }
+
+    _input_samples.resize(_num_inputs * _buffer_size);
+    _output_samples.resize(_num_outputs * _buffer_size);
+    _io.input_buffer = {_input_samples.data(), static_cast<size_t>(_buffer_size), static_cast<size_t>(_num_inputs), contiguous_interleaved};
+    _io.output_buffer = {_output_samples.data(), static_cast<size_t>(_buffer_size), static_cast<size_t>(_num_outputs), contiguous_interleaved};
+
+    set_input_reader();
+    set_output_writer();
+  }
+
+  void set_input_reader() {
+
+    if (!is_input()) {
+      _read = [](long) {};
+      return;
+    }
+
+    switch (_sample_type) {
+      case ASIOSTInt32LSB: _read = [this](long index) { read<int32_t>(index); }; break;
+      case ASIOSTInt24LSB: _read = [this](long index) { read<packed24_t>(index); }; break;
+      case ASIOSTInt16LSB: _read = [this](long index) { read<int16_t>(index); }; break;
+      case ASIOSTFloat32LSB: _read = [this](long index) { read<float>(index); }; break;
+      case ASIOSTFloat64LSB: _read = [this](long index) { read<double>(index); }; break;
+
+      default: throw audio_device_exception("ASIO native sample type not supported");
+    }
+  }
+
+  template<class _SampleType>
+  void read(long index) {
+
+    auto& in = *_io.input_buffer;
+    for (int channel = 0; channel < _num_inputs; ++channel) {
+      const auto buffer = static_cast<__asio_sample<_SampleType>*>(_asio_buffers[channel].buffers[index]);
+      for (size_t frame = 0; frame < in.size_frames(); ++frame) {
+        in(frame, channel) = buffer[frame].float_value();
+      }
+    }
+  }
+
+  void set_output_writer() {
+
+    if (!is_output()) {
+      _write = [](long) {};
+      return;
+    }
+
+    switch (_sample_type) {
+      case ASIOSTInt32LSB: _write = [this](long index) { write<int32_t>(index); }; break;
+      case ASIOSTInt24LSB: _write = [this](long index) { write<packed24_t>(index); }; break;
+      case ASIOSTInt16LSB: _write = [this](long index) { write<int16_t>(index); }; break;
+      case ASIOSTFloat32LSB: _write = [this](long index) { write<float>(index); }; break;
+      case ASIOSTFloat64LSB: _write = [this](long index) { write<double>(index); }; break;
+
+      default: throw audio_device_exception("ASIO native sample type not supported");
+    }
+  }
+
+  template<class _SampleType>
+  void write(long index) {
+    using sample = __asio_sample<_SampleType>;
+    auto& out = *_io.output_buffer;
+    for (int channel = 0; channel < _num_outputs; ++channel) {
+      const auto buffer = static_cast<sample*>(_asio_buffers[_num_inputs + channel].buffers[index]);
+      for (size_t frame = 0; frame < out.size_frames(); ++frame) {
+        buffer[frame] = sample(out(frame, channel));
+      }
+    }
+  }
+
+  static void sample_rate_changed(ASIOSampleRate) {}
+
+  static long asio_message(long selector, long, void*, double*) {
+    switch (selector) {
+      case kAsioSupportsTimeInfo: return ASIOTrue;
+      case kAsioEngineVersion: return 2;
+      case kAsioSelectorSupported: return ASIOFalse;
+      default: return ASIOFalse;
+    }
+  }
+
+  static void buffer_switch(long index, ASIOBool) {
+    instance()->on_buffer_switch(index);
+  }
+
+  void on_buffer_switch(long index) {
+    _read(index);
+    _user_callback(*this, _io);
+    _write(index);
+
+    _asio->outputReady();
+  }
+
+  static ASIOTime* buffer_switch_time_info(ASIOTime* time, long index, ASIOBool) {
+    return instance()->on_buffer_switch(time, index);
+  }
+
+  ASIOTime* on_buffer_switch(ASIOTime* time, long index) {
+    _read(index);
+    _user_callback(*this, _io);
+    _write(index);
+
+    time->timeInfo.flags = kSystemTimeValid | kSamplePositionValid; // NOLINT(hicpp-signed-bitwise)
+    time->timeInfo.samplePosition = _sample_position;
+    _sample_position += _buffer_size;
+    time->timeInfo.systemTime = timeGetTime() * 1'000'000;
+    return time;
+  }
+
+  CComPtr<IASIO> _asio;
+  const string _name;
+  device_id_t _id;
+  long _num_inputs{0};
+  long _num_outputs{0};
+  vector<sample_rate_t> _sample_rates;
+  vector<buffer_size_t> _buffer_sizes;
+  buffer_size_t _buffer_size{0};
+  bool _running = false;
+
+  ASIOSampleType _sample_type{};
+  ASIOSamples _sample_position{0};
+
+  using __asio_callback_t = function<void(audio_device&, audio_device_io<__asio_common_sample_t>&)>;
+  __asio_callback_t _user_callback;
+  audio_device_io<__asio_common_sample_t> _io;
+  vector<__asio_common_sample_t> _input_samples;
+  vector<__asio_common_sample_t> _output_samples;
+
+  using fill_buffers = function<void(long index)>;
+  fill_buffers _read;
+  fill_buffers _write;
+
+  vector<ASIOBufferInfo> _asio_buffers;
+  ASIOCallbacks _asio_callbacks{};
+
+  static audio_device* instance(optional<audio_device*> new_device = {}) {
+    static audio_device* device = nullptr;
+    if (new_device.has_value()) {
+      device = *new_device;
+    }
+    return device;
+  }
+};
+
+class audio_device_list : public forward_list<audio_device> {};
+
+class __reg_key final {
+public:
+  __reg_key(HKEY key, const string& subkey) {
+    RegOpenKeyExA(key, subkey.c_str(), 0, KEY_READ, &_key); // NOLINT(hicpp-signed-bitwise)
+  }
+
+  ~__reg_key() {
+    if (_key) {
+      RegCloseKey(_key);
+    }
+  }
+
+  vector<string> subkeys() const {
+    constexpr int max_asio_name_length{32};
+    char name[max_asio_name_length];
+    vector<string> keys;
+
+    for (DWORD index = 0;; ++index) {
+      DWORD size{max_asio_name_length};
+      const auto result = RegEnumKeyEx(_key, index, name, &size, nullptr, nullptr, nullptr, nullptr);
+      if (result != ERROR_SUCCESS) {
+        break;
+      }
+      keys.emplace_back(name);
+    }
+    return keys;
+  }
+
+  __reg_key subkey(const string& name) const {
+    return {_key, name};
+  }
+
+  string value(const char* name) const {
+    DWORD size{0};
+    RegQueryValueExA(_key, name, nullptr, nullptr, nullptr, &size);
+    string value(size + 1, 0);
+    RegQueryValueExA(_key, name, nullptr, nullptr, reinterpret_cast<LPBYTE>(value.data()), &size);
+
+    return value;
+  }
+
+private:
+  HKEY _key{nullptr};
+};
+
+class __asio_devices {
+public:
+  static __asio_devices& get() {
+    static __asio_devices instance;
+    return instance;
+  }
+
+  ~__asio_devices() {
+    CoUninitialize();
+  }
+
+  optional<audio_device> default_input() const {
+    auto devices = inputs();
+    if (devices.empty()) {
+      return {};
+    }
+    return *devices.begin();
+  }
+
+  optional<audio_device> default_output() const {
+    auto devices = outputs();
+    if (devices.empty()) {
+      return {};
+    }
+    return *devices.begin();
+  }
+
+  audio_device_list inputs() const {
+    return enumerate(audio_direction::in);
+  }
+
+  audio_device_list outputs() const {
+    return enumerate(audio_direction::out);
+  }
+
+private:
+  __asio_devices() {
+    CoInitialize(nullptr);
+  }
+
+  audio_device_list enumerate(audio_direction direction) const {
+    audio_device_list devices;
+    _index = 0;
+
+    for (const auto& name : _asio_reg.subkeys()) {
+      auto device = open_device(name, direction);
+      if (device) {
+        devices.push_front(move(*device));
+      }
+    }
+    return devices;
+  }
+
+  optional<audio_device> open_device(const string& name, const audio_direction direction) const {
+    if (is_excluded(name)) {
+      return {};
+    }
+    const auto key = _asio_reg.subkey(name);
+    const auto value = key.value("CLSID");
+
+    CLSID class_id;
+    CLSIDFromString(CComBSTR(value.c_str()), &class_id);
+
+    CComPtr<IASIO> asio;
+    const auto result = CoCreateInstance(class_id, nullptr, CLSCTX_INPROC_SERVER, class_id, reinterpret_cast<void**>(&asio));
+    if (result) {
+      throw audio_device_exception("Failed to open ASIO driver");
+    }
+    if (!is_connected(asio)) {
+      return {};
+    }
+    const auto device = audio_device(_index++, name, asio, direction);
+    if (!is_required(device, direction)) {
+      return {};
+    }
+    return device;
+  }
+
+  static bool is_required(const audio_device& device, const audio_direction direction) {
+    switch (direction) {
+      case audio_direction::in: return device.is_input();
+      case audio_direction::out: return device.is_output();
+      case audio_direction::full_duplex: return device.is_input() && device.is_output();
+      default: return false;
+    }
+  }
+
+  static bool is_excluded(string_view name) {
+    if (name == "Realtek ASIO") {
+      // Realtek ASIO drivers seem unstable
+      // Every other time is IASIO::createBuffers called, it fails with ASE_InvalidMode
+      // Play continues after stop is called
+      return true;
+    }
+    return false;
+  }
+
+  static bool is_connected(IASIO* asio) {
+    return ASIOTrue == asio->init(nullptr);
+  }
+
+  __reg_key _asio_reg{HKEY_LOCAL_MACHINE, R"(software\asio)"};
+  mutable int _index{0};
+};
+
+optional<audio_device> get_default_audio_input_device() {
+  auto& devices = __asio_devices::get();
+  return devices.default_input();
+}
+
+optional<audio_device> get_default_audio_output_device() {
+  auto& devices = __asio_devices::get();
+  return devices.default_output();
+}
+
+audio_device_list get_audio_input_device_list() {
+  auto& devices = __asio_devices::get();
+  return devices.inputs();
+}
+
+audio_device_list get_audio_output_device_list() {
+  auto& devices = __asio_devices::get();
+  return devices.outputs();
+}
+
+template<class F, class /* = enable_if_t<is_nothrow_invocable_v<F>> */>
+void set_audio_device_list_callback(audio_device_list_event, F&&) {
+  // TODO: Implement this.
+}
+
+_LIBSTDAUDIO_NAMESPACE_END
diff --git a/include/audio_backend/__null_backend.h b/include/audio_backend/__null_backend.h
index 0acac07..41113e4 100644
--- a/include/audio_backend/__null_backend.h
+++ b/include/audio_backend/__null_backend.h
@@ -7,6 +7,7 @@
 
 #include <string_view>
 #include <chrono>
+#include <cassert>
 
 _LIBSTDAUDIO_NAMESPACE_BEGIN
 
@@ -40,7 +41,7 @@ class audio_device {
     return 0;
   }
 
-  using sample_rate_t = unsigned;
+  using sample_rate_t = int;
 
   sample_rate_t get_sample_rate() const noexcept {
     return {};
@@ -50,13 +51,13 @@ class audio_device {
     return false;
   }
 
-  using buffer_size_t  = unsigned;
+  using buffer_size_t  = int;
 
   buffer_size_t get_buffer_size_frames() const noexcept {
     return {};
   }
 
-  bool set_buffer_size_frames(buffer_size_t new_buffer_size) {
+  bool set_buffer_size_frames(buffer_size_t) {
     return false;
   }
 
@@ -94,6 +95,11 @@ class audio_device {
     assert(false);
   }
 
+  template <typename _CallbackType>
+  void connect(_CallbackType) {
+    assert(false);
+  }
+
   constexpr bool has_unprocessed_io() const noexcept {
     return false;
   }
@@ -116,6 +122,8 @@ class audio_device_list
 public:
   auto begin() -> iterator { return {}; }
   auto end() -> iterator { return {}; }
+  auto begin() const -> iterator { return {}; }
+  auto end() const -> iterator { return {}; }
   auto empty() -> bool { return true; }
 };
 
@@ -135,4 +143,4 @@ audio_device_list get_audio_output_device_list() {
   return {};
 }
 
-_LIBSTDAUDIO_NAMESPACE_END
\ No newline at end of file
+_LIBSTDAUDIO_NAMESPACE_END
diff --git a/include/audio_backend/asio.h b/include/audio_backend/asio.h
new file mode 100644
index 0000000..341e755
--- /dev/null
+++ b/include/audio_backend/asio.h
@@ -0,0 +1,1070 @@
+//---------------------------------------------------------------------------------------------------
+//---------------------------------------------------------------------------------------------------
+
+/*
+	Steinberg Audio Stream I/O API
+	(c) 1997 - 2013, Steinberg Media Technologies GmbH
+
+	ASIO Interface Specification v 2.3
+
+	2005 - Added support for DSD sample data (in cooperation with Sony)
+	2012 - Added support for drop out detection
+		
+	
+
+	basic concept is an i/o synchronous double-buffer scheme:
+	
+	on bufferSwitch(index == 0), host will read/write:
+
+		after ASIOStart(), the
+  read  first input buffer A (index 0)
+	|   will be invalid (empty)
+	*   ------------------------
+	|------------------------|-----------------------|
+	|                        |                       |
+	|  Input Buffer A (0)    |   Input Buffer B (1)  |
+	|                        |                       |
+	|------------------------|-----------------------|
+	|                        |                       |
+	|  Output Buffer A (0)   |   Output Buffer B (1) |
+	|                        |                       |
+	|------------------------|-----------------------|
+	*                        -------------------------
+	|                        before calling ASIOStart(),
+  write                      host will have filled output
+                             buffer B (index 1) already
+
+  *please* take special care of proper statement of input
+  and output latencies (see ASIOGetLatencies()), these
+  control sequencer sync accuracy
+
+*/
+
+//---------------------------------------------------------------------------------------------------
+//---------------------------------------------------------------------------------------------------
+
+/*
+
+prototypes summary:
+
+ASIOError ASIOInit(ASIODriverInfo *info);
+ASIOError ASIOExit(void);
+ASIOError ASIOStart(void);
+ASIOError ASIOStop(void);
+ASIOError ASIOGetChannels(long *numInputChannels, long *numOutputChannels);
+ASIOError ASIOGetLatencies(long *inputLatency, long *outputLatency);
+ASIOError ASIOGetBufferSize(long *minSize, long *maxSize, long *preferredSize, long *granularity);
+ASIOError ASIOCanSampleRate(ASIOSampleRate sampleRate);
+ASIOError ASIOGetSampleRate(ASIOSampleRate *currentRate);
+ASIOError ASIOSetSampleRate(ASIOSampleRate sampleRate);
+ASIOError ASIOGetClockSources(ASIOClockSource *clocks, long *numSources);
+ASIOError ASIOSetClockSource(long reference);
+ASIOError ASIOGetSamplePosition (ASIOSamples *sPos, ASIOTimeStamp *tStamp);
+ASIOError ASIOGetChannelInfo(ASIOChannelInfo *info);
+ASIOError ASIOCreateBuffers(ASIOBufferInfo *bufferInfos, long numChannels,
+	long bufferSize, ASIOCallbacks *callbacks);
+ASIOError ASIODisposeBuffers(void);
+ASIOError ASIOControlPanel(void);
+void *ASIOFuture(long selector, void *params);
+ASIOError ASIOOutputReady(void);
+
+*/
+
+//---------------------------------------------------------------------------------------------------
+//---------------------------------------------------------------------------------------------------
+
+#ifndef __ASIO_H
+#define __ASIO_H
+
+// force 4 byte alignment
+#if defined(_MSC_VER) && !defined(__MWERKS__) 
+#pragma pack(push,4)
+#elif PRAGMA_ALIGN_SUPPORTED
+#pragma options align = native
+#endif
+
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+// Type definitions
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+
+// number of samples data type is 64 bit integer
+#if NATIVE_INT64
+	typedef long long int ASIOSamples;
+#else
+	typedef struct ASIOSamples {
+		unsigned long hi;
+		unsigned long lo;
+	} ASIOSamples;
+#endif
+
+// Timestamp data type is 64 bit integer,
+// Time format is Nanoseconds.
+#if NATIVE_INT64
+	typedef long long int ASIOTimeStamp ;
+#else
+	typedef struct ASIOTimeStamp {
+		unsigned long hi;
+		unsigned long lo;
+	} ASIOTimeStamp;
+#endif
+
+// Samplerates are expressed in IEEE 754 64 bit double float,
+// native format as host computer
+#if IEEE754_64FLOAT
+	typedef double ASIOSampleRate;
+#else
+	typedef struct ASIOSampleRate {
+		char ieee[8];
+	} ASIOSampleRate;
+#endif
+
+// Boolean values are expressed as long
+typedef long ASIOBool;
+enum {
+	ASIOFalse = 0,
+	ASIOTrue = 1
+};
+
+// Sample Types are expressed as long
+typedef long ASIOSampleType;
+enum {
+	ASIOSTInt16MSB   = 0,
+	ASIOSTInt24MSB   = 1,		// used for 20 bits as well
+	ASIOSTInt32MSB   = 2,
+	ASIOSTFloat32MSB = 3,		// IEEE 754 32 bit float
+	ASIOSTFloat64MSB = 4,		// IEEE 754 64 bit double float
+
+	// these are used for 32 bit data buffer, with different alignment of the data inside
+	// 32 bit PCI bus systems can be more easily used with these
+	ASIOSTInt32MSB16 = 8,		// 32 bit data with 16 bit alignment
+	ASIOSTInt32MSB18 = 9,		// 32 bit data with 18 bit alignment
+	ASIOSTInt32MSB20 = 10,		// 32 bit data with 20 bit alignment
+	ASIOSTInt32MSB24 = 11,		// 32 bit data with 24 bit alignment
+	
+	ASIOSTInt16LSB   = 16,
+	ASIOSTInt24LSB   = 17,		// used for 20 bits as well
+	ASIOSTInt32LSB   = 18,
+	ASIOSTFloat32LSB = 19,		// IEEE 754 32 bit float, as found on Intel x86 architecture
+	ASIOSTFloat64LSB = 20, 		// IEEE 754 64 bit double float, as found on Intel x86 architecture
+
+	// these are used for 32 bit data buffer, with different alignment of the data inside
+	// 32 bit PCI bus systems can more easily used with these
+	ASIOSTInt32LSB16 = 24,		// 32 bit data with 18 bit alignment
+	ASIOSTInt32LSB18 = 25,		// 32 bit data with 18 bit alignment
+	ASIOSTInt32LSB20 = 26,		// 32 bit data with 20 bit alignment
+	ASIOSTInt32LSB24 = 27,		// 32 bit data with 24 bit alignment
+
+	//	ASIO DSD format.
+	ASIOSTDSDInt8LSB1   = 32,		// DSD 1 bit data, 8 samples per byte. First sample in Least significant bit.
+	ASIOSTDSDInt8MSB1   = 33,		// DSD 1 bit data, 8 samples per byte. First sample in Most significant bit.
+	ASIOSTDSDInt8NER8	= 40,		// DSD 8 bit data, 1 sample per byte. No Endianness required.
+
+	ASIOSTLastEntry
+};
+
+/*-----------------------------------------------------------------------------
+// DSD operation and buffer layout
+// Definition by Steinberg/Sony Oxford.
+//
+// We have tried to treat DSD as PCM and so keep a consistant structure across
+// the ASIO interface.
+//
+// DSD's sample rate is normally referenced as a multiple of 44.1Khz, so
+// the standard sample rate is refered to as 64Fs (or 2.8224Mhz). We looked
+// at making a special case for DSD and adding a field to the ASIOFuture that
+// would allow the user to select the Over Sampleing Rate (OSR) as a seperate
+// entity but decided in the end just to treat it as a simple value of
+// 2.8224Mhz and use the standard interface to set it.
+//
+// The second problem was the "word" size, in PCM the word size is always a
+// greater than or equal to 8 bits (a byte). This makes life easy as we can
+// then pack the samples into the "natural" size for the machine.
+// In DSD the "word" size is 1 bit. This is not a major problem and can easily
+// be dealt with if we ensure that we always deal with a multiple of 8 samples.
+//
+// DSD brings with it another twist to the Endianness religion. How are the
+// samples packed into the byte. It would be nice to just say the most significant
+// bit is always the first sample, however there would then be a performance hit
+// on little endian machines. Looking at how some of the processing goes...
+// Little endian machines like the first sample to be in the Least Significant Bit,
+//   this is because when you write it to memory the data is in the correct format
+//   to be shifted in and out of the words.
+// Big endian machine prefer the first sample to be in the Most Significant Bit,
+//   again for the same reasion.
+//
+// And just when things were looking really muddy there is a proposed extension to
+// DSD that uses 8 bit word sizes. It does not care what endianness you use.
+//
+// Switching the driver between DSD and PCM mode
+// ASIOFuture allows for extending the ASIO API quite transparently.
+// See kAsioSetIoFormat, kAsioGetIoFormat, kAsioCanDoIoFormat
+//
+//-----------------------------------------------------------------------------*/
+
+
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+// Error codes
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+
+typedef long ASIOError;
+enum {
+	ASE_OK = 0,             // This value will be returned whenever the call succeeded
+	ASE_SUCCESS = 0x3f4847a0,	// unique success return value for ASIOFuture calls
+	ASE_NotPresent = -1000, // hardware input or output is not present or available
+	ASE_HWMalfunction,      // hardware is malfunctioning (can be returned by any ASIO function)
+	ASE_InvalidParameter,   // input parameter invalid
+	ASE_InvalidMode,        // hardware is in a bad mode or used in a bad mode
+	ASE_SPNotAdvancing,     // hardware is not running when sample position is inquired
+	ASE_NoClock,            // sample clock or rate cannot be determined or is not present
+	ASE_NoMemory            // not enough memory for completing the request
+};
+
+//---------------------------------------------------------------------------------------------------
+//---------------------------------------------------------------------------------------------------
+
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+// Time Info support
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+
+typedef struct ASIOTimeCode
+{       
+	double          speed;                  // speed relation (fraction of nominal speed)
+	                                        // optional; set to 0. or 1. if not supported
+	ASIOSamples     timeCodeSamples;        // time in samples
+	unsigned long   flags;                  // some information flags (see below)
+	char future[64];
+} ASIOTimeCode;
+
+typedef enum ASIOTimeCodeFlags
+{
+	kTcValid                = 1,
+	kTcRunning              = 1 << 1,
+	kTcReverse              = 1 << 2,
+	kTcOnspeed              = 1 << 3,
+	kTcStill                = 1 << 4,
+	
+	kTcSpeedValid           = 1 << 8
+}  ASIOTimeCodeFlags;
+
+typedef struct AsioTimeInfo
+{
+	double          speed;                  // absolute speed (1. = nominal)
+	ASIOTimeStamp   systemTime;             // system time related to samplePosition, in nanoseconds
+	                                        // on mac, must be derived from Microseconds() (not UpTime()!)
+	                                        // on windows, must be derived from timeGetTime()
+	ASIOSamples     samplePosition;
+	ASIOSampleRate  sampleRate;             // current rate
+	unsigned long flags;                    // (see below)
+	char reserved[12];
+} AsioTimeInfo;
+
+typedef enum AsioTimeInfoFlags
+{
+	kSystemTimeValid        = 1,            // must always be valid
+	kSamplePositionValid    = 1 << 1,       // must always be valid
+	kSampleRateValid        = 1 << 2,
+	kSpeedValid             = 1 << 3,
+	
+	kSampleRateChanged      = 1 << 4,
+	kClockSourceChanged     = 1 << 5
+} AsioTimeInfoFlags;
+
+typedef struct ASIOTime                          // both input/output
+{
+	long reserved[4];                       // must be 0
+	struct AsioTimeInfo     timeInfo;       // required
+	struct ASIOTimeCode     timeCode;       // optional, evaluated if (timeCode.flags & kTcValid)
+} ASIOTime;
+
+/*
+
+using time info:
+it is recommended to use the new method with time info even if the asio
+device does not support timecode; continuous calls to ASIOGetSamplePosition
+and ASIOGetSampleRate are avoided, and there is a more defined relationship
+between callback time and the time info.
+
+see the example below.
+to initiate time info mode, after you have received the callbacks pointer in
+ASIOCreateBuffers, you will call the asioMessage callback with kAsioSupportsTimeInfo
+as the argument. if this returns 1, host has accepted time info mode.
+now host expects the new callback bufferSwitchTimeInfo to be used instead
+of the old bufferSwitch method. the ASIOTime structure is assumed to be valid
+and accessible until the callback returns.
+
+using time code:
+if the device supports reading time code, it will call host's asioMessage callback
+with kAsioSupportsTimeCode as the selector. it may then fill the according
+fields and set the kTcValid flag.
+host will call the future method with the kAsioEnableTimeCodeRead selector when
+it wants to enable or disable tc reading by the device. you should also support
+the kAsioCanTimeInfo and kAsioCanTimeCode selectors in ASIOFuture (see example).
+
+note:
+the AsioTimeInfo/ASIOTimeCode pair is supposed to work in both directions.
+as a matter of convention, the relationship between the sample
+position counter and the time code at buffer switch time is
+(ignoring offset between tc and sample pos when tc is running):
+
+on input:	sample 0 -> input  buffer sample 0 -> time code 0
+on output:	sample 0 -> output buffer sample 0 -> time code 0
+
+this means that for 'real' calculations, one has to take into account
+the according latencies.
+
+example:
+
+ASIOTime asioTime;
+
+in createBuffers()
+{
+	memset(&asioTime, 0, sizeof(ASIOTime));
+	AsioTimeInfo* ti = &asioTime.timeInfo;
+	ti->sampleRate = theSampleRate;
+	ASIOTimeCode* tc = &asioTime.timeCode;
+	tc->speed = 1.;
+	timeInfoMode = false;
+	canTimeCode = false;
+	if(callbacks->asioMessage(kAsioSupportsTimeInfo, 0, 0, 0) == 1)
+	{
+		timeInfoMode = true;
+#if kCanTimeCode
+		if(callbacks->asioMessage(kAsioSupportsTimeCode, 0, 0, 0) == 1)
+			canTimeCode = true;
+#endif
+	}
+}
+
+void switchBuffers(long doubleBufferIndex, bool processNow)
+{
+	if(timeInfoMode)
+	{
+		AsioTimeInfo* ti = &asioTime.timeInfo;
+		ti->flags =	kSystemTimeValid | kSamplePositionValid | kSampleRateValid;
+		ti->systemTime = theNanoSeconds;
+		ti->samplePosition = theSamplePosition;
+		if(ti->sampleRate != theSampleRate)
+			ti->flags |= kSampleRateChanged;
+		ti->sampleRate = theSampleRate;
+
+#if kCanTimeCode
+		if(canTimeCode && timeCodeEnabled)
+		{
+			ASIOTimeCode* tc = &asioTime.timeCode;
+			tc->timeCodeSamples = tcSamples;						// tc in samples
+			tc->flags = kTcValid | kTcRunning | kTcOnspeed;			// if so...
+		}
+		ASIOTime* bb = callbacks->bufferSwitchTimeInfo(&asioTime, doubleBufferIndex, processNow ? ASIOTrue : ASIOFalse);
+#else
+		callbacks->bufferSwitchTimeInfo(&asioTime, doubleBufferIndex, processNow ? ASIOTrue : ASIOFalse);
+#endif
+	}
+	else
+		callbacks->bufferSwitch(doubleBufferIndex, ASIOFalse);
+}
+
+ASIOError ASIOFuture(long selector, void *params)
+{
+	switch(selector)
+	{
+		case kAsioEnableTimeCodeRead:
+			timeCodeEnabled = true;
+			return ASE_SUCCESS;
+		case kAsioDisableTimeCodeRead:
+			timeCodeEnabled = false;
+			return ASE_SUCCESS;
+		case kAsioCanTimeInfo:
+			return ASE_SUCCESS;
+		#if kCanTimeCode
+		case kAsioCanTimeCode:
+			return ASE_SUCCESS;
+		#endif
+	}
+	return ASE_NotPresent;
+};
+
+*/
+
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+// application's audio stream handler callbacks
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+
+typedef struct ASIOCallbacks
+{
+	void (*bufferSwitch) (long doubleBufferIndex, ASIOBool directProcess);
+		// bufferSwitch indicates that both input and output are to be processed.
+		// the current buffer half index (0 for A, 1 for B) determines
+		// - the output buffer that the host should start to fill. the other buffer
+		//   will be passed to output hardware regardless of whether it got filled
+		//   in time or not.
+		// - the input buffer that is now filled with incoming data. Note that
+		//   because of the synchronicity of i/o, the input always has at
+		//   least one buffer latency in relation to the output.
+		// directProcess suggests to the host whether it should immedeately
+		// start processing (directProcess == ASIOTrue), or whether its process
+		// should be deferred because the call comes from a very low level
+		// (for instance, a high level priority interrupt), and direct processing
+		// would cause timing instabilities for the rest of the system. If in doubt,
+		// directProcess should be set to ASIOFalse.
+		// Note: bufferSwitch may be called at interrupt time for highest efficiency.
+
+	void (*sampleRateDidChange) (ASIOSampleRate sRate);
+		// gets called when the AudioStreamIO detects a sample rate change
+		// If sample rate is unknown, 0 is passed (for instance, clock loss
+		// when externally synchronized).
+
+	long (*asioMessage) (long selector, long value, void* message, double* opt);
+		// generic callback for various purposes, see selectors below.
+		// note this is only present if the asio version is 2 or higher
+
+	ASIOTime* (*bufferSwitchTimeInfo) (ASIOTime* params, long doubleBufferIndex, ASIOBool directProcess);
+		// new callback with time info. makes ASIOGetSamplePosition() and various
+		// calls to ASIOGetSampleRate obsolete,
+		// and allows for timecode sync etc. to be preferred; will be used if
+		// the driver calls asioMessage with selector kAsioSupportsTimeInfo.
+} ASIOCallbacks;
+
+// asioMessage selectors
+enum
+{
+	kAsioSelectorSupported = 1,	// selector in <value>, returns 1L if supported,
+								// 0 otherwise
+    kAsioEngineVersion,			// returns engine (host) asio implementation version,
+								// 2 or higher
+	kAsioResetRequest,			// request driver reset. if accepted, this
+								// will close the driver (ASIO_Exit() ) and
+								// re-open it again (ASIO_Init() etc). some
+								// drivers need to reconfigure for instance
+								// when the sample rate changes, or some basic
+								// changes have been made in ASIO_ControlPanel().
+								// returns 1L; note the request is merely passed
+								// to the application, there is no way to determine
+								// if it gets accepted at this time (but it usually
+								// will be).
+	kAsioBufferSizeChange,		// not yet supported, will currently always return 0L.
+								// for now, use kAsioResetRequest instead.
+								// once implemented, the new buffer size is expected
+								// in <value>, and on success returns 1L
+	kAsioResyncRequest,			// the driver went out of sync, such that
+								// the timestamp is no longer valid. this
+								// is a request to re-start the engine and
+								// slave devices (sequencer). returns 1 for ok,
+								// 0 if not supported.
+	kAsioLatenciesChanged, 		// the drivers latencies have changed. The engine
+								// will refetch the latencies.
+	kAsioSupportsTimeInfo,		// if host returns true here, it will expect the
+								// callback bufferSwitchTimeInfo to be called instead
+								// of bufferSwitch
+	kAsioSupportsTimeCode,		// 
+	kAsioMMCCommand,			// unused - value: number of commands, message points to mmc commands
+	kAsioSupportsInputMonitor,	// kAsioSupportsXXX return 1 if host supports this
+	kAsioSupportsInputGain,     // unused and undefined
+	kAsioSupportsInputMeter,    // unused and undefined
+	kAsioSupportsOutputGain,    // unused and undefined
+	kAsioSupportsOutputMeter,   // unused and undefined
+	kAsioOverload,              // driver detected an overload
+
+	kAsioNumMessageSelectors
+};
+
+//---------------------------------------------------------------------------------------------------
+//---------------------------------------------------------------------------------------------------
+
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+// (De-)Construction
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+
+typedef struct ASIODriverInfo
+{
+	long asioVersion;		// currently, 2
+	long driverVersion;		// driver specific
+	char name[32];
+	char errorMessage[124];
+	void *sysRef;			// on input: system reference
+							// (Windows: application main window handle, Mac & SGI: 0)
+} ASIODriverInfo;
+
+ASIOError ASIOInit(ASIODriverInfo *info);
+/* Purpose:
+	  Initialize the AudioStreamIO.
+	Parameter:
+	  info: pointer to an ASIODriver structure:
+	    - asioVersion:
+			- on input, the host version. *** Note *** this is 0 for earlier asio
+			implementations, and the asioMessage callback is implemeted
+			only if asioVersion is 2 or greater. sorry but due to a design fault
+			the driver doesn't have access to the host version in ASIOInit :-(
+			added selector for host (engine) version in the asioMessage callback
+			so we're ok from now on.
+			- on return, asio implementation version.
+			  older versions are 1
+			  if you support this version (namely, ASIO_outputReady() )
+			  this should be 2 or higher. also see the note in
+			  ASIO_getTimeStamp() !
+	    - version: on return, the driver version (format is driver specific)
+	    - name: on return, a null-terminated string containing the driver's name
+		- error message: on return, should contain a user message describing
+		  the type of error that occured during ASIOInit(), if any.
+		- sysRef: platform specific
+	Returns:
+	  If neither input nor output is present ASE_NotPresent
+	  will be returned.
+	  ASE_NoMemory, ASE_HWMalfunction are other possible error conditions
+*/
+
+ASIOError ASIOExit(void);
+/* Purpose:
+	  Terminates the AudioStreamIO.
+	Parameter:
+	  None.
+	Returns:
+	  If neither input nor output is present ASE_NotPresent
+	  will be returned.
+	Notes: this implies ASIOStop() and ASIODisposeBuffers(),
+	  meaning that no host callbacks must be accessed after ASIOExit().
+*/
+
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+// Start/Stop
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+
+ASIOError ASIOStart(void);
+/* Purpose:
+	  Start input and output processing synchronously.
+	  This will
+	  - reset the sample counter to zero
+	  - start the hardware (both input and output)
+	    The first call to the hosts' bufferSwitch(index == 0) then tells
+	    the host to read from input buffer A (index 0), and start
+	    processing to output buffer A while output buffer B (which
+	    has been filled by the host prior to calling ASIOStart())
+	    is possibly sounding (see also ASIOGetLatencies()) 
+	Parameter:
+	  None.
+	Returns:
+	  If neither input nor output is present, ASE_NotPresent
+	  will be returned.
+	  If the hardware fails to start, ASE_HWMalfunction will be returned.
+	Notes:
+	  There is no restriction on the time that ASIOStart() takes
+	  to perform (that is, it is not considered a realtime trigger).
+*/
+
+ASIOError ASIOStop(void);
+/* Purpose:
+	  Stops input and output processing altogether.
+	Parameter:
+	  None.
+	Returns:
+	  If neither input nor output is present ASE_NotPresent
+	  will be returned.
+	Notes:
+	  On return from ASIOStop(), the driver must in no
+	  case call the hosts' bufferSwitch() routine.
+*/
+
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+// Inquiry methods and sample rate
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+
+ASIOError ASIOGetChannels(long *numInputChannels, long *numOutputChannels);
+/* Purpose:
+	  Returns number of individual input/output channels.
+	Parameter:
+	  numInputChannels will hold the number of available input channels
+	  numOutputChannels will hold the number of available output channels
+	Returns:
+	  If no input/output is present ASE_NotPresent will be returned.
+	  If only inputs, or only outputs are available, the according
+	  other parameter will be zero, and ASE_OK is returned.
+*/
+
+ASIOError ASIOGetLatencies(long *inputLatency, long *outputLatency);
+/* Purpose:
+	  Returns the input and output latencies. This includes
+	  device specific delays, like FIFOs etc.
+	Parameter:
+	  inputLatency will hold the 'age' of the first sample frame
+	  in the input buffer when the hosts reads it in bufferSwitch()
+	  (this is theoretical, meaning it does not include the overhead
+	  and delay between the actual physical switch, and the time
+	  when bufferSitch() enters).
+	  This will usually be the size of one block in sample frames, plus
+	  device specific latencies.
+
+	  outputLatency will specify the time between the buffer switch,
+	  and the time when the next play buffer will start to sound.
+	  The next play buffer is defined as the one the host starts
+	  processing after (or at) bufferSwitch(), indicated by the
+	  index parameter (0 for buffer A, 1 for buffer B).
+	  It will usually be either one block, if the host writes directly
+	  to a dma buffer, or two or more blocks if the buffer is 'latched' by
+	  the driver. As an example, on ASIOStart(), the host will have filled
+	  the play buffer at index 1 already; when it gets the callback (with
+	  the parameter index == 0), this tells it to read from the input
+	  buffer 0, and start to fill the play buffer 0 (assuming that now
+	  play buffer 1 is already sounding). In this case, the output
+	  latency is one block. If the driver decides to copy buffer 1
+	  at that time, and pass it to the hardware at the next slot (which
+	  is most commonly done, but should be avoided), the output latency
+	  becomes two blocks instead, resulting in a total i/o latency of at least
+	  3 blocks. As memory access is the main bottleneck in native dsp processing,
+	  and to acheive less latency, it is highly recommended to try to avoid
+	  copying (this is also why the driver is the owner of the buffers). To
+	  summarize, the minimum i/o latency can be acheived if the input buffer
+	  is processed by the host into the output buffer which will physically
+	  start to sound on the next time slice. Also note that the host expects
+	  the bufferSwitch() callback to be accessed for each time slice in order
+	  to retain sync, possibly recursively; if it fails to process a block in
+	  time, it will suspend its operation for some time in order to recover.
+	Returns:
+	  If no input/output is present ASE_NotPresent will be returned.
+*/
+
+ASIOError ASIOGetBufferSize(long *minSize, long *maxSize, long *preferredSize, long *granularity);
+/* Purpose:
+	  Returns min, max, and preferred buffer sizes for input/output
+	Parameter:
+	  minSize will hold the minimum buffer size
+	  maxSize will hold the maxium possible buffer size
+	  preferredSize will hold the preferred buffer size (a size which
+	  best fits performance and hardware requirements)
+	  granularity will hold the granularity at which buffer sizes
+	  may differ. Usually, the buffer size will be a power of 2;
+	  in this case, granularity will hold -1 on return, signalling
+	  possible buffer sizes starting from minSize, increased in
+	  powers of 2 up to maxSize.
+	Returns:
+	  If no input/output is present ASE_NotPresent will be returned.
+	Notes:
+	  When minimum and maximum buffer size are equal,
+	  the preferred buffer size has to be the same value as well; granularity
+	  should be 0 in this case.
+*/
+
+ASIOError ASIOCanSampleRate(ASIOSampleRate sampleRate);
+/* Purpose:
+	  Inquires the hardware for the available sample rates.
+	Parameter:
+	  sampleRate is the rate in question.
+	Returns:
+	  If the inquired sample rate is not supported, ASE_NoClock will be returned.
+	  If no input/output is present ASE_NotPresent will be returned.
+*/
+ASIOError ASIOGetSampleRate(ASIOSampleRate *currentRate);
+/* Purpose:
+	  Get the current sample Rate.
+	Parameter:
+	  currentRate will hold the current sample rate on return.
+	Returns:
+	  If sample rate is unknown, sampleRate will be 0 and ASE_NoClock will be returned.
+	  If no input/output is present ASE_NotPresent will be returned.
+	Notes:
+*/
+
+ASIOError ASIOSetSampleRate(ASIOSampleRate sampleRate);
+/* Purpose:
+	  Set the hardware to the requested sample Rate. If sampleRate == 0,
+	  enable external sync.
+	Parameter:
+	  sampleRate: on input, the requested rate
+	Returns:
+	  If sampleRate is unknown ASE_NoClock will be returned.
+	  If the current clock is external, and sampleRate is != 0,
+	  ASE_InvalidMode will be returned
+	  If no input/output is present ASE_NotPresent will be returned.
+	Notes:
+*/
+
+typedef struct ASIOClockSource
+{
+	long index;					// as used for ASIOSetClockSource()
+	long associatedChannel;		// for instance, S/PDIF or AES/EBU
+	long associatedGroup;		// see channel groups (ASIOGetChannelInfo())
+	ASIOBool isCurrentSource;	// ASIOTrue if this is the current clock source
+	char name[32];				// for user selection
+} ASIOClockSource;
+
+ASIOError ASIOGetClockSources(ASIOClockSource *clocks, long *numSources);
+/* Purpose:
+	  Get the available external audio clock sources
+	Parameter:
+	  clocks points to an array of ASIOClockSource structures:
+	  	- index: this is used to identify the clock source
+	  	  when ASIOSetClockSource() is accessed, should be
+	  	  an index counting from zero
+	  	- associatedInputChannel: the first channel of an associated
+	  	  input group, if any.
+	  	- associatedGroup: the group index of that channel.
+	  	  groups of channels are defined to seperate for
+	  	  instance analog, S/PDIF, AES/EBU, ADAT connectors etc,
+	  	  when present simultaniously. Note that associated channel
+	  	  is enumerated according to numInputs/numOutputs, means it
+	  	  is independant from a group (see also ASIOGetChannelInfo())
+	  	  inputs are associated to a clock if the physical connection
+	  	  transfers both data and clock (like S/PDIF, AES/EBU, or
+	  	  ADAT inputs). if there is no input channel associated with
+	  	  the clock source (like Word Clock, or internal oscillator), both
+	  	  associatedChannel and associatedGroup should be set to -1.
+	  	- isCurrentSource: on exit, ASIOTrue if this is the current clock
+	  	  source, ASIOFalse else
+		- name: a null-terminated string for user selection of the available sources.
+	  numSources:
+	      on input: the number of allocated array members
+	      on output: the number of available clock sources, at least
+	      1 (internal clock generator).
+	Returns:
+	  If no input/output is present ASE_NotPresent will be returned.
+	Notes:
+*/
+
+ASIOError ASIOSetClockSource(long index);
+/* Purpose:
+	  Set the audio clock source
+	Parameter:
+	  index as obtained from an inquiry to ASIOGetClockSources()
+	Returns:
+	  If no input/output is present ASE_NotPresent will be returned.
+	  If the clock can not be selected because an input channel which
+	  carries the current clock source is active, ASE_InvalidMode
+	  *may* be returned (this depends on the properties of the driver
+	  and/or hardware).
+	Notes:
+	  Should *not* return ASE_NoClock if there is no clock signal present
+	  at the selected source; this will be inquired via ASIOGetSampleRate().
+	  It should call the host callback procedure sampleRateHasChanged(),
+	  if the switch causes a sample rate change, or if no external clock
+	  is present at the selected source.
+*/
+
+ASIOError ASIOGetSamplePosition (ASIOSamples *sPos, ASIOTimeStamp *tStamp);
+/* Purpose:
+	  Inquires the sample position/time stamp pair.
+	Parameter:
+	  sPos will hold the sample position on return. The sample
+	  position is reset to zero when ASIOStart() gets called.
+	  tStamp will hold the system time when the sample position
+	  was latched.
+	Returns:
+	  If no input/output is present, ASE_NotPresent will be returned.
+	  If there is no clock, ASE_SPNotAdvancing will be returned.
+	Notes:
+
+	  in order to be able to synchronise properly,
+	  the sample position / time stamp pair must refer to the current block,
+	  that is, the engine will call ASIOGetSamplePosition() in its bufferSwitch()
+	  callback and expect the time for the current block. thus, when requested
+	  in the very first bufferSwitch after ASIO_Start(), the sample position
+	  should be zero, and the time stamp should refer to the very time where
+	  the stream was started. it also means that the sample position must be
+	  block aligned. the driver must ensure proper interpolation if the system
+	  time can not be determined for the block position. the driver is responsible
+	  for precise time stamps as it usually has most direct access to lower
+	  level resources. proper behaviour of ASIO_GetSamplePosition() and ASIO_GetLatencies()
+	  are essential for precise media synchronization!
+*/
+
+typedef struct ASIOChannelInfo
+{
+	long channel;			// on input, channel index
+	ASIOBool isInput;		// on input
+	ASIOBool isActive;		// on exit
+	long channelGroup;		// dto
+	ASIOSampleType type;	// dto
+	char name[32];			// dto
+} ASIOChannelInfo;
+
+ASIOError ASIOGetChannelInfo(ASIOChannelInfo *info);
+/* Purpose:
+	  retreive information about the nature of a channel
+	Parameter:
+	  info: pointer to a ASIOChannelInfo structure with
+	  	- channel: on input, the channel index of the channel in question.
+	  	- isInput: on input, ASIOTrue if info for an input channel is
+	  	  requested, else output
+		- channelGroup: on return, the channel group that the channel
+		  belongs to. For drivers which support different types of
+		  channels, like analog, S/PDIF, AES/EBU, ADAT etc interfaces,
+		  there should be a reasonable grouping of these types. Groups
+		  are always independant form a channel index, that is, a channel
+		  index always counts from 0 to numInputs/numOutputs regardless
+		  of the group it may belong to.
+		  There will always be at least one group (group 0). Please
+		  also note that by default, the host may decide to activate
+		  channels 0 and 1; thus, these should belong to the most
+		  useful type (analog i/o, if present).
+	  	- type: on return, contains the sample type of the channel
+	  	- isActive: on return, ASIOTrue if channel is active as it was
+	  	  installed by ASIOCreateBuffers(), ASIOFalse else
+	  	- name:  describing the type of channel in question. Used to allow
+	  	  for user selection, and enabling of specific channels. examples:
+	      "Analog In", "SPDIF Out" etc
+	Returns:
+	  If no input/output is present ASE_NotPresent will be returned.
+	Notes:
+	  If possible, the string should be organised such that the first
+	  characters are most significantly describing the nature of the
+	  port, to allow for identification even if the view showing the
+	  port name is too small to display more than 8 characters, for
+	  instance.
+*/
+
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+// Buffer preparation
+//- - - - - - - - - - - - - - - - - - - - - - - - -
+
+typedef struct ASIOBufferInfo
+{
+	ASIOBool isInput;			// on input:  ASIOTrue: input, else output
+	long channelNum;			// on input:  channel index
+	void *buffers[2];			// on output: double buffer addresses
+} ASIOBufferInfo;
+
+ASIOError ASIOCreateBuffers(ASIOBufferInfo *bufferInfos, long numChannels,
+	long bufferSize, ASIOCallbacks *callbacks);
+
+/* Purpose:
+	  Allocates input/output buffers for all input and output channels to be activated.
+	Parameter:
+	  bufferInfos is a pointer to an array of ASIOBufferInfo structures:
+	    - isInput: on input, ASIOTrue if the buffer is to be allocated
+	      for an input, output buffer else
+	    - channelNum: on input, the index of the channel in question
+	      (counting from 0)
+	    - buffers: on exit, 2 pointers to the halves of the channels' double-buffer.
+	      the size of the buffer(s) of course depend on both the ASIOSampleType
+	      as obtained from ASIOGetChannelInfo(), and bufferSize
+	  numChannels is the sum of all input and output channels to be created;
+	  thus bufferInfos is a pointer to an array of numChannels ASIOBufferInfo
+	  structures.
+	  bufferSize selects one of the possible buffer sizes as obtained from
+	  ASIOGetBufferSizes().
+	  callbacks is a pointer to an ASIOCallbacks structure.
+	Returns:
+	  If not enough memory is available ASE_NoMemory will be returned.
+	  If no input/output is present ASE_NotPresent will be returned.
+	  If bufferSize is not supported, or one or more of the bufferInfos elements
+	  contain invalid settings, ASE_InvalidMode will be returned.
+	Notes:
+	  If individual channel selection is not possible but requested,
+	  the driver has to handle this. namely, bufferSwitch() will only
+	  have filled buffers of enabled outputs. If possible, processing
+	  and buss activities overhead should be avoided for channels which
+	  were not enabled here.
+*/
+
+ASIOError ASIODisposeBuffers(void);
+/* Purpose:
+	  Releases all buffers for the device.
+	Parameter:
+	  None.
+	Returns:
+	  If no buffer were ever prepared, ASE_InvalidMode will be returned.
+	  If no input/output is present ASE_NotPresent will be returned.
+	Notes:
+	  This implies ASIOStop().
+*/
+
+ASIOError ASIOControlPanel(void);
+/* Purpose:
+	  request the driver to start a control panel component
+	  for device specific user settings. This will not be
+	  accessed on some platforms (where the component is accessed
+	  instead).
+	Parameter:
+	  None.
+	Returns:
+	  If no panel is available ASE_NotPresent will be returned.
+	  Actually, the return code is ignored.
+	Notes:
+	  if the user applied settings which require a re-configuration
+	  of parts or all of the enigine and/or driver (such as a change of
+	  the block size), the asioMessage callback can be used (see
+	  ASIO_Callbacks).
+*/
+
+ASIOError ASIOFuture(long selector, void *params);
+/* Purpose:
+	  various
+	Parameter:
+	  selector: operation Code as to be defined. zero is reserved for
+	  testing purposes.
+	  params: depends on the selector; usually pointer to a structure
+	  for passing and retreiving any type and amount of parameters.
+	Returns:
+	  the return value is also selector dependant. if the selector
+	  is unknown, ASE_InvalidParameter should be returned to prevent
+	  further calls with this selector. on success, ASE_SUCCESS
+	  must be returned (note: ASE_OK is *not* sufficient!)
+	Notes:
+	  see selectors defined below.	  
+*/
+
+enum
+{
+	kAsioEnableTimeCodeRead = 1,	// no arguments
+	kAsioDisableTimeCodeRead,		// no arguments
+	kAsioSetInputMonitor,			// ASIOInputMonitor* in params
+	kAsioTransport,					// ASIOTransportParameters* in params
+	kAsioSetInputGain,				// ASIOChannelControls* in params, apply gain
+	kAsioGetInputMeter,				// ASIOChannelControls* in params, fill meter
+	kAsioSetOutputGain,				// ASIOChannelControls* in params, apply gain
+	kAsioGetOutputMeter,			// ASIOChannelControls* in params, fill meter
+	kAsioCanInputMonitor,			// no arguments for kAsioCanXXX selectors
+	kAsioCanTimeInfo,
+	kAsioCanTimeCode,
+	kAsioCanTransport,
+	kAsioCanInputGain,
+	kAsioCanInputMeter,
+	kAsioCanOutputGain,
+	kAsioCanOutputMeter,
+	kAsioOptionalOne,
+	
+	//	DSD support
+	//	The following extensions are required to allow switching
+	//	and control of the DSD subsystem.
+	kAsioSetIoFormat			= 0x23111961,		/* ASIOIoFormat * in params.			*/
+	kAsioGetIoFormat			= 0x23111983,		/* ASIOIoFormat * in params.			*/
+	kAsioCanDoIoFormat			= 0x23112004,		/* ASIOIoFormat * in params.			*/
+	
+	// Extension for drop out detection
+	kAsioCanReportOverload			= 0x24042012,	/* return ASE_SUCCESS if driver can detect and report overloads */
+	
+	kAsioGetInternalBufferSamples	= 0x25042012	/* ASIOInternalBufferInfo * in params. Deliver size of driver internal buffering, return ASE_SUCCESS if supported */
+};
+
+typedef struct ASIOInputMonitor
+{
+	long input;		// this input was set to monitor (or off), -1: all
+	long output;	// suggested output for monitoring the input (if so)
+	long gain;		// suggested gain, ranging 0 - 0x7fffffffL (-inf to +12 dB)
+	ASIOBool state;	// ASIOTrue => on, ASIOFalse => off
+	long pan;		// suggested pan, 0 => all left, 0x7fffffff => right
+} ASIOInputMonitor;
+
+typedef struct ASIOChannelControls
+{
+	long channel;			// on input, channel index
+	ASIOBool isInput;		// on input
+	long gain;				// on input,  ranges 0 thru 0x7fffffff
+	long meter;				// on return, ranges 0 thru 0x7fffffff
+	char future[32];
+} ASIOChannelControls;
+
+typedef struct ASIOTransportParameters
+{
+	long command;		// see enum below
+	ASIOSamples samplePosition;
+	long track;
+	long trackSwitches[16];		// 512 tracks on/off
+	char future[64];
+} ASIOTransportParameters;
+
+enum
+{
+	kTransStart = 1,
+	kTransStop,
+	kTransLocate,		// to samplePosition
+	kTransPunchIn,
+	kTransPunchOut,
+	kTransArmOn,		// track
+	kTransArmOff,		// track
+	kTransMonitorOn,	// track
+	kTransMonitorOff,	// track
+	kTransArm,			// trackSwitches
+	kTransMonitor		// trackSwitches
+};
+
+/*
+// DSD support
+//	Some notes on how to use ASIOIoFormatType.
+//
+//	The caller will fill the format with the request types.
+//	If the board can do the request then it will leave the
+//	values unchanged. If the board does not support the
+//	request then it will change that entry to Invalid (-1)
+//
+//	So to request DSD then
+//
+//	ASIOIoFormat NeedThis={kASIODSDFormat};
+//
+//	if(ASE_SUCCESS != ASIOFuture(kAsioSetIoFormat,&NeedThis) ){
+//		// If the board did not accept one of the parameters then the
+//		// whole call will fail and the failing parameter will
+//		// have had its value changes to -1.
+//	}
+//
+// Note: Switching between the formats need to be done before the "prepared"
+// state (see ASIO 2 documentation) is entered.
+*/
+typedef long int ASIOIoFormatType;
+enum ASIOIoFormatType_e
+{
+	kASIOFormatInvalid = -1,
+	kASIOPCMFormat = 0,
+	kASIODSDFormat = 1,
+};
+
+typedef struct ASIOIoFormat_s
+{
+	ASIOIoFormatType	FormatType;
+	char				future[512-sizeof(ASIOIoFormatType)];
+} ASIOIoFormat;
+
+// Extension for drop detection
+// Note: Refers to buffering that goes beyond the double buffer e.g. used by USB driver designs
+typedef struct ASIOInternalBufferInfo
+{
+	long inputSamples;			// size of driver's internal input buffering which is included in getLatencies
+	long outputSamples;			// size of driver's internal output buffering which is included in getLatencies
+} ASIOInternalBufferInfo;
+
+
+ASIOError ASIOOutputReady(void);
+/* Purpose:
+	  this tells the driver that the host has completed processing
+	  the output buffers. if the data format required by the hardware
+	  differs from the supported asio formats, but the hardware
+	  buffers are DMA buffers, the driver will have to convert
+	  the audio stream data; as the bufferSwitch callback is
+	  usually issued at dma block switch time, the driver will
+	  have to convert the *previous* host buffer, which increases
+	  the output latency by one block.
+	  when the host finds out that ASIOOutputReady() returns
+	  true, it will issue this call whenever it completed
+	  output processing. then the driver can convert the
+	  host data directly to the dma buffer to be played next,
+	  reducing output latency by one block.
+	  another way to look at it is, that the buffer switch is called
+	  in order to pass the *input* stream to the host, so that it can
+	  process the input into the output, and the output stream is passed
+	  to the driver when the host has completed its process.
+	Parameter:
+		None
+	Returns:
+	  only if the above mentioned scenario is given, and a reduction
+	  of output latency can be acheived by this mechanism, should
+	  ASE_OK be returned. otherwise (and usually), ASE_NotPresent
+	  should be returned in order to prevent further calls to this
+	  function. note that the host may want to determine if it is
+	  to use this when the system is not yet fully initialized, so
+	  ASE_OK should always be returned if the mechanism makes sense.	  
+	Notes:
+	  please remeber to adjust ASIOGetLatencies() according to
+	  whether ASIOOutputReady() was ever called or not, if your
+	  driver supports this scenario.
+	  also note that the engine may fail to call ASIO_OutputReady()
+	  in time in overload cases. as already mentioned, bufferSwitch
+      should be called for every block regardless of whether a block
+      could be processed in time.
+*/
+
+// restore old alignment
+#if defined(_MSC_VER) && !defined(__MWERKS__) 
+#pragma pack(pop)
+#elif PRAGMA_ALIGN_SUPPORTED
+#pragma options align = reset
+#endif
+
+#endif
+
diff --git a/include/audio_backend/iasiodrv.h b/include/audio_backend/iasiodrv.h
new file mode 100644
index 0000000..a0adfa4
--- /dev/null
+++ b/include/audio_backend/iasiodrv.h
@@ -0,0 +1,35 @@
+//Steinberg Audio Stream I / O API
+//(c) 1997 - 2013, Steinberg Media Technologies GmbH
+
+#define IEEE754_64FLOAT 1
+#define NATIVE_INT64 1
+#include "asio.h"
+#include <Unknwn.h>
+
+class IASIO : public IUnknown
+{
+public:
+  virtual ASIOBool init(void *sysHandle) = 0;
+  virtual void getDriverName(char *name) = 0;
+  virtual long getDriverVersion() = 0;
+  virtual void getErrorMessage(char *string) = 0;
+  virtual ASIOError start() = 0;
+  virtual ASIOError stop() = 0;
+  virtual ASIOError getChannels(long *numInputChannels, long *numOutputChannels) = 0;
+  virtual ASIOError getLatencies(long *inputLatency, long *outputLatency) = 0;
+  virtual ASIOError getBufferSize(long *minSize, long *maxSize,
+    long *preferredSize, long *granularity) = 0;
+  virtual ASIOError canSampleRate(ASIOSampleRate sampleRate) = 0;
+  virtual ASIOError getSampleRate(ASIOSampleRate *sampleRate) = 0;
+  virtual ASIOError setSampleRate(ASIOSampleRate sampleRate) = 0;
+  virtual ASIOError getClockSources(ASIOClockSource *clocks, long *numSources) = 0;
+  virtual ASIOError setClockSource(long reference) = 0;
+  virtual ASIOError getSamplePosition(ASIOSamples *sPos, ASIOTimeStamp *tStamp) = 0;
+  virtual ASIOError getChannelInfo(ASIOChannelInfo *info) = 0;
+  virtual ASIOError createBuffers(ASIOBufferInfo *bufferInfos, long numChannels,
+    long bufferSize, ASIOCallbacks *callbacks) = 0;
+  virtual ASIOError disposeBuffers() = 0;
+  virtual ASIOError controlPanel() = 0;
+  virtual ASIOError future(long selector, void *opt) = 0;
+  virtual ASIOError outputReady() = 0;
+};
diff --git a/test/asio_test.cpp b/test/asio_test.cpp
new file mode 100644
index 0000000..70ebcca
--- /dev/null
+++ b/test/asio_test.cpp
@@ -0,0 +1,534 @@
+// libstdaudio
+// Copyright (c) 2019 - Andy Saul
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+
+#include "catch/catch.hpp"
+#include "catch/trompeloeil.hpp"
+#include "trompeloeil.hpp"
+#include <audio>
+
+using namespace std::experimental;
+
+using trompeloeil::_;
+
+using sample_rate_t = audio_device::sample_rate_t;
+using buffer_size_t = audio_device::buffer_size_t;
+
+TEST_CASE("Converts floating point samples to integer samples", "[asio]") {
+  SECTION("Converts to 32-bit samples") {
+    CHECK(__asio_sample<int32_t>(0.f).int_value() == 0);
+    CHECK(__asio_sample<int32_t>(1.f).int_value() == 0x7fff'ffff);
+    CHECK(__asio_sample<int32_t>(-1.f).int_value() == -0x7fff'ffff);
+    CHECK(__asio_sample<int32_t>(0.5f).int_value() == 0x7fff'ffff / 2);
+    CHECK(__asio_sample<int32_t>(-0.5f).int_value() == -0x7fff'ffff / 2);
+  }
+
+  SECTION("Converts to 24-bit samples") {
+    CHECK(__asio_sample<packed24_t>(0.f).int_value() == 0);
+    CHECK(__asio_sample<packed24_t>(1.f).int_value() == 0x7f'ffff);
+    CHECK(__asio_sample<packed24_t>(-1.f).int_value() == -0x7f'ffff);
+    CHECK(__asio_sample<packed24_t>(0.5f).int_value() == 0x7f'ffff / 2);
+    CHECK(__asio_sample<packed24_t>(-0.5f).int_value() == -0x7f'ffff / 2);
+  }
+
+  SECTION("Converts to 16-bit samples") {
+    CHECK(__asio_sample<int16_t>(0.f).int_value() == 0);
+    CHECK(__asio_sample<int16_t>(1.f).int_value() == 0x7fff);
+    CHECK(__asio_sample<int16_t>(-1.f).int_value() == -0x7fff);
+    CHECK(__asio_sample<int16_t>(0.5f).int_value() == 0x7fff / 2);
+    CHECK(__asio_sample<int16_t>(-0.5f).int_value() == -0x7fff / 2);
+  }
+}
+
+TEST_CASE("Converts integer samples to floating point samples", "[asio]") {
+  SECTION("Converts from 32-bit samples") {
+    CHECK(__asio_sample<int32_t>(0).float_value() == 0.f);
+    CHECK(__asio_sample<int32_t>(0x7fff'ffff).float_value() == 1.f);
+    CHECK(__asio_sample<int32_t>(-0x7fff'ffff).float_value() == -1.f);
+    CHECK(__asio_sample<int32_t>(0x7fff'ffff / 2).float_value() == 0.5f);
+    CHECK(__asio_sample<int32_t>(-0x7fff'ffff / 2).float_value() == -0.5f);
+  }
+
+  SECTION("Converts from 24-bit samples") {
+    CHECK(__asio_sample<packed24_t>(0u).float_value() == 0.f);
+    CHECK(__asio_sample<packed24_t>(0x7f'ffffu).float_value() == 1.f);
+    CHECK(__asio_sample<packed24_t>(static_cast<uint32_t>(-0x7f'ffff)).float_value() == -1.f);
+
+    const auto half = __asio_sample<packed24_t>(0x7f'ffffu / 2).float_value();
+    CHECK(Approx(half) == 0.5f);
+
+    const auto minus_half = __asio_sample<packed24_t>(static_cast<uint32_t>(-0x7f'ffff)/ 2).float_value();
+    CHECK(Approx(minus_half) == -0.5f);
+  }
+
+  SECTION("Converts from 16-bit samples") {
+    int16_t value = 0;
+    CHECK(__asio_sample<int16_t>(value).float_value() == 0.f);
+
+    value = 0x7fff;
+    CHECK(__asio_sample<int16_t>(value).float_value() == 1.f);
+
+    value = -0x7fff;
+    CHECK(__asio_sample<int16_t>(value).float_value() == -1.f);
+
+    value = 0x7fff / 2;
+    const auto half = __asio_sample<int16_t>(value).float_value();
+    CHECK(Approx(half).epsilon(0.0001f) == 0.5f);
+
+    value = -0x7fff / 2;
+    const auto minus_half = __asio_sample<int16_t>(value).float_value();
+    CHECK(Approx(minus_half).epsilon(0.0001f) == -0.5f);
+  }
+}
+
+class mock_asio : public trompeloeil::mock_interface<IASIO> {
+public:
+  long __stdcall QueryInterface(const IID&, void**) override {
+    return 0;
+  }
+  unsigned long __stdcall AddRef() override {
+    return 1;
+  }
+  unsigned long __stdcall Release() override {
+    return 0;
+  }
+  IMPLEMENT_MOCK1(init);
+  IMPLEMENT_MOCK1(getDriverName);
+  IMPLEMENT_MOCK0(getDriverVersion);
+  IMPLEMENT_MOCK1(getErrorMessage);
+  IMPLEMENT_MOCK0(start);
+  IMPLEMENT_MOCK0(stop);
+  IMPLEMENT_MOCK2(getChannels);
+  IMPLEMENT_MOCK2(getLatencies);
+  IMPLEMENT_MOCK4(getBufferSize);
+  IMPLEMENT_MOCK1(canSampleRate);
+  IMPLEMENT_MOCK1(getSampleRate);
+  IMPLEMENT_MOCK1(setSampleRate);
+  IMPLEMENT_MOCK2(getClockSources);
+  IMPLEMENT_MOCK1(setClockSource);
+  IMPLEMENT_MOCK2(getSamplePosition);
+  IMPLEMENT_MOCK1(getChannelInfo);
+  IMPLEMENT_MOCK4(createBuffers);
+  IMPLEMENT_MOCK0(disposeBuffers);
+  IMPLEMENT_MOCK0(controlPanel);
+  IMPLEMENT_MOCK2(future);
+  IMPLEMENT_MOCK0(outputReady);
+};
+
+class asio_device_builder {
+public:
+  explicit asio_device_builder(mock_asio& asio) : asio(asio) {}
+
+  using audio_device_ptr = std::unique_ptr<audio_device, std::function<void(audio_device*)>>;
+
+  audio_device_ptr operator()() {
+    REQUIRE_CALL(asio, getChannels(_, _)).SIDE_EFFECT(*_1 = num_inputs).SIDE_EFFECT(*_2 = num_outputs).RETURN(0);
+
+    REQUIRE_CALL(asio, getBufferSize(_, _, _, _))
+      .SIDE_EFFECT(*_1 = min_buffer_size)
+      .SIDE_EFFECT(*_2 = max_buffer_size)
+      .SIDE_EFFECT(*_3 = preferred_buffer_size)
+      .SIDE_EFFECT(*_4 = granularity)
+      .RETURN(0);
+
+    REQUIRE_CALL(asio, getChannelInfo(_)).SIDE_EFFECT(*_1 = info).RETURN(0);
+
+    REQUIRE_CALL(asio, canSampleRate(_)).TIMES(6).RETURN(is_supported_sample_rate(_1));
+
+    constexpr double sample_rate{44'100.0};
+    REQUIRE_CALL(asio, getSampleRate(_)).SIDE_EFFECT(*_1 = sample_rate).TIMES(AT_LEAST(1)).RETURN(ASIOTrue);
+
+    return {new audio_device(id, name, &asio, direction), [&](auto* device) {
+              REQUIRE_CALL(asio, stop()).RETURN(ASIOTrue);
+              ALLOW_CALL(asio, disposeBuffers()).RETURN(0);
+              delete device;
+            }};
+  }
+
+  long is_supported_sample_rate(const sample_rate_t rate) const {
+    return std::find(sample_rates.begin(), sample_rates.end(), rate) == sample_rates.end() ? ASE_NotPresent : ASE_OK;
+  }
+
+  asio_device_builder& with_id(const audio_device::device_id_t new_id) {
+    id = new_id;
+    return *this;
+  }
+
+  asio_device_builder& with_name(const std::string& new_name) {
+    name = new_name;
+    return *this;
+  }
+
+  asio_device_builder& with_num_input_channels(const long new_num_inputs) {
+    num_inputs = new_num_inputs;
+    return *this;
+  }
+
+  asio_device_builder& with_num_output_channels(const long new_num_outputs) {
+    num_outputs = new_num_outputs;
+    return *this;
+  }
+
+  asio_device_builder& using_inputs_only() {
+    direction = audio_direction::in;
+    return *this;
+  }
+
+  asio_device_builder& using_outputs_only() {
+    direction = audio_direction::out;
+    return *this;
+  }
+
+  asio_device_builder& with_unique_buffer_size(const long buffer_size) {
+    min_buffer_size = max_buffer_size = preferred_buffer_size = buffer_size;
+    granularity = 0;
+    return *this;
+  }
+
+  asio_device_builder& with_power_of_two_buffer_sizes(const long min, const long max) {
+    min_buffer_size = min;
+    max_buffer_size = max;
+    granularity = -1;
+    return *this;
+  }
+
+  asio_device_builder& with_preferred_buffer_size(const long preferred) {
+    preferred_buffer_size = preferred;
+    return *this;
+  }
+
+  asio_device_builder& with_buffer_size_range(const long min, const long max, const long step) {
+    min_buffer_size = min;
+    max_buffer_size = max;
+    granularity = step;
+    return *this;
+  }
+
+  asio_device_builder& with_sample_rates(std::vector<sample_rate_t> new_sample_rates) {
+    sample_rates = std::move(new_sample_rates);
+    return *this;
+  }
+
+private:
+  mock_asio& asio;
+  audio_device::device_id_t id{0};
+  std::string name;
+  audio_direction direction{audio_direction::full_duplex};
+
+  long num_inputs{0};
+  long num_outputs{0};
+
+  long min_buffer_size{128};
+  long max_buffer_size{512};
+  long preferred_buffer_size{256};
+  long granularity{-1};
+  ASIOChannelInfo info{0, ASIOFalse, ASIOFalse, 0, ASIOSTInt32LSB};
+
+  std::vector<sample_rate_t> sample_rates{44'100, 48'000, 88'200, 96'000, 176'400, 192'000};
+};
+
+class asio_device_fixture {
+public:
+  mock_asio asio;
+  asio_device_builder make_asio_device{asio};
+
+  ASIOCallbacks* callbacks;
+  ASIOBufferInfo* asio_buffers;
+  std::vector<int32_t> buffer;
+
+  template<typename _CallbackType>
+  void connect(audio_device& device, _CallbackType callback) {
+    REQUIRE_CALL(asio, createBuffers(_, _, _, _)).LR_SIDE_EFFECT(asio_buffers = _1).LR_SIDE_EFFECT(callbacks = _4).RETURN(0);
+    device.connect(callback);
+  }
+
+  void allocate_buffers(const uint32_t num_channels, const uint32_t num_frames) {
+    buffer.resize(2 * num_channels * num_frames);
+    auto data = buffer.data();
+    for (uint32_t c = 0; c < num_channels; ++c) {
+      for (auto& asio_buffer : asio_buffers[c].buffers) {
+        asio_buffer = data;
+        data += num_frames;
+      }
+    }
+  }
+
+  void verify_out_value(const uint32_t channel, const int32_t value) const {
+    CHECK(*static_cast<int32_t*>(asio_buffers[channel].buffers[0]) == value);
+  }
+
+  void set_input_value(const int channel, const int32_t value) const {
+    auto samples = static_cast<int32_t*>(asio_buffers[channel].buffers[0]);
+    samples[0] = value;
+    samples = static_cast<int32_t*>(asio_buffers[channel].buffers[1]);
+    samples[0] = value;
+  }
+};
+
+TEST_CASE_METHOD(asio_device_fixture, "Creates device with id", "[asio]") {
+  auto device = make_asio_device.with_id(42)();
+
+  CHECK(device->device_id() == 42);
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Creates device with name", "[asio]") {
+  auto device = make_asio_device.with_name("Fake ASIO")();
+
+  CHECK(device->name() == "Fake ASIO");
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Creates stereo output device", "[asio]") {
+  auto device = make_asio_device.with_num_output_channels(2)();
+
+  CHECK(device->is_output());
+  CHECK(device->get_num_output_channels() == 2);
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Creates mono output device", "[asio]") {
+  auto device = make_asio_device.with_num_output_channels(1)();
+
+  CHECK(device->is_output());
+  CHECK(device->get_num_output_channels() == 1);
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Creates stereo input device", "[asio]") {
+  auto device = make_asio_device.with_num_input_channels(2)();
+
+  CHECK(device->is_input());
+  CHECK(device->get_num_input_channels() == 2);
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Creates mono input device", "[asio]") {
+  auto device = make_asio_device.with_num_input_channels(1)();
+
+  CHECK(device->is_input());
+  CHECK(device->get_num_input_channels() == 1);
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Creates full duplex device", "[asio]") {
+  auto device = make_asio_device.with_num_input_channels(4).with_num_output_channels(4)();
+
+  CHECK(device->is_input());
+  CHECK(device->get_num_input_channels() == 4);
+  CHECK(device->is_output());
+  CHECK(device->get_num_output_channels() == 4);
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Creates input-only device from duplex ASIO", "[asio]") {
+  auto device = make_asio_device.with_num_input_channels(4).with_num_output_channels(4).using_inputs_only()();
+
+  CHECK(device->is_input());
+  CHECK(device->get_num_input_channels() == 4);
+  CHECK_FALSE(device->is_output());
+  CHECK(device->get_num_output_channels() == 0);
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Creates output-only device from duplex ASIO", "[asio]") {
+  auto device = make_asio_device.with_num_input_channels(4).with_num_output_channels(4).using_outputs_only()();
+
+  CHECK_FALSE(device->is_input());
+  CHECK(device->get_num_input_channels() == 0);
+  CHECK(device->is_output());
+  CHECK(device->get_num_output_channels() == 4);
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Supports unique buffer size", "[asio]") {
+  auto device = make_asio_device.with_unique_buffer_size(1024)();
+
+  // TODO: Use future API to query for allowed buffer sizes
+  CHECK(device->get_buffer_size_frames() == 1024);
+  CHECK(device->set_buffer_size_frames(1024));
+  CHECK_FALSE(device->set_buffer_size_frames(64));
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Supports power-of-two buffer sizes", "[asio]") {
+  auto device = make_asio_device.with_power_of_two_buffer_sizes(64, 1024).with_preferred_buffer_size(256)();
+
+  // TODO: Use future API to query for allowed buffer sizes
+  CHECK(device->get_buffer_size_frames() == 256);
+
+  for (const auto size : {64, 128, 256, 512, 1024}) {
+    CHECK(device->set_buffer_size_frames(size));
+    CHECK_FALSE(device->set_buffer_size_frames(size + 1));
+    CHECK_FALSE(device->set_buffer_size_frames(size - 1));
+    CHECK(device->get_buffer_size_frames() == size);
+  }
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Supports buffer size ranges", "[asio]") {
+  auto device = make_asio_device.with_buffer_size_range(64, 256, 64).with_preferred_buffer_size(192)();
+
+  // TODO: Use future API to query for allowed buffer sizes
+  CHECK(device->get_buffer_size_frames() == 192);
+
+  for (const auto size : {64, 128, 192, 256}) {
+    CHECK(device->set_buffer_size_frames(size));
+    CHECK_FALSE(device->set_buffer_size_frames(size + 1));
+    CHECK_FALSE(device->set_buffer_size_frames(size - 1));
+    CHECK(device->get_buffer_size_frames() == size);
+  }
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Supports common samplerates", "[asio]") {
+  auto device = make_asio_device();
+
+  // TODO: Use future API to query for allowed sample rates
+  for (const auto rate : {44'100, 48'000, 88'200, 96'000, 176'400, 192'000}) {
+    ALLOW_CALL(asio, setSampleRate(_)).RETURN(make_asio_device.is_supported_sample_rate(rate));
+    CHECK(device->set_sample_rate(rate));
+  }
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Can connect to device", "[asio]") {
+  auto device = make_asio_device();
+
+  CHECK(device->can_connect());
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Cannot poll device", "[asio]") {
+  auto device = make_asio_device();
+
+  CHECK_FALSE(device->can_process());
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Device is not running before connection", "[asio]") {
+  auto device = make_asio_device();
+
+  CHECK_FALSE(device->is_running());
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Device cannot be started before connection", "[asio]") {
+  auto device = make_asio_device();
+
+  CHECK_FALSE(device->start());
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Device writes outputs from legacy callbacks", "[asio]") {
+  auto device = make_asio_device.with_num_output_channels(2).with_unique_buffer_size(32)();
+
+  connect(*device, [&](audio_device & d, audio_device_io<float> & io) mutable noexcept {
+    CHECK(device.get() == &d);
+    auto& out = *io.output_buffer;
+    CHECK(io.output_buffer.has_value());
+    CHECK(out.size_channels() == 2);
+    CHECK(out.size_frames() == 32);
+    for (size_t frame = 0; frame < out.size_frames(); ++frame) {
+      out(frame, 0) = 1.0f;
+      out(frame, 1) = -1.0f;
+    }
+  });
+
+  allocate_buffers(2, 32);
+
+  REQUIRE_CALL(asio, start()).RETURN(0);
+  REQUIRE_CALL(asio, outputReady()).RETURN(0);
+  CHECK(device->start());
+
+  callbacks->bufferSwitch(0, ASIOFalse);
+
+  verify_out_value(0, 0x7fff'ffff);
+  verify_out_value(1, -0x7fff'ffff);
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Device writes outputs from timestamped callbacks", "[asio]") {
+  auto device = make_asio_device.with_num_output_channels(2).with_unique_buffer_size(32)();
+
+  connect(*device, [&](audio_device & d, audio_device_io<float> & io) mutable noexcept {
+    CHECK(device.get() == &d);
+    auto& out = *io.output_buffer;
+    CHECK(io.output_buffer.has_value());
+    CHECK(out.size_channels() == 2);
+    CHECK(out.size_frames() == 32);
+    for (size_t frame = 0; frame < out.size_frames(); ++frame) {
+      out(frame, 0) = 1.0f;
+      out(frame, 1) = -1.0f;
+    }
+  });
+
+  allocate_buffers(2, 32);
+
+  REQUIRE_CALL(asio, start()).RETURN(0);
+  CHECK(device->start());
+
+  ASIOTime time;
+  auto result = callbacks->bufferSwitchTimeInfo(&time, 0, ASIOFalse);
+  CHECK(result->timeInfo.samplePosition == 0);
+
+  result = callbacks->bufferSwitchTimeInfo(&time, 0, ASIOFalse);
+  CHECK(result->timeInfo.samplePosition == 32);
+
+  verify_out_value(0, 0x7fff'ffff);
+  verify_out_value(1, -0x7fff'ffff);
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Device responds to ASIO message callback", "[asio]") {
+  const auto device = make_asio_device();
+  connect(*device, [](auto&, auto&) noexcept {});
+
+  CHECK(callbacks->asioMessage(kAsioSupportsTimeInfo, 0, nullptr, nullptr) == ASIOTrue);
+  CHECK(callbacks->asioMessage(kAsioEngineVersion, 0, nullptr, nullptr) == 2);
+  CHECK(callbacks->asioMessage(kAsioSelectorSupported, 0, nullptr, nullptr) == ASIOFalse);
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Throws exception if connection attempted when already running", "[asio]") {
+  const auto device = make_asio_device.with_num_output_channels(1).with_unique_buffer_size(1)();
+  const auto no_op = [](auto&, auto&) noexcept {};
+  connect(*device, no_op);
+  REQUIRE_CALL(asio, start()).RETURN(0);
+  CHECK(device->start());
+
+  CHECK(device->is_running());
+  CHECK_THROWS_AS(device->connect(no_op), audio_device_exception);
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Device reads inputs from legacy callbacks", "[asio]") {
+  auto device = make_asio_device.with_num_input_channels(2).with_unique_buffer_size(32)();
+
+  connect(*device, [&](audio_device & d, audio_device_io<float> & io) mutable noexcept {
+    CHECK(device.get() == &d);
+    auto& in = *io.input_buffer;
+    CHECK(io.input_buffer.has_value());
+    CHECK(in.size_channels() == 2);
+    CHECK(in.size_frames() == 32);
+    CHECK(in(0, 0) == 1.f);
+    CHECK(in(0, 1) == -1.0f);
+  });
+
+  allocate_buffers(2, 32);
+  set_input_value(0, 0x7fff'ffff);
+  set_input_value(1, -0x7fff'ffff);
+
+  REQUIRE_CALL(asio, start()).RETURN(0);
+  CHECK(device->start());
+
+  REQUIRE_CALL(asio, outputReady()).RETURN(0);
+  callbacks->bufferSwitch(0, ASIOFalse);
+}
+
+TEST_CASE_METHOD(asio_device_fixture, "Device reads inputs from timestamped callbacks", "[asio]") {
+  auto device = make_asio_device.with_num_input_channels(2).with_unique_buffer_size(32)();
+
+  connect(*device, [&](audio_device & d, audio_device_io<float> & io) mutable noexcept {
+    CHECK(device.get() == &d);
+    auto& in = *io.input_buffer;
+    CHECK(io.input_buffer.has_value());
+    CHECK(in.size_channels() == 2);
+    CHECK(in.size_frames() == 32);
+    CHECK(in(0, 0) == 1.f);
+    CHECK(in(0, 1) == -1.0f);
+  });
+
+  allocate_buffers(2, 32);
+  set_input_value(0, 0x7fff'ffff);
+  set_input_value(1, -0x7fff'ffff);
+
+  REQUIRE_CALL(asio, start()).RETURN(0);
+  CHECK(device->start());
+
+  ASIOTime time;
+  auto result = callbacks->bufferSwitchTimeInfo(&time, 0, ASIOFalse);
+  CHECK(result->timeInfo.samplePosition == 0);
+  result = callbacks->bufferSwitchTimeInfo(&time, 0, ASIOFalse);
+  CHECK(result->timeInfo.samplePosition == 32);
+}
diff --git a/test/audio_device_test.cpp b/test/audio_device_test.cpp
index ec9df20..c6c999b 100644
--- a/test/audio_device_test.cpp
+++ b/test/audio_device_test.cpp
@@ -45,7 +45,7 @@ TEST_CASE("All output devices have unique IDs")
 
 TEST_CASE("If there are any input devices, there must be a default input device")
 {
-  auto default_device = get_default_audio_input_device();
+  const auto default_device = get_default_audio_input_device();
   auto devices = get_audio_input_device_list();
   if (devices.empty()) {
     CHECK_FALSE(default_device.has_value());
@@ -57,7 +57,7 @@ TEST_CASE("If there are any input devices, there must be a default input device"
 
 TEST_CASE("If there are any output devices, there must be a default output device")
 {
-  auto default_device = get_default_audio_output_device();
+  const auto default_device = get_default_audio_output_device();
   auto devices = get_audio_output_device_list();
   if (devices.empty()) {
     CHECK_FALSE(default_device.has_value());
diff --git a/test/catch/trompeloeil.hpp b/test/catch/trompeloeil.hpp
new file mode 100644
index 0000000..4747eec
--- /dev/null
+++ b/test/catch/trompeloeil.hpp
@@ -0,0 +1,50 @@
+/*
+ * Trompeloeil C++ mocking framework
+ *
+ * Copyright Björn Fahller 2014-2019
+ *
+ *  Use, modification and distribution is subject to the
+ *  Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at
+ *  http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * Project home: https://github.com/rollbear/trompeloeil
+ */
+
+
+#ifndef TROMPELOEIL_CATCH2_HPP_
+#define TROMPELOEIL_CATCH2_HPP_
+
+#ifndef CATCH_VERSION_MAJOR
+#error "<catch.hpp> must be included before <catch2/trompeloeil.hpp>"
+#endif
+
+#include "../trompeloeil.hpp"
+
+namespace trompeloeil
+{
+  template <>
+  inline void reporter<specialized>::send(
+    severity s,
+    const char* file,
+    unsigned long line,
+    const char* msg)
+  {
+    std::ostringstream os;
+    if (line) os << file << ':' << line << '\n';
+    os << msg;
+    auto failure = os.str();
+    if (s == severity::fatal)
+    {
+      FAIL(failure);
+    }
+    else
+    {
+      CAPTURE(failure);
+      CHECK(failure.empty());
+    }
+  }
+}
+
+
+#endif //TROMPELOEIL_CATCH2_HPP_
diff --git a/test/trompeloeil.hpp b/test/trompeloeil.hpp
new file mode 100644
index 0000000..9301931
--- /dev/null
+++ b/test/trompeloeil.hpp
@@ -0,0 +1,4901 @@
+/*
+ * Trompeloeil C++ mocking framework
+ *
+ * Copyright Björn Fahller 2014-2019
+ * Copyright (C) 2017, 2018 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 at
+ *  http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * Project home: https://github.com/rollbear/trompeloeil
+ */
+
+#ifndef TROMPELOEIL_HPP_
+#define TROMPELOEIL_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(_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
+
+#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
+
+#include <tuple>
+#include <iomanip>
+#include <sstream>
+#include <exception>
+#include <functional>
+#include <memory>
+#include <cstring>
+#include <regex>
+#include <mutex>
+#include <atomic>
+#include <initializer_list>
+#include <type_traits>
+#include <utility>
+
+
+#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))
+
+#define TROMPELOEIL_CONCAT_(x, y) x ## y
+#define TROMPELOEIL_CONCAT(x, y) TROMPELOEIL_CONCAT_(x, y)
+
+#define TROMPELOEIL_INIT_WITH_STR15(base, x, ...)                              \
+  base{#x, x}, TROMPELOEIL_INIT_WITH_STR14(base, __VA_ARGS__)
+
+#define TROMPELOEIL_INIT_WITH_STR14(base, x, ...)                              \
+  base{#x, x}, TROMPELOEIL_INIT_WITH_STR13(base, __VA_ARGS__)
+
+#define TROMPELOEIL_INIT_WITH_STR13(base, x, ...)                              \
+  base{#x, x}, TROMPELOEIL_INIT_WITH_STR12(base, __VA_ARGS__)
+
+#define TROMPELOEIL_INIT_WITH_STR12(base, x, ...)                              \
+  base{#x, x}, TROMPELOEIL_INIT_WITH_STR11(base, __VA_ARGS__)
+
+#define TROMPELOEIL_INIT_WITH_STR11(base, x, ...)                              \
+  base{#x, x}, TROMPELOEIL_INIT_WITH_STR10(base, __VA_ARGS__)
+
+#define TROMPELOEIL_INIT_WITH_STR10(base, x, ...)                              \
+  base{#x, x}, TROMPELOEIL_INIT_WITH_STR9(base, __VA_ARGS__)
+
+#define TROMPELOEIL_INIT_WITH_STR9(base, x, ...)                               \
+  base{#x, x}, TROMPELOEIL_INIT_WITH_STR8(base, __VA_ARGS__)
+
+#define TROMPELOEIL_INIT_WITH_STR8(base, x, ...)                               \
+  base{#x, x}, TROMPELOEIL_INIT_WITH_STR7(base, __VA_ARGS__)
+
+#define TROMPELOEIL_INIT_WITH_STR7(base, x, ...)                               \
+  base{#x, x}, TROMPELOEIL_INIT_WITH_STR6(base, __VA_ARGS__)
+
+#define TROMPELOEIL_INIT_WITH_STR6(base, x, ...)                               \
+  base{#x, x}, TROMPELOEIL_INIT_WITH_STR5(base, __VA_ARGS__)
+
+#define TROMPELOEIL_INIT_WITH_STR5(base, x, ...)                               \
+  base{#x, x}, TROMPELOEIL_INIT_WITH_STR4(base, __VA_ARGS__)
+
+#define TROMPELOEIL_INIT_WITH_STR4(base, x, ...)                               \
+  base{#x, x}, TROMPELOEIL_INIT_WITH_STR3(base, __VA_ARGS__)
+
+#define TROMPELOEIL_INIT_WITH_STR3(base, x, ...)                               \
+  base{#x, x}, TROMPELOEIL_INIT_WITH_STR2(base, __VA_ARGS__)
+
+#define TROMPELOEIL_INIT_WITH_STR2(base, x, ...)                               \
+  base{#x, x}, 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(func_type)                                    \
+  TROMPELOEIL_PARAM_LIST14(func_type),                                         \
+  ::trompeloeil::param_list_t<func_type, 14> p15
+
+#define TROMPELOEIL_PARAM_LIST14(func_type)                                    \
+  TROMPELOEIL_PARAM_LIST13(func_type),                                         \
+  ::trompeloeil::param_list_t<func_type, 13> p14
+
+#define TROMPELOEIL_PARAM_LIST13(func_type)                                    \
+  TROMPELOEIL_PARAM_LIST12(func_type),                                         \
+  ::trompeloeil::param_list_t<func_type, 12> p13
+
+#define TROMPELOEIL_PARAM_LIST12(func_type)                                    \
+  TROMPELOEIL_PARAM_LIST11(func_type),                                         \
+  ::trompeloeil::param_list_t<func_type, 11> p12
+
+#define TROMPELOEIL_PARAM_LIST11(func_type)                                    \
+  TROMPELOEIL_PARAM_LIST10(func_type),                                         \
+  ::trompeloeil::param_list_t<func_type, 10> p11
+
+#define TROMPELOEIL_PARAM_LIST10(func_type)                                    \
+  TROMPELOEIL_PARAM_LIST9(func_type),                                          \
+  ::trompeloeil::param_list_t<func_type, 9> p10
+
+#define TROMPELOEIL_PARAM_LIST9(func_type)                                     \
+  TROMPELOEIL_PARAM_LIST8(func_type),                                          \
+  ::trompeloeil::param_list_t<func_type, 8> p9
+
+#define TROMPELOEIL_PARAM_LIST8(func_type)                                     \
+  TROMPELOEIL_PARAM_LIST7(func_type),                                          \
+  ::trompeloeil::param_list_t<func_type, 7> p8
+
+#define TROMPELOEIL_PARAM_LIST7(func_type)                                     \
+  TROMPELOEIL_PARAM_LIST6(func_type),                                          \
+  ::trompeloeil::param_list_t<func_type, 6> p7
+
+#define TROMPELOEIL_PARAM_LIST6(func_type)                                     \
+  TROMPELOEIL_PARAM_LIST5(func_type),                                          \
+  ::trompeloeil::param_list_t<func_type, 5> p6
+
+#define TROMPELOEIL_PARAM_LIST5(func_type)                                     \
+  TROMPELOEIL_PARAM_LIST4(func_type),                                          \
+    ::trompeloeil::param_list_t<func_type, 4> p5
+
+#define TROMPELOEIL_PARAM_LIST4(func_type)                                     \
+  TROMPELOEIL_PARAM_LIST3(func_type),                                          \
+    ::trompeloeil::param_list_t<func_type, 3> p4
+
+#define TROMPELOEIL_PARAM_LIST3(func_type)                                     \
+  TROMPELOEIL_PARAM_LIST2(func_type),                                          \
+  ::trompeloeil::param_list_t<func_type, 2> p3
+
+#define TROMPELOEIL_PARAM_LIST2(func_type)                                     \
+  TROMPELOEIL_PARAM_LIST1(func_type),                                          \
+  ::trompeloeil::param_list_t<func_type, 1> p2
+
+#define TROMPELOEIL_PARAM_LIST1(func_type)                                     \
+  ::trompeloeil::param_list_t<func_type, 0> p1
+
+#define TROMPELOEIL_PARAM_LIST0(func_type)
+
+#define TROMPELOEIL_PARAM_LIST(num, func_type)                                 \
+  TROMPELOEIL_CONCAT(TROMPELOEIL_PARAM_LIST, num)(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) */
+
+  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
+  {
+    /* 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
+     */
+    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 implemenations 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
+
+  class specialized;
+
+  template <typename T>
+  using aligned_storage_for =
+    typename std::aligned_storage<sizeof(T), alignof(T)>::type;
+
+  template <typename T = void>
+  std::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>
+
+    static aligned_storage_for<std::recursive_mutex> buffer;
+    static auto mutex = new (&buffer) std::recursive_mutex;
+    return std::unique_lock<std::recursive_mutex>{*mutex};
+  }
+
+  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;
+  };
+
+  inline
+    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)>;
+
+  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
+    reporter_func&
+    reporter_obj()
+  {
+    static reporter_func obj = default_reporter;
+    return obj;
+  }
+
+  inline
+    reporter_func
+    set_reporter(
+      reporter_func f)
+  {
+    return detail::exchange(reporter_obj(), std::move(f));
+  }
+
+  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:
+    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>
+  struct reporter
+  {
+    static
+      void
+      send(
+        severity s,
+        char const *file,
+        unsigned long line,
+        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>
+  inline
+    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
+  {
+    // This abomination of constructor seems necessary for g++ 4.9 and 5.1
+    template <typename ... T>
+    constexpr
+      wildcard(
+        T&& ...)
+      noexcept
+    {}
+
+#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 T,
+      typename = detail::enable_if_t<!std::is_lvalue_reference<T>::value>>
+      operator T && ()
+      const;
+
+#endif
+
+    template <
+      typename T,
+      typename = detail::enable_if_t<
+      can_copy_construct<T>::value
+      || !can_move_construct<T>::value
+      >
+    >
+      operator T&()
+      const;
+
+    template <typename T>
+    constexpr
+      bool
+      matches(
+        T const&)
+      const
+      noexcept
+    {
+      return true;
+    }
+
+    friend
+      std::ostream&
+      operator<<(
+        std::ostream& os,
+        wildcard const&)
+      noexcept
+    {
+      return os << " matching _";
+    }
+  };
+
+  static constexpr wildcard const _{};
+
+
+  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
+  {
+    operator T() const;
+  };
+
+  template <>
+  struct typed_matcher<std::nullptr_t> : matcher
+  {
+    template <typename T, typename = decltype(std::declval<T>() == nullptr)>
+    operator T && () const;
+
+    template <typename T,
+      typename = decltype(std::declval<T>() == nullptr),
+      typename = detail::enable_if_t<can_copy_construct<T>::value>>
+      operator T&()const;
+
+    template <typename T, typename C>
+    operator T C::*() const;
+  };
+
+  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;
+
+#endif
+
+    template <typename V,
+      typename = detail::enable_if_t < !is_matcher<V>{} > ,
+      typename = invoke_result_type<Pred, V&, T... >>
+      operator V&() const;
+  };
+
+  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
+  {
+    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()
+    {
+      os.flags(flags);
+      os.fill(fill);
+      os.width(width);
+    }
+  private:
+    std::ostream& os;
+    std::streamsize width;
+    std::ios_base::fmtflags flags;
+    char fill;
+  };
+
+  template <typename T, typename U>
+  using equality_comparison = decltype((std::declval<T>() == std::declval<U>())
+    ? true
+    : false);
+
+  template <typename T, typename U>
+  using is_equal_comparable = is_detected<equality_comparison, T, U>;
+
+  template <typename T>
+  using is_null_comparable = is_equal_comparable<T, std::nullptr_t>;
+
+  template <typename T>
+  inline
+    constexpr
+    bool
+    is_null(
+      T const &t,
+      std::true_type)
+    noexcept(noexcept(std::declval<const T&>() == nullptr))
+  {
+    return t == nullptr;
+  }
+
+  template <typename T>
+  inline
+    constexpr
+    bool
+    is_null(
+      T const &,
+      std::false_type)
+    noexcept
+  {
+    return false;
+  }
+
+  template <typename T>
+  inline
+    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<T>::value,
+    bool = is_collection<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 = "";
+      auto const end = std::end(t);
+      for (auto i = std::begin(t); i != end; ++i)
+      {
+        os << sep;
+        ::trompeloeil::print(os, *i);
+        sep = ", ";
+      }
+      os << " }";
+    }
+  };
+
+  template <typename T>
+  struct streamer<T, false, false>
+  {
+    static
+      void
+      print(
+        std::ostream& os,
+        T const &t)
+    {
+      stream_sentry s(os);
+      static const char *linebreak = "\n";
+      os << sizeof(T) << "-byte object={";
+      os << (linebreak + (sizeof(T) <= 8)); // stupid construction silences VS2015 warning
+      os << std::setfill('0') << std::hex;
+      auto p = reinterpret_cast<uint8_t const*>(&t);
+      for (size_t i = 0; i < sizeof(T); ++i)
+      {
+        os << " 0x" << std::setw(2) << unsigned(p[i]);
+        if ((i & 0xf) == 0xf) os << '\n';
+      }
+      os << " }";
+    }
+  };
+
+  template <typename T>
+  void
+    print(
+      std::ostream& os,
+      T const &t)
+  {
+    if (is_null(t))
+    {
+      os << "nullptr";
+    }
+    else
+    {
+      streamer<T>::print(os, t);
+    }
+  }
+
+  inline
+    constexpr
+    auto
+    param_compare_operator(
+      ...)
+    TROMPELOEIL_TRAILING_RETURN_TYPE(const char*)
+  {
+    return " == ";
+  }
+
+  inline
+    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();
+    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
+    : public std::iterator<std::bidirectional_iterator_tag, T>
+  {
+    friend class list<T, Disposer>;
+  public:
+    iterator()
+      noexcept
+      : p{ nullptr }
+    {}
+
+    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:
+    iterator(
+      list_elem<T> const *t)
+      noexcept
+      : p{ const_cast<list_elem<T>*>(t) }
+    {}
+
+    list_elem<T>* p;
+  };
+
+  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 p = i++;
+      Disposer::dispose(&*p);
+    }
+  }
+
+  template <typename T, typename Disposer>
+  auto
+    list<T, Disposer>::begin()
+    const
+    noexcept
+    -> iterator
+  {
+    return { next };
+  }
+
+  template <typename T, typename Disposer>
+  auto
+    list<T, Disposer>::end()
+    const
+    noexcept
+    -> iterator
+  {
+    return { 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 { 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 { 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;
+
+    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() : obj(new sequence_type) {}
+    sequence_type& operator*() { return *obj; }
+    bool is_completed() const { return obj->is_completed(); }
+  private:
+    std::unique_ptr<sequence_type> obj;
+  };
+
+  class sequence_matcher : public list_elem<sequence_matcher>
+  {
+  public:
+    using init_type = std::pair<char const*, sequence&>;
+    sequence_matcher(
+      char const *exp,
+      location loc,
+      init_type i)
+      noexcept
+      : seq_name(i.first)
+      , exp_name(exp)
+      , exp_loc(loc)
+      , 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);
+    }
+
+    bool
+      is_first()
+      const
+      noexcept
+    {
+      return seq.is_first(this);
+    }
+
+    void
+      retire()
+      noexcept
+    {
+      this->unlink();
+    }
+
+    void
+      print_expectation(std::ostream& os)
+      const
+    {
+      os << exp_name << " at " << exp_loc;
+    }
+
+    char const*
+      sequence_name()
+      noexcept
+    {
+      return seq_name;
+    }
+  private:
+    char const *seq_name;
+    char const *exp_name;
+    location    exp_loc;
+    sequence_type& seq;
+  };
+
+  inline
+    bool
+    sequence_type::is_completed()
+    const
+    noexcept
+  {
+    return matchers.empty();
+  }
+
+  inline
+    bool
+    sequence_type::is_first(
+      sequence_matcher const *m)
+    const
+    noexcept
+  {
+    return !matchers.empty() && &*matchers.begin() == m;
+  }
+
+  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;
+    for (auto& m : matchers)
+    {
+      std::ostringstream os;
+      os << "Sequence mismatch for sequence \"" << seq_name
+        << "\" with matching call of " << match_name
+        << " at " << loc
+        << ". Sequence \"" << seq_name << "\" has ";
+      m.print_expectation(os);
+      os << " first in line\n";
+      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;
+
+    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:
+        string_helper(
+          std::string const& s)
+          noexcept
+          : str(s.c_str())
+        {}
+
+        constexpr
+          string_helper(
+            char const* s)
+          noexcept
+          : str(s)
+        {}
+
+        char const*
+          c_str()
+          const
+          noexcept
+        {
+          return str;
+        }
+      private:
+        char const* str;
+      };
+
+      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 !::trompeloeil::is_null(str.c_str())
+          && std::regex_search(str.c_str(), 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(
+      ...)
+  {
+    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
+      : p{ nullptr }
+    {}
+
+    null_on_move(
+      T* p_)
+      noexcept
+      : p{ p_ }
+    {}
+
+    null_on_move(
+      null_on_move&&)
+      noexcept
+      : p{ nullptr }
+    {}
+
+    null_on_move(
+      null_on_move const&)
+      noexcept
+      : p{ nullptr }
+    {}
+
+    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;
+  };
+
+  struct sequence_handler_base
+  {
+    virtual
+      ~sequence_handler_base()
+      noexcept = default;
+
+    virtual
+      void
+      validate(severity s, char const *, location) = 0;
+
+    virtual
+      bool
+      is_first()
+      const
+      noexcept = 0;
+
+    virtual
+      void
+      retire()
+      noexcept = 0;
+  };
+
+  template <size_t N>
+  struct sequence_handler : public sequence_handler_base
+  {
+  public:
+    template <typename ... S>
+    sequence_handler(
+      char const *name,
+      location loc,
+      S&& ... s)
+      noexcept
+      : matchers{ {name, loc, 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);
+      }
+    }
+
+    bool
+      is_first()
+      const
+      noexcept
+      override
+    {
+      // 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& m : matchers)
+      {
+        if (!m.is_first()) return false;
+      }
+      return true;
+    }
+
+    void
+      retire()
+      noexcept
+      override
+    {
+      for (auto& e : matchers)
+      {
+        e.retire();
+      }
+    }
+  private:
+    sequence_matcher matchers[N];
+  };
+
+  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();
+
+    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;
+      if (sequences) sequences->validate(severity::nonfatal, call_name, loc);
+    }
+
+    template <typename ... T>
+    void
+      set_sequence(
+        T&& ... t)
+    {
+      auto seq = new sequence_handler<sizeof...(T)>(invocation_name,
+        loc,
+        std::forward<T>(t)...);
+      sequences.reset(seq);
+    }
+  private:
+    std::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;
+  };
+
+  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
+    }
+  };
+
+  template <typename R>
+  inline
+    R
+    default_return()
+  {
+    /* Work around VS 2017 15.7.x C4702 warning by
+     * enclosing the operation in an otherwise
+     * unnecessary try/catch block.
+     */
+    try
+    {
+      return default_return_t<R>::value();
+    }
+    catch (...)
+    {
+      throw;
+    }
+  }
+
+
+
+  template <>
+  inline
+    void
+    default_return<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 i = iter++;
+        auto &m = *i;
+        m.mock_destroyed();
+        m.unlink();
+      }
+    }
+  };
+
+  template <typename Sig>
+  struct call_matcher_base : public list_elem<call_matcher_base<Sig>>
+  {
+    call_matcher_base(
+      location loc_,
+      char const* name_)
+      : loc{ loc_ }
+      , name{ name_ }
+    {
+    }
+
+    call_matcher_base(call_matcher_base&&) = delete;
+
+    virtual
+      ~call_matcher_base() = default;
+
+    virtual
+      void
+      mock_destroyed() = 0;
+
+    virtual
+      bool
+      matches(
+        call_params_type_t<Sig> const&)
+      const = 0;
+
+    virtual
+      bool
+      first_in_sequence()
+      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,
+      ...)
+    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) + 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) + 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& 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;
+    for (auto& i : list)
+    {
+      if (i.matches(p))
+      {
+        if (i.first_in_sequence())
+        {
+          return &i;
+        }
+        if (!first_match)
+        {
+          first_match = &i;
+        }
+      }
+    }
+    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>
+  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&,
+      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>
+    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;
+  };
+
+  template <typename Sig>
+  class condition_base : public list_elem<condition_base<Sig>>
+  {
+  public:
+    condition_base(
+      char const *n)
+      noexcept
+      : id(n)
+    {}
+
+    virtual
+      ~condition_base() = 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>>
+  {
+    virtual
+      ~side_effect_base() = 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>
+    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 <unsigned long long L, unsigned long long H = L>
+  struct multiplicity { };
+
+  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, unsigned long long H>
+  struct call_limit_injector : Parent
+  {
+    static bool               const call_limit_set = true;
+    static unsigned long long const upper_call_limit = H;
+  };
+
+  template <typename Parent>
+  struct call_limit_injector<Parent, 0ULL> : Parent
+  {
+    static bool const call_limit_set = true;
+    static unsigned long long const upper_call_limit = 0ULL;
+  };
+
+  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::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 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
+
+      constexpr bool is_illegal_type = std::is_same<detail::decay_t<ret>, illegal_argument>::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(matching_ret_type || !void_signature,
+        "RETURN does not make sense for void-function");
+      static_assert(!is_illegal_type,
+        "RETURN illegal argument");
+      static_assert(!ptr_const_mismatch,
+        "RETURN const* from function returning pointer to non-const");
+      static_assert(!ref_value_mismatch || matching_ret_type,
+        "RETURN non-reference from function returning reference");
+      static_assert(ref_value_mismatch || !ref_const_mismatch,
+        "RETURN const& from function returning non-const reference");
+
+      static_assert(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_first_return,
+        "Multiple RETURN does not make sense");
+      static_assert(!throws || upper_call_limit == 0,
+        "THROW and RETURN does not make sense");
+      static_assert(upper_call_limit > 0ULL,
+        "RETURN for forbidden call does not make sense");
+
+      constexpr bool valid = !is_illegal_type && matching_ret_type && is_first_return && !throws && upper_call_limit > 0ULL;
+      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);
+    }
+
+  private:
+    template <typename H>
+    struct throw_handler_t
+    {
+      using R = decltype(default_return<return_of_t<signature>>());
+
+      throw_handler_t(H&& h_)
+        : h(std::forward<H>(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);
+        }
+        catch (...)
+        {
+          throw;
+        }
+        return R();
+      }
+
+    private:
+      H h;
+    };
+
+  public:
+    template <typename H>
+    call_modifier<Matcher, modifier_tag, throw_injector<Parent>>
+      handle_throw(
+        H&& h)
+    {
+      static_assert(!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(!forbidden,
+        "THROW for forbidden call does not make sense");
+
+      constexpr bool valid = !throws && !has_return;// && !forbidden;
+      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 <unsigned long long L,
+      unsigned long long 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->min_calls = L;
+      matcher->max_calls = 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 > 0ULL,
+        "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,
+      unsigned long long min_calls,
+      unsigned long long 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 return_type = void;
+    static unsigned long long 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;
+
+    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)...)
+    {}
+
+    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 call_count >= min_calls;
+    }
+
+    bool
+      is_saturated()
+      const
+      noexcept
+      override
+    {
+      auto lock = get_lock();
+      return call_count >= max_calls;
+    }
+    bool
+      is_unfulfilled()
+      const
+      noexcept
+    {
+      return !reported && this->is_linked() && call_count < min_calls;
+    }
+
+    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;
+    }
+
+    bool
+      first_in_sequence()
+      const
+      noexcept
+      override
+    {
+      auto saturated = call_count >= min_calls;
+      return saturated || !sequences || sequences->is_first();
+    }
+
+    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 (max_calls == 0)
+      {
+        reported = true;
+        report_forbidden_call(name, loc, params_string(params));
+      }
+      auto lock = get_lock();
+      {
+        if (call_count < min_calls && sequences)
+        {
+          sequences->validate(severity::fatal, name, loc);
+        }
+        if (++call_count == min_calls && sequences)
+        {
+          sequences->retire();
+        }
+        if (call_count == max_calls)
+        {
+          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)
+    {
+      reported = true;
+      report_unfulfilled(
+        reason,
+        name,
+        params_string(val),
+        min_calls,
+        call_count,
+        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)
+    {
+      auto seq = new sequence_handler<sizeof...(T)>(name,
+        loc,
+        std::forward<T>(t)...);
+      sequences.reset(seq);
+    }
+
+    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>
+    inline                           // 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
+
+    condition_list<Sig>                    conditions;
+    side_effect_list<Sig>                  actions;
+    std::unique_ptr<return_handler<Sig>>   return_handler_obj;
+    std::unique_ptr<sequence_handler_base> sequences;
+    unsigned long long                     call_count = 0;
+    std::atomic<unsigned long long>        min_calls{ 1 };
+    std::atomic<unsigned long long>        max_calls{ 1 };
+    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 N>
+  inline
+    constexpr
+    illegal_argument const
+    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>&& 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;
+      constexpr bool retmatch = std::is_same<ret, sigret>::value;
+      constexpr bool forbidden = call::upper_call_limit == 0ULL;
+      constexpr bool valid_return_type = call::throws || retmatch || forbidden;
+      static_assert(valid_return_type, "RETURN missing for non-void function");
+      auto tag = std::integral_constant<bool, valid_return_type>{};
+      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;
+  }
+
+  template <bool sequence_set>
+  struct lifetime_monitor_modifier
+  {
+    operator std::unique_ptr<lifetime_monitor>() { return std::move(monitor); }
+    template <typename ... T, bool b = sequence_set>
+    lifetime_monitor_modifier<true>
+      in_sequence(T&& ... t)
+    {
+      static_assert(!b,
+        "Multiple IN_SEQUENCE does not make sense."
+        " You can list several sequence objects at once");
+      monitor->set_sequence(std::forward<T>(t)...);
+      return { std::move(monitor) };
+    }
+    std::unique_ptr<lifetime_monitor> monitor;
+  };
+
+  struct lifetime_monitor_releaser
+  {
+    template <bool b>
+    std::unique_ptr<trompeloeil::lifetime_monitor>
+      operator+(
+        lifetime_monitor_modifier<b>&& m)
+      const
+    {
+      return m;
+    }
+  };
+
+  template <bool movable, typename Sig>
+  struct expectations
+  {
+    expectations() = default;
+    expectations(expectations&&) = 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&&)
+    {
+      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);
+    }
+    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(std::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__)
+
+#ifdef _MSC_VER
+#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(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(0, name)
+#define TROMPELOEIL_IMPLEMENT_MOCK1(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(1, name)
+#define TROMPELOEIL_IMPLEMENT_MOCK2(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(2, name)
+#define TROMPELOEIL_IMPLEMENT_MOCK3(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(3, name)
+#define TROMPELOEIL_IMPLEMENT_MOCK4(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(4, name)
+#define TROMPELOEIL_IMPLEMENT_MOCK5(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(5, name)
+#define TROMPELOEIL_IMPLEMENT_MOCK6(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(6, name)
+#define TROMPELOEIL_IMPLEMENT_MOCK7(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(7, name)
+#define TROMPELOEIL_IMPLEMENT_MOCK8(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(8, name)
+#define TROMPELOEIL_IMPLEMENT_MOCK9(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(9, name)
+#define TROMPELOEIL_IMPLEMENT_MOCK10(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(10, name)
+#define TROMPELOEIL_IMPLEMENT_MOCK11(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(11, name)
+#define TROMPELOEIL_IMPLEMENT_MOCK12(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(12, name)
+#define TROMPELOEIL_IMPLEMENT_MOCK13(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(13, name)
+#define TROMPELOEIL_IMPLEMENT_MOCK14(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(14, name)
+#define TROMPELOEIL_IMPLEMENT_MOCK15(name) \
+  TROMPELOEIL_IMPLEMENT_MOCK_(15, name)
+
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK0(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(0, name)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK1(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(1, name)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK2(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(2, name)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK3(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(3, name)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK4(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(4, name)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK5(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(5, name)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK6(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(6, name)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK7(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(7, name)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK8(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(8, name)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK9(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(9, name)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK10(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(10, name)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK11(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(11, name)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK12(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(12, name)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK13(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(13, name)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK14(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(14, name)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK15(name) \
+  TROMPELOEIL_IMPLEMENT_CONST_MOCK_(15, name)
+
+#define TROMPELOEIL_IMPLEMENT_MOCK_(num, name) \
+  TROMPELOEIL_MAKE_MOCK_(name,,num, decltype(::trompeloeil::nonconst_member_signature(&trompeloeil_interface_name::name))::type,override,)
+#define TROMPELOEIL_IMPLEMENT_CONST_MOCK_(num, name) \
+  TROMPELOEIL_MAKE_MOCK_(name,const,num, decltype(::trompeloeil::const_member_signature(&trompeloeil_interface_name::name))::type,override,)
+
+#define TROMPELOEIL_MAKE_MOCK_(name, constness, num, sig, spec, ...)           \
+  using TROMPELOEIL_LINE_ID(cardinality_match) =                               \
+    std::integral_constant<bool, num == ::trompeloeil::param_list<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<sig>;\
+  using TROMPELOEIL_LINE_ID(expectation_list_t) =                              \
+    ::trompeloeil::expectations<trompeloeil_movable_mock, 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<sig>::type;\
+                                                                               \
+    using trompeloeil_call_params_type_t =                                     \
+      ::trompeloeil::call_params_type_t<sig>;                                  \
+                                                                               \
+    using trompeloeil_return_of_t = ::trompeloeil::return_of_t<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<                             \
+                          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)...     \
+              }                                                                \
+      };                                                                       \
+    }                                                                          \
+  };                                                                           \
+                                                                               \
+  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<sig>                                              \
+  name(                                                                        \
+    TROMPELOEIL_PARAM_LIST(num, sig))                                          \
+  constness                                                                    \
+  spec                                                                         \
+  {                                                                            \
+    /* Use the auxiliary functions to avoid unneeded-member-function warning */\
+    using T_ ## name = typename std::remove_reference<decltype(*this)>::type;  \
+                                                                               \
+    using pmf_s_t = typename ::trompeloeil::signature_to_member_function<      \
+      T_ ## name, decltype(*this), sig>::type const;                           \
+                                                                               \
+    using pmf_e_t = typename ::trompeloeil::signature_to_member_function<      \
+      T_ ## name, TROMPELOEIL_LINE_ID(tag_type_trompeloeil), sig>::type const; \
+                                                                               \
+    pmf_s_t const s_ptr = &T_ ## name::trompeloeil_self_ ## name;              \
+    pmf_e_t const e_ptr = &T_ ## name::trompeloeil_tag_ ## name;               \
+                                                                               \
+    ::trompeloeil::ignore(s_ptr, e_ptr);                                       \
+                                                                               \
+    return ::trompeloeil::mock_func<trompeloeil_movable_mock, sig>(            \
+                                    TROMPELOEIL_LINE_ID(cardinality_match){},  \
+                                    TROMPELOEIL_LINE_ID(expectations),         \
+                                    #name,                                     \
+                                    #sig                                       \
+                                    TROMPELOEIL_PARAMS(num));                  \
+  }                                                                            \
+                                                                               \
+  auto                                                                         \
+  trompeloeil_self_ ## name(TROMPELOEIL_PARAM_LIST(num, sig)) constness        \
+    -> decltype(*this)                                                         \
+  {                                                                            \
+    ::trompeloeil::ignore(#name TROMPELOEIL_PARAMS(num));                      \
+    return *this;                                                              \
+  }                                                                            \
+                                                                               \
+  TROMPELOEIL_LINE_ID(tag_type_trompeloeil)                                    \
+  trompeloeil_tag_ ## name(TROMPELOEIL_PARAM_LIST(num, sig)) constness         \
+  {                                                                            \
+    ::trompeloeil::ignore(#name TROMPELOEIL_PARAMS(num));                      \
+    return {nullptr, 0ul, nullptr};                                            \
+  }                                                                            \
+                                                                               \
+  mutable TROMPELOEIL_LINE_ID(expectation_list_t) TROMPELOEIL_LINE_ID(expectations){}
+
+
+#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__)
+
+
+#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__                                                              \
+      ;                                                                        \
+  }()
+
+
+#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_TIMES(0, ~0ULL))
+
+// Accept three or more arguments.
+#define TROMPELOEIL_ALLOW_CALL_T(obj, func, ...)                               \
+  TROMPELOEIL_REQUIRE_CALL_T(obj,                                              \
+                             func,                                             \
+                             .TROMPELOEIL_TIMES(0, ~0ULL) __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_TIMES(0, ~0ULL))
+
+// Accept three or more arguments.
+#define TROMPELOEIL_NAMED_ALLOW_CALL_T(obj, func, ...)                         \
+  TROMPELOEIL_NAMED_REQUIRE_CALL_T(obj,                                        \
+                                   func,                                       \
+                                   .TROMPELOEIL_TIMES(0, ~0ULL) __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_TIMES(0, ~0ULL)
+
+
+#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_TIMES(0, ~0ULL)
+
+
+#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]                                                                  \
+    (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](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](trompeloeil_e_t::trompeloeil_call_params_type_t& trompeloeil_x)  \
+      -> 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__);                      \
+  })
+
+#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](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) */
+
+
+#define TROMPELOEIL_TIMES(...) times(::trompeloeil::multiplicity<__VA_ARGS__>{})
+
+#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, ~0ULL
+#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
+
+#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