From 93494768f72c44414b861ba3ae9ff570f677027a Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Sat, 8 Dec 2018 08:49:55 +0800
Subject: [PATCH 01/38] Added class HeterEventDispatcher

---
 include/eventpp/hetereventdispatcher.h        | 221 ++++++++++++++++++
 tests/unittest/CMakeLists.txt                 |   1 +
 tests/unittest/test_heterdispatcher_basic.cpp |  43 ++++
 3 files changed, 265 insertions(+)
 create mode 100644 include/eventpp/hetereventdispatcher.h
 create mode 100644 tests/unittest/test_heterdispatcher_basic.cpp

diff --git a/include/eventpp/hetereventdispatcher.h b/include/eventpp/hetereventdispatcher.h
new file mode 100644
index 0000000..d7be967
--- /dev/null
+++ b/include/eventpp/hetereventdispatcher.h
@@ -0,0 +1,221 @@
+// eventpp library
+// Copyright (C) 2018 Wang Qi (wqking)
+// Github: https://github.com/wqking/eventpp
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//   http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef HETEREVENTDISPATCHER_H_127766658555
+#define HETEREVENTDISPATCHER_H_127766658555
+
+#include "eventdispatcher.h"
+
+#include <array>
+#include <string>
+#include <functional>
+#include <type_traits>
+#include <map>
+#include <unordered_map>
+#include <mutex>
+#include <algorithm>
+#include <memory>
+#include <tuple>
+
+namespace eventpp {
+
+template <typename ...Types>
+struct PrototypeList
+{
+	enum { size = sizeof...(Types) };
+};
+
+template <typename ...Args>
+struct CanConvert
+{
+	enum { value = false };
+};
+
+template <typename From, typename ...FromArgs, typename To, typename ...ToArgs>
+struct CanConvert <std::tuple<From, FromArgs...>, std::tuple<To, ToArgs...> >
+{
+	enum { value = std::is_convertible<From, To>::value && CanConvert<std::tuple<FromArgs...>, std::tuple<ToArgs...> >::value };
+};
+
+template <>
+struct CanConvert <std::tuple<>, std::tuple<> >
+{
+	enum { value = true };
+};
+
+template <int N, typename PrototypeList_, typename ...InArgs>
+struct FindCallablePrototypeHelper
+{
+	using Prototype = void;
+	enum {index = -1 };
+};
+
+template <int N, typename RT, typename ...Args, typename ...Others, typename ...InArgs>
+struct FindCallablePrototypeHelper <N, PrototypeList<RT (Args...), Others...>, InArgs...>
+{
+	using Prototype = typename std::conditional<
+		CanConvert<std::tuple<InArgs...>, std::tuple<Args...> >::value,
+		RT (Args...),
+		typename FindCallablePrototypeHelper<N + 1, PrototypeList<Others...>, InArgs...>::Prototype
+	>::type;
+	enum {
+		index = CanConvert<std::tuple<InArgs...>, std::tuple<Args...> >::value
+			? N
+			: FindCallablePrototypeHelper<N + 1, PrototypeList<Others...>, InArgs...>::index
+	};
+};
+
+template <typename PrototypeList_, typename ...InArgs>
+struct FindCallablePrototype : public FindCallablePrototypeHelper <0, PrototypeList_, InArgs...>
+{
+};
+
+
+
+namespace internal_ {
+
+template <
+	typename EventType,
+	typename PrototypeList_,
+	typename PoliciesType,
+	typename MixinRoot_
+>
+class HeterEventDispatcherBase
+{
+private:
+	template <typename T>
+	class CallableInvoker
+	{
+	};
+
+	template <typename RT, typename ...Args>
+	class CallableInvoker <RT (Args...)> : public EventDispatcher<EventType, RT (Args...), PoliciesType>
+	{
+	public:
+	private:
+	};
+
+protected:
+	using ThisType = HeterEventDispatcherBase<
+		EventType,
+		PrototypeList_,
+		PoliciesType,
+		MixinRoot_
+	>;
+
+	using Policies = PoliciesType;
+	using Threading = typename SelectThreading<Policies, HasTypeThreading<Policies>::value>::Type;
+
+	enum { prototypeCount = PrototypeList_::size };
+
+public:
+	using Event = EventType;
+	using Mutex = typename Threading::Mutex;
+
+public:
+	HeterEventDispatcherBase()
+	{
+	}
+
+	HeterEventDispatcherBase(const HeterEventDispatcherBase & other)
+	{
+	}
+
+	HeterEventDispatcherBase(HeterEventDispatcherBase && other) noexcept
+	{
+	}
+
+	HeterEventDispatcherBase & operator = (const HeterEventDispatcherBase & other)
+	{
+	}
+
+	HeterEventDispatcherBase & operator = (HeterEventDispatcherBase && other) noexcept
+	{
+	}
+
+	void swap(HeterEventDispatcherBase & other) noexcept {
+		using std::swap;
+		
+		//swap(eventCallbackListMap, other.eventCallbackListMap);
+	}
+	
+	friend void swap(HeterEventDispatcherBase & first, HeterEventDispatcherBase & second) noexcept {
+		first.swap(second);
+	}
+
+	template <template <typename> class F, typename RT, typename ...Args>
+	void appendListener(const Event & event, const F<RT(Args...)> & callback)
+	{
+		auto invoker = doFindCallableInvoker<Args...>();
+		invoker->appendListener(event, callback);
+	}
+
+	template <typename ...Args>
+	void dispatch(Args ...args) const
+	{
+		auto invoker = doFindCallableInvoker<Args...>();
+		invoker->dispatch(std::forward<Args>(args)...);
+	}
+
+private:
+	template <typename ...Args>
+	auto doFindCallableInvoker() const
+		-> std::shared_ptr<CallableInvoker<typename FindCallablePrototype<PrototypeList_, Args...>::Prototype> >
+	{
+		using FindResult = FindCallablePrototype<PrototypeList_, Args...>;
+		static_assert(FindResult::index >= 0, "Can't find invoker for the given argument types.");
+
+		if(! callableInvokerList[FindResult::index]) {
+			if(! callableInvokerList[FindResult::index]) {
+				std::lock_guard<Mutex> lockGuard(callableInvokerListMutex);
+				callableInvokerList[FindResult::index] = std::make_shared<CallableInvoker<typename FindResult::Prototype> >();
+			}
+		}
+
+		return std::static_pointer_cast<CallableInvoker<typename FindResult::Prototype> >(callableInvokerList[FindResult::index]);
+	}
+
+private:
+	mutable std::array<std::shared_ptr<void>, prototypeCount> callableInvokerList;
+	mutable Mutex callableInvokerListMutex;
+};
+
+
+} //namespace internal_
+
+template <
+	typename Event_,
+	typename PrototypeList_,
+	typename Policies_ = DefaultPolicies
+>
+class HeterEventDispatcher : public internal_::InheritMixins<
+		internal_::HeterEventDispatcherBase<Event_, PrototypeList_, Policies_, void>,
+		typename internal_::SelectMixins<Policies_, internal_::HasTypeMixins<Policies_>::value >::Type
+	>::Type, public TagEventDispatcher
+{
+private:
+	using super = typename internal_::InheritMixins<
+		internal_::HeterEventDispatcherBase<Event_, PrototypeList_, Policies_, void>,
+		typename internal_::SelectMixins<Policies_, internal_::HasTypeMixins<Policies_>::value >::Type
+	>::Type;
+
+public:
+	using super::super;
+};
+
+
+} //namespace eventpp
+
+
+#endif
+
diff --git a/tests/unittest/CMakeLists.txt b/tests/unittest/CMakeLists.txt
index c087fa4..f6fcfce 100644
--- a/tests/unittest/CMakeLists.txt
+++ b/tests/unittest/CMakeLists.txt
@@ -13,6 +13,7 @@ set(SRC_TEST
 	test_dispatcher_multithread.cpp
 	test_queue_basic.cpp
 	test_queue_multithread.cpp
+	test_heterdispatcher_basic.cpp
 	test_eventutil.cpp
 	test_conditionalremover.cpp
 	test_counterremover.cpp
diff --git a/tests/unittest/test_heterdispatcher_basic.cpp b/tests/unittest/test_heterdispatcher_basic.cpp
new file mode 100644
index 0000000..9c61b94
--- /dev/null
+++ b/tests/unittest/test_heterdispatcher_basic.cpp
@@ -0,0 +1,43 @@
+// eventpp library
+// Copyright (C) 2018 Wang Qi (wqking)
+// Github: https://github.com/wqking/eventpp
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//   http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "test.h"
+#include "eventpp/hetereventdispatcher.h"
+
+#include <iostream>
+
+using namespace eventpp;
+struct xxx{};
+TEST_CASE("HeterEventDispatcher, xxx")
+{
+	static_assert(CanConvert<std::tuple<int, int>, std::tuple<int ,int> >::value, "");
+	static_assert(FindCallablePrototype<PrototypeList<void (), void (int, int)> >::index == 0, "");
+	static_assert(FindCallablePrototype<PrototypeList<void (int), void (int, int)>, char>::index == 0, "");
+	static_assert(FindCallablePrototype<PrototypeList<void (int), void (int, int)>, char, int>::index == 1, "");
+	static_assert(FindCallablePrototype<PrototypeList<void (int), void (int, int), void (int, const xxx &)>, int, xxx>::index == 2, "");
+
+	HeterEventDispatcher<int, PrototypeList<void (), void (int)> > a;
+	a.appendListener(3, std::function<void ()>([]() {
+		std::cout << "empty" << std::endl;
+	}));
+	a.appendListener(3, std::function<void (int)>([](int a) {
+		std::cout << "3 a = " << a << std::endl;
+	}));
+	a.appendListener(8, std::function<void (int)>([](int a) {
+		std::cout << "8 a = " << a << std::endl;
+	}));
+	a.dispatch(3);
+	a.dispatch(8);
+	//a.dispatch(8, 5);
+}
+

From 21baa6b5d99da1ebbf2ea20a310a5eba3f1de1cf Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Sat, 8 Dec 2018 12:42:59 +0800
Subject: [PATCH 02/38] Added Handle and removeListener to HeterEventDispatcher

---
 include/eventpp/hetereventdispatcher.h        | 91 +++++++++++++++----
 tests/unittest/test_heterdispatcher_basic.cpp |  5 +-
 2 files changed, 74 insertions(+), 22 deletions(-)

diff --git a/include/eventpp/hetereventdispatcher.h b/include/eventpp/hetereventdispatcher.h
index d7be967..c1dd02d 100644
--- a/include/eventpp/hetereventdispatcher.h
+++ b/include/eventpp/hetereventdispatcher.h
@@ -27,6 +27,8 @@
 #include <memory>
 #include <tuple>
 
+// source code for heterogeneous dispatcher
+
 namespace eventpp {
 
 template <typename ...Types>
@@ -93,16 +95,36 @@ template <
 class HeterEventDispatcherBase
 {
 private:
-	template <typename T>
-	class CallableInvoker
+	struct Handle_
 	{
+		int index;
+		std::weak_ptr<void> homoHandle;
+
+		operator bool () const noexcept {
+			return (bool)homoHandle;
+		}
 	};
 
-	template <typename RT, typename ...Args>
-	class CallableInvoker <RT (Args...)> : public EventDispatcher<EventType, RT (Args...), PoliciesType>
+	class HomoDispatcherTypeBase
 	{
 	public:
+		virtual bool doRemoveListener(const EventType & event, const Handle_ & handle) = 0;
+	};
+
+	template <typename T>
+	class HomoDispatcherType : public EventDispatcher<EventType, T, PoliciesType>, public HomoDispatcherTypeBase
+	{
 	private:
+		using super = EventDispatcher<EventType, T, PoliciesType>;
+
+	public:
+		virtual bool doRemoveListener(const EventType & event, const Handle_ & handle) override {
+			auto sp = handle.homoHandle.lock();
+			if(! sp) {
+				return false;
+			}
+			return this->removeListener(event, typename super::Handle(std::static_pointer_cast<typename super::Handle::element_type>(sp)));
+		}
 	};
 
 protected:
@@ -116,9 +138,13 @@ class HeterEventDispatcherBase
 	using Policies = PoliciesType;
 	using Threading = typename SelectThreading<Policies, HasTypeThreading<Policies>::value>::Type;
 
+	// Disable ArgumentPassingMode explicitly
+	static_assert(! HasTypeArgumentPassingMode<Policies>::value, "Policies can't have ArgumentPassingMode in heterogeneous dispatcher.");
+
 	enum { prototypeCount = PrototypeList_::size };
 
 public:
+	using Handle = Handle_;
 	using Event = EventType;
 	using Mutex = typename Threading::Mutex;
 
@@ -154,39 +180,64 @@ class HeterEventDispatcherBase
 	}
 
 	template <template <typename> class F, typename RT, typename ...Args>
-	void appendListener(const Event & event, const F<RT(Args...)> & callback)
+	Handle appendListener(const Event & event, const F<RT(Args...)> & callback)
 	{
-		auto invoker = doFindCallableInvoker<Args...>();
-		invoker->appendListener(event, callback);
+		using FindResult = FindCallablePrototype<PrototypeList_, Args...>;
+		auto dispatcher = doFindDispatcher<FindResult>();
+		return Handle {
+			FindResult::index,
+			dispatcher->appendListener(event, callback)
+		};
 	}
 
-	template <typename ...Args>
-	void dispatch(Args ...args) const
+	template <template <typename> class F, typename RT, typename ...Args>
+	Handle prependListener(const Event & event, const F<RT(Args...)> & callback)
 	{
-		auto invoker = doFindCallableInvoker<Args...>();
-		invoker->dispatch(std::forward<Args>(args)...);
+		using FindResult = FindCallablePrototype<PrototypeList_, Args...>;
+		auto dispatcher = doFindDispatcher<FindResult>();
+		return Handle {
+			FindResult::index,
+			dispatcher->prependListener(event, callback)
+		};
 	}
 
-private:
-	template <typename ...Args>
-	auto doFindCallableInvoker() const
-		-> std::shared_ptr<CallableInvoker<typename FindCallablePrototype<PrototypeList_, Args...>::Prototype> >
+	bool removeListener(const Event & event, const Handle & handle)
+	{
+		auto dispatcher = dispatcherList[handle.index];
+		if(dispatcher) {
+			return dispatcher->doRemoveListener(event, handle);
+		}
+
+		return false;
+	}
+
+	template <typename T, typename ...Args>
+	void dispatch(T && first, Args ...args) const
 	{
 		using FindResult = FindCallablePrototype<PrototypeList_, Args...>;
+		auto dispatcher = doFindDispatcher<FindResult>();
+		dispatcher->dispatch(std::forward<T>(first), std::forward<Args>(args)...);
+	}
+
+private:
+	template <typename FindResult>
+	auto doFindDispatcher() const
+		-> HomoDispatcherType<typename FindResult::Prototype> *
+	{
 		static_assert(FindResult::index >= 0, "Can't find invoker for the given argument types.");
 
-		if(! callableInvokerList[FindResult::index]) {
-			if(! callableInvokerList[FindResult::index]) {
+		if(! dispatcherList[FindResult::index]) {
+			if(! dispatcherList[FindResult::index]) {
 				std::lock_guard<Mutex> lockGuard(callableInvokerListMutex);
-				callableInvokerList[FindResult::index] = std::make_shared<CallableInvoker<typename FindResult::Prototype> >();
+				dispatcherList[FindResult::index] = std::make_shared<HomoDispatcherType<typename FindResult::Prototype> >();
 			}
 		}
 
-		return std::static_pointer_cast<CallableInvoker<typename FindResult::Prototype> >(callableInvokerList[FindResult::index]);
+		return static_cast<HomoDispatcherType<typename FindResult::Prototype> *>(dispatcherList[FindResult::index].get());
 	}
 
 private:
-	mutable std::array<std::shared_ptr<void>, prototypeCount> callableInvokerList;
+	mutable std::array<std::shared_ptr<HomoDispatcherTypeBase>, prototypeCount> dispatcherList;
 	mutable Mutex callableInvokerListMutex;
 };
 
diff --git a/tests/unittest/test_heterdispatcher_basic.cpp b/tests/unittest/test_heterdispatcher_basic.cpp
index 9c61b94..87dde50 100644
--- a/tests/unittest/test_heterdispatcher_basic.cpp
+++ b/tests/unittest/test_heterdispatcher_basic.cpp
@@ -27,9 +27,10 @@ TEST_CASE("HeterEventDispatcher, xxx")
 	static_assert(FindCallablePrototype<PrototypeList<void (int), void (int, int), void (int, const xxx &)>, int, xxx>::index == 2, "");
 
 	HeterEventDispatcher<int, PrototypeList<void (), void (int)> > a;
-	a.appendListener(3, std::function<void ()>([]() {
+	auto handle = a.appendListener(3, std::function<void ()>([]() {
 		std::cout << "empty" << std::endl;
 	}));
+	a.removeListener(3, handle);
 	a.appendListener(3, std::function<void (int)>([](int a) {
 		std::cout << "3 a = " << a << std::endl;
 	}));
@@ -38,6 +39,6 @@ TEST_CASE("HeterEventDispatcher, xxx")
 	}));
 	a.dispatch(3);
 	a.dispatch(8);
-	//a.dispatch(8, 5);
+	a.dispatch(8, 5);
 }
 

From 11d8c3f3ecef664764d58750349a041b2b38f0b0 Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Sat, 8 Dec 2018 15:44:47 +0800
Subject: [PATCH 03/38] Use std::tuple instead of PrototypeList

---
 include/eventpp/hetereventdispatcher.h        | 14 ++++----------
 tests/unittest/test_heterdispatcher_basic.cpp | 10 +++++-----
 2 files changed, 9 insertions(+), 15 deletions(-)

diff --git a/include/eventpp/hetereventdispatcher.h b/include/eventpp/hetereventdispatcher.h
index c1dd02d..fe69067 100644
--- a/include/eventpp/hetereventdispatcher.h
+++ b/include/eventpp/hetereventdispatcher.h
@@ -31,12 +31,6 @@
 
 namespace eventpp {
 
-template <typename ...Types>
-struct PrototypeList
-{
-	enum { size = sizeof...(Types) };
-};
-
 template <typename ...Args>
 struct CanConvert
 {
@@ -63,17 +57,17 @@ struct FindCallablePrototypeHelper
 };
 
 template <int N, typename RT, typename ...Args, typename ...Others, typename ...InArgs>
-struct FindCallablePrototypeHelper <N, PrototypeList<RT (Args...), Others...>, InArgs...>
+struct FindCallablePrototypeHelper <N, std::tuple<RT (Args...), Others...>, InArgs...>
 {
 	using Prototype = typename std::conditional<
 		CanConvert<std::tuple<InArgs...>, std::tuple<Args...> >::value,
 		RT (Args...),
-		typename FindCallablePrototypeHelper<N + 1, PrototypeList<Others...>, InArgs...>::Prototype
+		typename FindCallablePrototypeHelper<N + 1, std::tuple<Others...>, InArgs...>::Prototype
 	>::type;
 	enum {
 		index = CanConvert<std::tuple<InArgs...>, std::tuple<Args...> >::value
 			? N
-			: FindCallablePrototypeHelper<N + 1, PrototypeList<Others...>, InArgs...>::index
+			: FindCallablePrototypeHelper<N + 1, std::tuple<Others...>, InArgs...>::index
 	};
 };
 
@@ -141,7 +135,7 @@ class HeterEventDispatcherBase
 	// Disable ArgumentPassingMode explicitly
 	static_assert(! HasTypeArgumentPassingMode<Policies>::value, "Policies can't have ArgumentPassingMode in heterogeneous dispatcher.");
 
-	enum { prototypeCount = PrototypeList_::size };
+	enum { prototypeCount = std::tuple_size<PrototypeList_>::value };
 
 public:
 	using Handle = Handle_;
diff --git a/tests/unittest/test_heterdispatcher_basic.cpp b/tests/unittest/test_heterdispatcher_basic.cpp
index 87dde50..f0e6595 100644
--- a/tests/unittest/test_heterdispatcher_basic.cpp
+++ b/tests/unittest/test_heterdispatcher_basic.cpp
@@ -21,12 +21,12 @@ struct xxx{};
 TEST_CASE("HeterEventDispatcher, xxx")
 {
 	static_assert(CanConvert<std::tuple<int, int>, std::tuple<int ,int> >::value, "");
-	static_assert(FindCallablePrototype<PrototypeList<void (), void (int, int)> >::index == 0, "");
-	static_assert(FindCallablePrototype<PrototypeList<void (int), void (int, int)>, char>::index == 0, "");
-	static_assert(FindCallablePrototype<PrototypeList<void (int), void (int, int)>, char, int>::index == 1, "");
-	static_assert(FindCallablePrototype<PrototypeList<void (int), void (int, int), void (int, const xxx &)>, int, xxx>::index == 2, "");
+	static_assert(FindCallablePrototype<std::tuple<void (), void (int, int)> >::index == 0, "");
+	static_assert(FindCallablePrototype<std::tuple<void (int), void (int, int)>, char>::index == 0, "");
+	static_assert(FindCallablePrototype<std::tuple<void (int), void (int, int)>, char, int>::index == 1, "");
+	static_assert(FindCallablePrototype<std::tuple<void (int), void (int, int), void (int, const xxx &)>, int, xxx>::index == 2, "");
 
-	HeterEventDispatcher<int, PrototypeList<void (), void (int)> > a;
+	HeterEventDispatcher<int, std::tuple<void (), void (int)> > a;
 	auto handle = a.appendListener(3, std::function<void ()>([]() {
 		std::cout << "empty" << std::endl;
 	}));

From 8e16ae2e90043ffe70c25145e5916f68e00f6902 Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Sat, 8 Dec 2018 16:11:53 +0800
Subject: [PATCH 04/38] Enclosed internal code with namespace internal_

---
 include/eventpp/hetereventdispatcher.h        |  3 +++
 tests/unittest/test_heterdispatcher_basic.cpp | 15 +++++++--------
 2 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/include/eventpp/hetereventdispatcher.h b/include/eventpp/hetereventdispatcher.h
index fe69067..90e8eb7 100644
--- a/include/eventpp/hetereventdispatcher.h
+++ b/include/eventpp/hetereventdispatcher.h
@@ -31,6 +31,8 @@
 
 namespace eventpp {
 
+namespace internal_ {
+
 template <typename ...Args>
 struct CanConvert
 {
@@ -76,6 +78,7 @@ struct FindCallablePrototype : public FindCallablePrototypeHelper <0, PrototypeL
 {
 };
 
+} //namespace internal_
 
 
 namespace internal_ {
diff --git a/tests/unittest/test_heterdispatcher_basic.cpp b/tests/unittest/test_heterdispatcher_basic.cpp
index f0e6595..b0d72cb 100644
--- a/tests/unittest/test_heterdispatcher_basic.cpp
+++ b/tests/unittest/test_heterdispatcher_basic.cpp
@@ -16,17 +16,16 @@
 
 #include <iostream>
 
-using namespace eventpp;
 struct xxx{};
+static_assert(eventpp::internal_::CanConvert<std::tuple<int, int>, std::tuple<int ,int> >::value, "");
+static_assert(eventpp::internal_::FindCallablePrototype<std::tuple<void (), void (int, int)> >::index == 0, "");
+static_assert(eventpp::internal_::FindCallablePrototype<std::tuple<void (int), void (int, int)>, char>::index == 0, "");
+static_assert(eventpp::internal_::FindCallablePrototype<std::tuple<void (int), void (int, int)>, char, int>::index == 1, "");
+static_assert(eventpp::internal_::FindCallablePrototype<std::tuple<void (int), void (int, int), void (int, const xxx &)>, int, xxx>::index == 2, "");
+
 TEST_CASE("HeterEventDispatcher, xxx")
 {
-	static_assert(CanConvert<std::tuple<int, int>, std::tuple<int ,int> >::value, "");
-	static_assert(FindCallablePrototype<std::tuple<void (), void (int, int)> >::index == 0, "");
-	static_assert(FindCallablePrototype<std::tuple<void (int), void (int, int)>, char>::index == 0, "");
-	static_assert(FindCallablePrototype<std::tuple<void (int), void (int, int)>, char, int>::index == 1, "");
-	static_assert(FindCallablePrototype<std::tuple<void (int), void (int, int), void (int, const xxx &)>, int, xxx>::index == 2, "");
-
-	HeterEventDispatcher<int, std::tuple<void (), void (int)> > a;
+	eventpp::HeterEventDispatcher<int, std::tuple<void (), void (int)> > a;
 	auto handle = a.appendListener(3, std::function<void ()>([]() {
 		std::cout << "empty" << std::endl;
 	}));

From 8fddc0913598279d916848d727bb08b43f29c39d Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Sun, 9 Dec 2018 16:13:42 +0800
Subject: [PATCH 05/38] Improved ctors in HeterEventDispatcher

---
 include/eventpp/hetereventdispatcher.h        | 28 ++++++++++--
 tests/unittest/test_heterdispatcher_basic.cpp | 44 +++++++++++++------
 2 files changed, 54 insertions(+), 18 deletions(-)

diff --git a/include/eventpp/hetereventdispatcher.h b/include/eventpp/hetereventdispatcher.h
index 90e8eb7..ac018ed 100644
--- a/include/eventpp/hetereventdispatcher.h
+++ b/include/eventpp/hetereventdispatcher.h
@@ -106,6 +106,7 @@ class HeterEventDispatcherBase
 	{
 	public:
 		virtual bool doRemoveListener(const EventType & event, const Handle_ & handle) = 0;
+		virtual std::shared_ptr<HomoDispatcherTypeBase> doClone() = 0;
 	};
 
 	template <typename T>
@@ -122,6 +123,10 @@ class HeterEventDispatcherBase
 			}
 			return this->removeListener(event, typename super::Handle(std::static_pointer_cast<typename super::Handle::element_type>(sp)));
 		}
+
+		virtual std::shared_ptr<HomoDispatcherTypeBase> doClone() override {
+			return std::make_shared<HomoDispatcherType<T> >(*this);
+		}
 	};
 
 protected:
@@ -147,29 +152,44 @@ class HeterEventDispatcherBase
 
 public:
 	HeterEventDispatcherBase()
+		:
+			dispatcherList(),
+			dispatcherListMutex()
 	{
 	}
 
 	HeterEventDispatcherBase(const HeterEventDispatcherBase & other)
 	{
+		for(size_t i = 0; i < dispatcherList.size(); ++i) {
+			dispatcherList[i] = other.dispatcherList[i]->doClone();
+		}
 	}
 
 	HeterEventDispatcherBase(HeterEventDispatcherBase && other) noexcept
+		:
+			dispatcherList(std::move(other.dispatcherList)),
+			dispatcherListMutex()
 	{
 	}
 
-	HeterEventDispatcherBase & operator = (const HeterEventDispatcherBase & other)
+	HeterEventDispatcherBase & operator = (HeterEventDispatcherBase other)
 	{
+		swap(*this, other);
+
+		return *this;
 	}
 
 	HeterEventDispatcherBase & operator = (HeterEventDispatcherBase && other) noexcept
 	{
+		dispatcherList = std::move(other.dispatcherList);
+
+		return *this;
 	}
 
 	void swap(HeterEventDispatcherBase & other) noexcept {
 		using std::swap;
 		
-		//swap(eventCallbackListMap, other.eventCallbackListMap);
+		swap(dispatcherList, other.dispatcherList);
 	}
 	
 	friend void swap(HeterEventDispatcherBase & first, HeterEventDispatcherBase & second) noexcept {
@@ -225,7 +245,7 @@ class HeterEventDispatcherBase
 
 		if(! dispatcherList[FindResult::index]) {
 			if(! dispatcherList[FindResult::index]) {
-				std::lock_guard<Mutex> lockGuard(callableInvokerListMutex);
+				std::lock_guard<Mutex> lockGuard(dispatcherListMutex);
 				dispatcherList[FindResult::index] = std::make_shared<HomoDispatcherType<typename FindResult::Prototype> >();
 			}
 		}
@@ -235,7 +255,7 @@ class HeterEventDispatcherBase
 
 private:
 	mutable std::array<std::shared_ptr<HomoDispatcherTypeBase>, prototypeCount> dispatcherList;
-	mutable Mutex callableInvokerListMutex;
+	mutable Mutex dispatcherListMutex;
 };
 
 
diff --git a/tests/unittest/test_heterdispatcher_basic.cpp b/tests/unittest/test_heterdispatcher_basic.cpp
index b0d72cb..bad0d7a 100644
--- a/tests/unittest/test_heterdispatcher_basic.cpp
+++ b/tests/unittest/test_heterdispatcher_basic.cpp
@@ -14,8 +14,6 @@
 #include "test.h"
 #include "eventpp/hetereventdispatcher.h"
 
-#include <iostream>
-
 struct xxx{};
 static_assert(eventpp::internal_::CanConvert<std::tuple<int, int>, std::tuple<int ,int> >::value, "");
 static_assert(eventpp::internal_::FindCallablePrototype<std::tuple<void (), void (int, int)> >::index == 0, "");
@@ -23,21 +21,39 @@ static_assert(eventpp::internal_::FindCallablePrototype<std::tuple<void (int), v
 static_assert(eventpp::internal_::FindCallablePrototype<std::tuple<void (int), void (int, int)>, char, int>::index == 1, "");
 static_assert(eventpp::internal_::FindCallablePrototype<std::tuple<void (int), void (int, int), void (int, const xxx &)>, int, xxx>::index == 2, "");
 
-TEST_CASE("HeterEventDispatcher, xxx")
+TEST_CASE("xxx HeterEventDispatcher, 1")
 {
-	eventpp::HeterEventDispatcher<int, std::tuple<void (), void (int)> > a;
-	auto handle = a.appendListener(3, std::function<void ()>([]() {
-		std::cout << "empty" << std::endl;
+	eventpp::HeterEventDispatcher<int, std::tuple<void (), void (int, int, int)> > dispatcher;
+
+	std::array<int, 2> dataList{};
+
+	dispatcher.appendListener(3, std::function<void ()>([&dataList]() {
+		++dataList[0];
 	}));
-	a.removeListener(3, handle);
-	a.appendListener(3, std::function<void (int)>([](int a) {
-		std::cout << "3 a = " << a << std::endl;
+	dispatcher.appendListener(3, std::function<void (int, int, int)>([&dataList](int a, int b, int c) {
+		dataList[1] += a + b + c;
 	}));
-	a.appendListener(8, std::function<void (int)>([](int a) {
-		std::cout << "8 a = " << a << std::endl;
+	dispatcher.appendListener(8, std::function<void (int, int, int)>([&dataList](int a, int b, int c) {
+		dataList[1] += a + b + c;
 	}));
-	a.dispatch(3);
-	a.dispatch(8);
-	a.dispatch(8, 5);
+	
+	REQUIRE(dataList[0] == 0);
+	REQUIRE(dataList[1] == 0);
+
+	dispatcher.dispatch(3);
+	REQUIRE(dataList[0] == 1);
+	REQUIRE(dataList[1] == 0);
+
+	dispatcher.dispatch(8);
+	REQUIRE(dataList[0] == 1);
+	REQUIRE(dataList[1] == 0);
+
+	dispatcher.dispatch(8, 5, 1, 3);
+	REQUIRE(dataList[0] == 1);
+	REQUIRE(dataList[1] == 9);
+
+	dispatcher.dispatch(3, 2, 6, 7);
+	REQUIRE(dataList[0] == 1);
+	REQUIRE(dataList[1] == 24);
 }
 

From eac2f1ab02ac88bd78864bfb9ba84a76fc0e61bf Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Sun, 9 Dec 2018 20:01:40 +0800
Subject: [PATCH 06/38] Simplified callback type in HeterEventDispatcher

---
 include/eventpp/callbacklist.h                | 14 --------
 include/eventpp/hetereventdispatcher.h        | 32 +++++++++----------
 include/eventpp/internal/eventpolicies_i.h    | 15 +++++++++
 tests/unittest/test_heterdispatcher_basic.cpp | 21 ++++++------
 4 files changed, 42 insertions(+), 40 deletions(-)

diff --git a/include/eventpp/callbacklist.h b/include/eventpp/callbacklist.h
index e88d84f..33e7931 100644
--- a/include/eventpp/callbacklist.h
+++ b/include/eventpp/callbacklist.h
@@ -28,20 +28,6 @@ namespace eventpp {
 
 namespace internal_ {
 
-template <typename F, typename ...A>
-struct CanInvoke
-{
-	template <typename U, typename ...X>
-	static auto invoke(int) -> decltype(std::declval<U>()(std::declval<X>()...), std::true_type());
-
-	template <typename U, typename ...X>
-	static auto invoke(...) -> std::false_type;
-
-	enum {
-		value = !! decltype(invoke<F, A...>(0))()
-	};
-};
-
 template <
 	typename Prototype,
 	typename PoliciesType
diff --git a/include/eventpp/hetereventdispatcher.h b/include/eventpp/hetereventdispatcher.h
index ac018ed..1728175 100644
--- a/include/eventpp/hetereventdispatcher.h
+++ b/include/eventpp/hetereventdispatcher.h
@@ -51,30 +51,30 @@ struct CanConvert <std::tuple<>, std::tuple<> >
 	enum { value = true };
 };
 
-template <int N, typename PrototypeList_, typename ...InArgs>
+template <int N, typename PrototypeList_, typename Callable>
 struct FindCallablePrototypeHelper
 {
 	using Prototype = void;
 	enum {index = -1 };
 };
 
-template <int N, typename RT, typename ...Args, typename ...Others, typename ...InArgs>
-struct FindCallablePrototypeHelper <N, std::tuple<RT (Args...), Others...>, InArgs...>
+template <int N, typename RT, typename ...Args, typename ...Others, typename Callable>
+struct FindCallablePrototypeHelper <N, std::tuple<RT (Args...), Others...>, Callable>
 {
 	using Prototype = typename std::conditional<
-		CanConvert<std::tuple<InArgs...>, std::tuple<Args...> >::value,
+		CanInvoke<Callable, Args...>::value,
 		RT (Args...),
-		typename FindCallablePrototypeHelper<N + 1, std::tuple<Others...>, InArgs...>::Prototype
+		typename FindCallablePrototypeHelper<N + 1, std::tuple<Others...>, Callable>::Prototype
 	>::type;
 	enum {
-		index = CanConvert<std::tuple<InArgs...>, std::tuple<Args...> >::value
+		index = CanInvoke<Callable, Args...>::value
 			? N
-			: FindCallablePrototypeHelper<N + 1, std::tuple<Others...>, InArgs...>::index
+			: FindCallablePrototypeHelper<N + 1, std::tuple<Others...>, Callable>::index
 	};
 };
 
-template <typename PrototypeList_, typename ...InArgs>
-struct FindCallablePrototype : public FindCallablePrototypeHelper <0, PrototypeList_, InArgs...>
+template <typename PrototypeList_, typename Callable>
+struct FindCallablePrototype : public FindCallablePrototypeHelper <0, PrototypeList_, Callable>
 {
 };
 
@@ -196,10 +196,10 @@ class HeterEventDispatcherBase
 		first.swap(second);
 	}
 
-	template <template <typename> class F, typename RT, typename ...Args>
-	Handle appendListener(const Event & event, const F<RT(Args...)> & callback)
+	template <typename C>
+	Handle appendListener(const Event & event, const C & callback)
 	{
-		using FindResult = FindCallablePrototype<PrototypeList_, Args...>;
+		using FindResult = FindCallablePrototype<PrototypeList_, C>;
 		auto dispatcher = doFindDispatcher<FindResult>();
 		return Handle {
 			FindResult::index,
@@ -207,10 +207,10 @@ class HeterEventDispatcherBase
 		};
 	}
 
-	template <template <typename> class F, typename RT, typename ...Args>
-	Handle prependListener(const Event & event, const F<RT(Args...)> & callback)
+	template <typename C>
+	Handle prependListener(const Event & event, const C & callback)
 	{
-		using FindResult = FindCallablePrototype<PrototypeList_, Args...>;
+		using FindResult = FindCallablePrototype<PrototypeList_, C>;
 		auto dispatcher = doFindDispatcher<FindResult>();
 		return Handle {
 			FindResult::index,
@@ -231,7 +231,7 @@ class HeterEventDispatcherBase
 	template <typename T, typename ...Args>
 	void dispatch(T && first, Args ...args) const
 	{
-		using FindResult = FindCallablePrototype<PrototypeList_, Args...>;
+		using FindResult = FindCallablePrototype<PrototypeList_, void(Args...)>;
 		auto dispatcher = doFindDispatcher<FindResult>();
 		dispatcher->dispatch(std::forward<T>(first), std::forward<Args>(args)...);
 	}
diff --git a/include/eventpp/internal/eventpolicies_i.h b/include/eventpp/internal/eventpolicies_i.h
index e8f0bba..9f5e6af 100644
--- a/include/eventpp/internal/eventpolicies_i.h
+++ b/include/eventpp/internal/eventpolicies_i.h
@@ -176,4 +176,19 @@ struct HasFunctionMixinBeforeDispatch
 	enum { value = !! decltype(test<T>(0))() };
 };
 
+template <typename F, typename ...A>
+struct CanInvoke
+{
+	template <typename U, typename ...X>
+	static auto invoke(int) -> decltype(std::declval<U>()(std::declval<X>()...), std::true_type());
+
+	template <typename U, typename ...X>
+	static auto invoke(...) -> std::false_type;
+
+	enum {
+		value = !! decltype(invoke<F, A...>(0))()
+	};
+};
+
+
 } //namespace internal_
diff --git a/tests/unittest/test_heterdispatcher_basic.cpp b/tests/unittest/test_heterdispatcher_basic.cpp
index bad0d7a..111109c 100644
--- a/tests/unittest/test_heterdispatcher_basic.cpp
+++ b/tests/unittest/test_heterdispatcher_basic.cpp
@@ -16,10 +16,10 @@
 
 struct xxx{};
 static_assert(eventpp::internal_::CanConvert<std::tuple<int, int>, std::tuple<int ,int> >::value, "");
-static_assert(eventpp::internal_::FindCallablePrototype<std::tuple<void (), void (int, int)> >::index == 0, "");
-static_assert(eventpp::internal_::FindCallablePrototype<std::tuple<void (int), void (int, int)>, char>::index == 0, "");
-static_assert(eventpp::internal_::FindCallablePrototype<std::tuple<void (int), void (int, int)>, char, int>::index == 1, "");
-static_assert(eventpp::internal_::FindCallablePrototype<std::tuple<void (int), void (int, int), void (int, const xxx &)>, int, xxx>::index == 2, "");
+static_assert(eventpp::internal_::FindCallablePrototype<std::tuple<void (), void (int, int)>, void() >::index == 0, "");
+static_assert(eventpp::internal_::FindCallablePrototype<std::tuple<void (int), void (int, int)>, void(char)>::index == 0, "");
+static_assert(eventpp::internal_::FindCallablePrototype<std::tuple<void (int), void (int, int)>, void(char, int)>::index == 1, "");
+static_assert(eventpp::internal_::FindCallablePrototype<std::tuple<void (int), void (int, int), void (int, const xxx &)>, void(int, xxx)>::index == 2, "");
 
 TEST_CASE("xxx HeterEventDispatcher, 1")
 {
@@ -27,15 +27,16 @@ TEST_CASE("xxx HeterEventDispatcher, 1")
 
 	std::array<int, 2> dataList{};
 
-	dispatcher.appendListener(3, std::function<void ()>([&dataList]() {
+	dispatcher.appendListener(3, [&dataList]() {
 		++dataList[0];
-	}));
-	dispatcher.appendListener(3, std::function<void (int, int, int)>([&dataList](int a, int b, int c) {
+	});
+	dispatcher.appendListener(3, [&dataList](int a, int b, int c) -> int {
 		dataList[1] += a + b + c;
-	}));
-	dispatcher.appendListener(8, std::function<void (int, int, int)>([&dataList](int a, int b, int c) {
+		return 0;
+	});
+	dispatcher.appendListener(8, [&dataList](int a, int b, int c) {
 		dataList[1] += a + b + c;
-	}));
+	});
 	
 	REQUIRE(dataList[0] == 0);
 	REQUIRE(dataList[1] == 0);

From 45a6bc05fa5f02d3518cfa780d6c090711beeecb Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Sun, 9 Dec 2018 22:45:19 +0800
Subject: [PATCH 07/38] Improved unit tests

---
 tests/unittest/test.h                         | 19 +++++++++++++++++++
 tests/unittest/test_dispatcher_basic.cpp      |  4 ++--
 tests/unittest/test_heterdispatcher_basic.cpp |  4 ++--
 3 files changed, 23 insertions(+), 4 deletions(-)

diff --git a/tests/unittest/test.h b/tests/unittest/test.h
index 6584f65..6153dca 100644
--- a/tests/unittest/test.h
+++ b/tests/unittest/test.h
@@ -51,5 +51,24 @@ bool checkAllWeakPtrAreFreed(const T & nodeList)
 	return true;
 }
 
+// Can be converted from int implicitly
+struct FromInt
+{
+	FromInt() : value(0) {}
+	FromInt(const int value) : value(value) {}
+
+	int value;
+};
+
+// Can convert to int implicitly
+struct ToInt
+{
+	ToInt() : value(0) {}
+	explicit ToInt(const int value) : value(value) {}
+
+	operator int() const { return value; }
+
+	int value;
+};
 
 #endif
diff --git a/tests/unittest/test_dispatcher_basic.cpp b/tests/unittest/test_dispatcher_basic.cpp
index 5a5ae81..3a13dc8 100644
--- a/tests/unittest/test_dispatcher_basic.cpp
+++ b/tests/unittest/test_dispatcher_basic.cpp
@@ -173,9 +173,9 @@ TEST_CASE("EventDispatcher, int, void (const std::string &, int)")
 	std::vector<std::string> sList(2);
 	std::vector<int> iList(sList.size());
 
-	dispatcher.appendListener(event, [event, &dispatcher, &sList, &iList](const std::string & s, int i) {
+	dispatcher.appendListener(event, [event, &dispatcher, &sList, &iList](const std::string & s, const FromInt & i) {
 		sList[0] = s;
-		iList[0] = i;
+		iList[0] = i.value;
 	});
 	dispatcher.appendListener(event, [event, &dispatcher, &sList, &iList](std::string s, const int i) {
 		sList[1] = s + "2";
diff --git a/tests/unittest/test_heterdispatcher_basic.cpp b/tests/unittest/test_heterdispatcher_basic.cpp
index 111109c..728264d 100644
--- a/tests/unittest/test_heterdispatcher_basic.cpp
+++ b/tests/unittest/test_heterdispatcher_basic.cpp
@@ -30,8 +30,8 @@ TEST_CASE("xxx HeterEventDispatcher, 1")
 	dispatcher.appendListener(3, [&dataList]() {
 		++dataList[0];
 	});
-	dispatcher.appendListener(3, [&dataList](int a, int b, int c) -> int {
-		dataList[1] += a + b + c;
+	dispatcher.appendListener(3, [&dataList](const FromInt & a, int b, int c) -> int {
+		dataList[1] += a.value + b + c;
 		return 0;
 	});
 	dispatcher.appendListener(8, [&dataList](int a, int b, int c) {

From 527742e22dbda74aee34ac6af36430f224ceb95d Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Wed, 12 Dec 2018 22:34:42 +0800
Subject: [PATCH 08/38] Removed unused headers

---
 include/eventpp/eventdispatcher.h             |  3 --
 include/eventpp/eventqueue.h                  | 31 +------------
 include/eventpp/hetereventdispatcher.h        |  3 --
 include/eventpp/internal/eventqueue_i.h       | 44 +++++++++++++++++++
 tests/unittest/test_dispatcher_basic.cpp      |  1 +
 .../unittest/test_dispatcher_multithread.cpp  |  1 +
 tests/unittest/test_queue_multithread.cpp     |  1 +
 7 files changed, 48 insertions(+), 36 deletions(-)
 create mode 100644 include/eventpp/internal/eventqueue_i.h

diff --git a/include/eventpp/eventdispatcher.h b/include/eventpp/eventdispatcher.h
index fe2b430..fd4cb36 100644
--- a/include/eventpp/eventdispatcher.h
+++ b/include/eventpp/eventdispatcher.h
@@ -19,10 +19,7 @@
 #include <string>
 #include <functional>
 #include <type_traits>
-#include <map>
-#include <unordered_map>
 #include <mutex>
-#include <algorithm>
 #include <memory>
 
 namespace eventpp {
diff --git a/include/eventpp/eventqueue.h b/include/eventpp/eventqueue.h
index 8c30a5c..fad59ad 100644
--- a/include/eventpp/eventqueue.h
+++ b/include/eventpp/eventqueue.h
@@ -15,6 +15,7 @@
 #define EVENTQUEUE_H_705786053037
 
 #include "eventdispatcher.h"
+#include "internal/eventqueue_i.h"
 
 #include <list>
 #include <tuple>
@@ -27,36 +28,6 @@ namespace eventpp {
 
 namespace internal_ {
 
-template <size_t ...Indexes>
-struct IndexSequence
-{
-};
-
-template <size_t N, size_t ...Indexes>
-struct MakeIndexSequence : MakeIndexSequence <N - 1, N - 1, Indexes...>
-{
-};
-
-template <std::size_t ...Indexes>
-struct MakeIndexSequence<0, Indexes...>
-{
-	using Type = IndexSequence<Indexes...>;
-};
-
-template <typename T>
-struct CounterGuard
-{
-	explicit CounterGuard(T & v) : value(v) {
-		++value;
-	}
-
-	~CounterGuard() {
-		--value;
-	}
-
-	T & value;
-};
-
 template <
 	typename EventType,
 	typename Prototype,
diff --git a/include/eventpp/hetereventdispatcher.h b/include/eventpp/hetereventdispatcher.h
index 1728175..056c047 100644
--- a/include/eventpp/hetereventdispatcher.h
+++ b/include/eventpp/hetereventdispatcher.h
@@ -20,10 +20,7 @@
 #include <string>
 #include <functional>
 #include <type_traits>
-#include <map>
-#include <unordered_map>
 #include <mutex>
-#include <algorithm>
 #include <memory>
 #include <tuple>
 
diff --git a/include/eventpp/internal/eventqueue_i.h b/include/eventpp/internal/eventqueue_i.h
new file mode 100644
index 0000000..2be0346
--- /dev/null
+++ b/include/eventpp/internal/eventqueue_i.h
@@ -0,0 +1,44 @@
+#ifndef EVENTQUEUE_I_H
+#define EVENTQUEUE_I_H
+
+namespace eventpp {
+
+namespace internal_ {
+
+template <size_t ...Indexes>
+struct IndexSequence
+{
+};
+
+template <size_t N, size_t ...Indexes>
+struct MakeIndexSequence : MakeIndexSequence <N - 1, N - 1, Indexes...>
+{
+};
+
+template <std::size_t ...Indexes>
+struct MakeIndexSequence<0, Indexes...>
+{
+	using Type = IndexSequence<Indexes...>;
+};
+
+template <typename T>
+struct CounterGuard
+{
+	explicit CounterGuard(T & v) : value(v) {
+		++value;
+	}
+
+	~CounterGuard() {
+		--value;
+	}
+
+	T & value;
+};
+
+} //namespace internal_
+
+} //namespace eventpp
+
+
+#endif
+
diff --git a/tests/unittest/test_dispatcher_basic.cpp b/tests/unittest/test_dispatcher_basic.cpp
index 3a13dc8..226176b 100644
--- a/tests/unittest/test_dispatcher_basic.cpp
+++ b/tests/unittest/test_dispatcher_basic.cpp
@@ -17,6 +17,7 @@
 
 #include <numeric>
 #include <random>
+#include <algorithm>
 
 TEST_CASE("EventDispatcher, std::string, void (const std::string &)")
 {
diff --git a/tests/unittest/test_dispatcher_multithread.cpp b/tests/unittest/test_dispatcher_multithread.cpp
index ca9c0a2..fc487c2 100644
--- a/tests/unittest/test_dispatcher_multithread.cpp
+++ b/tests/unittest/test_dispatcher_multithread.cpp
@@ -17,6 +17,7 @@
 #include <thread>
 #include <numeric>
 #include <random>
+#include <algorithm>
 
 TEST_CASE("EventDispatcher, multi threading, int, void (int)")
 {
diff --git a/tests/unittest/test_queue_multithread.cpp b/tests/unittest/test_queue_multithread.cpp
index 5868ffc..2fad3b3 100644
--- a/tests/unittest/test_queue_multithread.cpp
+++ b/tests/unittest/test_queue_multithread.cpp
@@ -17,6 +17,7 @@
 #include <thread>
 #include <numeric>
 #include <random>
+#include <algorithm>
 
 TEST_CASE("EventQueue, multi threading, int, void (int)")
 {

From 64f19c629541f86a468148d1d7e09878bc3bb5c6 Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Wed, 12 Dec 2018 22:54:16 +0800
Subject: [PATCH 09/38] Unified template parameter name

---
 include/eventpp/eventdispatcher.h | 48 +++++++++++++++----------------
 include/eventpp/eventqueue.h      | 34 +++++++++++-----------
 2 files changed, 41 insertions(+), 41 deletions(-)

diff --git a/include/eventpp/eventdispatcher.h b/include/eventpp/eventdispatcher.h
index fd4cb36..dee70ac 100644
--- a/include/eventpp/eventdispatcher.h
+++ b/include/eventpp/eventdispatcher.h
@@ -27,31 +27,31 @@ namespace eventpp {
 namespace internal_ {
 
 template <
-	typename EventType,
-	typename Prototype,
-	typename Policies,
+	typename EventType_,
+	typename Prototype_,
+	typename Policies_,
 	typename MixinRoot_
 >
 class EventDispatcherBase;
 
 template <
-	typename EventType,
-	typename PoliciesType,
+	typename EventType_,
+	typename Policies_,
 	typename MixinRoot_,
 	typename ReturnType, typename ...Args
 >
 class EventDispatcherBase <
-	EventType,
+	EventType_,
 	ReturnType (Args...),
-	PoliciesType,
+	Policies_,
 	MixinRoot_
 >
 {
 protected:
 	using ThisType = EventDispatcherBase<
-		EventType,
+		EventType_,
 		ReturnType (Args...),
-		PoliciesType,
+		Policies_,
 		MixinRoot_
 	>;
 	using MixinRoot = typename std::conditional<
@@ -59,40 +59,40 @@ class EventDispatcherBase <
 		ThisType,
 		MixinRoot_
 	>::type;
-	using Policies = PoliciesType;
+	using Policies = Policies_;
 
-	using Threading = typename SelectThreading<Policies, HasTypeThreading<Policies>::value>::Type;
+	using Threading = typename SelectThreading<Policies_, HasTypeThreading<Policies_>::value>::Type;
 
 	using ArgumentPassingMode = typename SelectArgumentPassingMode<
-		Policies,
-		HasTypeArgumentPassingMode<Policies>::value
+		Policies_,
+		HasTypeArgumentPassingMode<Policies_>::value
 	>::Type;
 
 	using Callback_ = typename SelectCallback<
-		Policies,
-		HasTypeCallback<Policies>::value,
+		Policies_,
+		HasTypeCallback<Policies_>::value,
 		std::function<ReturnType (Args...)>
 	>::Type;
-	using CallbackList_ = CallbackList<ReturnType (Args...), Policies>;
+	using CallbackList_ = CallbackList<ReturnType (Args...), Policies_>;
 
 	using Prototype = ReturnType (Args...);
 
 	using Map = typename SelectMap<
-		EventType,
+		EventType_,
 		CallbackList_,
-		Policies,
-		HasTemplateMap<Policies>::value
+		Policies_,
+		HasTemplateMap<Policies_>::value
 	>::Type;
 
 	using Mixins = typename internal_::SelectMixins<
-		Policies,
-		internal_::HasTypeMixins<Policies>::value
+		Policies_,
+		internal_::HasTypeMixins<Policies_>::value
 	>::Type;
 
 public:
 	using Handle = typename CallbackList_::Handle;
 	using Callback = Callback_;
-	using Event = EventType;
+	using Event = EventType_;
 	using Mutex = typename Threading::Mutex;
 
 public:
@@ -192,7 +192,7 @@ class EventDispatcherBase <
 	{
 		static_assert(ArgumentPassingMode::canIncludeEventType, "Dispatching arguments count doesn't match required (Event type should be included).");
 
-		using GetEvent = typename SelectGetEvent<Policies, EventType, HasFunctionGetEvent<Policies, Args...>::value>::Type;
+		using GetEvent = typename SelectGetEvent<Policies_, EventType_, HasFunctionGetEvent<Policies_, Args...>::value>::Type;
 
 		// can't std::forward<Args>(args) in GetEvent::getEvent because the pass by value arguments will be moved to getEvent
 		// then the other std::forward<Args>(args) to doDispatch will get empty values.
@@ -207,7 +207,7 @@ class EventDispatcherBase <
 	{
 		static_assert(ArgumentPassingMode::canExcludeEventType, "Dispatching arguments count doesn't match required (Event type should NOT be included).");
 
-		using GetEvent = typename SelectGetEvent<Policies, EventType, HasFunctionGetEvent<Policies, T &&, Args...>::value>::Type;
+		using GetEvent = typename SelectGetEvent<Policies_, EventType_, HasFunctionGetEvent<Policies_, T &&, Args...>::value>::Type;
 
 		doDispatch(
 			GetEvent::getEvent(std::forward<T>(first), args...),
diff --git a/include/eventpp/eventqueue.h b/include/eventpp/eventqueue.h
index fad59ad..f501449 100644
--- a/include/eventpp/eventqueue.h
+++ b/include/eventpp/eventqueue.h
@@ -29,41 +29,41 @@ namespace eventpp {
 namespace internal_ {
 
 template <
-	typename EventType,
-	typename Prototype,
-	typename Policies
+	typename EventType_,
+	typename Prototype_,
+	typename Policies_
 >
 class EventQueueBase;
 
 template <
-	typename EventType,
-	typename PoliciesType,
+	typename EventType_,
+	typename Policies_,
 	typename ReturnType, typename ...Args
 >
 class EventQueueBase <
-		EventType,
+		EventType_,
 		ReturnType (Args...),
-		PoliciesType
+		Policies_
 	> : public EventDispatcherBase<
-		EventType,
+		EventType_,
 		ReturnType (Args...),
-		PoliciesType,
+		Policies_,
 		EventQueueBase <
-			EventType,
+			EventType_,
 			ReturnType (Args...),
-			PoliciesType
+			Policies_
 		>
 	>
 {
 private:
 	using super = EventDispatcherBase<
-		EventType,
+		EventType_,
 		ReturnType (Args...),
-		PoliciesType,
+		Policies_,
 		EventQueueBase <
-			EventType,
+			EventType_,
 			ReturnType (Args...),
-			PoliciesType
+			Policies_
 		>
 	>;
 
@@ -187,7 +187,7 @@ class EventQueueBase <
 	{
 		static_assert(super::ArgumentPassingMode::canIncludeEventType, "Enqueuing arguments count doesn't match required (Event type should be included).");
 
-		using GetEvent = typename SelectGetEvent<Policies, EventType, HasFunctionGetEvent<Policies, Args...>::value>::Type;
+		using GetEvent = typename SelectGetEvent<Policies_, EventType_, HasFunctionGetEvent<Policies_, Args...>::value>::Type;
 
 		doEnqueue(QueuedEvent(
 			GetEvent::getEvent(args...),
@@ -204,7 +204,7 @@ class EventQueueBase <
 	{
 		static_assert(super::ArgumentPassingMode::canExcludeEventType, "Enqueuing arguments count doesn't match required (Event type should NOT be included).");
 
-		using GetEvent = typename SelectGetEvent<Policies, EventType, HasFunctionGetEvent<Policies, T &&, Args...>::value>::Type;
+		using GetEvent = typename SelectGetEvent<Policies_, EventType_, HasFunctionGetEvent<Policies_, T &&, Args...>::value>::Type;
 
 		doEnqueue(QueuedEvent(
 			GetEvent::getEvent(std::forward<T>(first), args...),

From 4469699d340a92d7461ea17d76e8817a081901b6 Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Thu, 13 Dec 2018 19:32:06 +0800
Subject: [PATCH 10/38] Rewrote EventQueue::QueuedEvent with meaningful struct

---
 doc/eventqueue.md                   | 35 +++++++++++++++----------
 include/eventpp/eventqueue.h        | 35 +++++++++++++------------
 tests/unittest/test_queue_basic.cpp | 40 ++++++++++++++---------------
 3 files changed, 59 insertions(+), 51 deletions(-)

diff --git a/doc/eventqueue.md b/doc/eventqueue.md
index 3824b64..c7c7204 100644
--- a/doc/eventqueue.md
+++ b/doc/eventqueue.md
@@ -5,13 +5,11 @@
 - [API reference](#apis)
 - [Internal data structure](#internal-data-structure)
 
-EventQueue includes all functions of [EventDispatcher](eventdispatcher.md) and adds event queue features. Note: EventQueue doesn't inherit from EventDispatcher, don't try to cast EventQueue to EventDispatcher.  
-
 ## Description
 
 EventQueue includes all features of EventDispatcher and adds event queue features. Note: EventQueue doesn't inherit from EventDispatcher, don't try to cast EventQueue to EventDispatcher.  
-EventQueue is asynchronous. Event are cached in the queue when `EventQueue::enqueue` is called, and dispatched later when `EventQueue::process` is called.  
-EventQueue is equivalent to the event system (QEvent) in Qt, or the message processing in Windows.  
+EventQueue is asynchronous. Events are cached in the queue when `EventQueue::enqueue` is called, and dispatched later when `EventQueue::process` is called.  
+EventQueue is equivalent to the event system (QEvent) in Qt, or the message processing in Windows API.  
 
 <a name="apis"></a>
 ## API reference
@@ -24,7 +22,7 @@ eventpp/eventqueue.h
 
 ```c++
 template <
-	typename Key,
+	typename Event,
 	typename Prototype,
 	typename Policies = DefaultPolicies
 >
@@ -35,14 +33,15 @@ EventQueue has the exactly same template parameters with EventDispatcher. Please
 
 ### Public types
 
-`QueuedEvent`: the data type of event stored in the queue. It's declaration is,  
+`QueuedEvent`: the data type of event stored in the queue. It's declaration in pseudo code is,  
 ```c++
-using QueuedEvent = std::tuple<
-	typename std::remove_cv<typename std::remove_reference<Event>::type>::type,
-	typename std::remove_cv<typename std::remove_reference<Args>::type>::type...
->;
+struct EventQueue::QueuedEvent
+{
+	TheEventType event;
+	std::tuple<ArgumentTypes...> arguments;
+};
 ```
-It's a `std::tuple`, the first member is always the event type, the other members are the arguments.
+`event` is the EventQueue::Event, `arguments` are the arguments passed in `enqueue`.  
 
 ### Member functions
 
@@ -153,7 +152,14 @@ for(;;) {
 bool peekEvent(EventQueue::QueuedEvent * queuedEvent);
 ```
 Retrieve an event from the queue. The event is returned in `queuedEvent`.  
-`queuedEvent` is a std::tuple, which the first element is the EventQueue::Event, and the other elements are the arguments passed in `enqueue`.  
+```c++
+struct EventQueue::QueuedEvent
+{
+	TheEventType event;
+	std::tuple<ArgumentTypes...> arguments;
+};
+```
+`queuedEvent` is a EventQueue::QueuedEvent struct. `event` is the EventQueue::Event, `arguments` are the arguments passed in `enqueue`.  
 If the queue is empty, the function returns false, otherwise true if an event is retrieved successfully.  
 After the function returns, the original even is still in the queue.  
 Note: `peekEvent` doesn't work with any non-copyable event arguments. If `peekEvent` is called when any arguments are non-copyable, compile fails.
@@ -174,10 +180,11 @@ Dispatch an event which was returned by `peekEvent` or `takeEvent`.
 **Inner class EventQueue::DisableQueueNotify**  
 
 `EventQueue::DisableQueueNotify` is a RAII class that temporarily prevents the event queue from waking up any waiting threads. When any `DisableQueueNotify` object exist, calling `enqueue` doesn't wake up any threads that are blocked by `wait`. When the `DisableQueueNotify` object is out of scope, the waking up is resumed. If there are more than one `DisableQueueNotify` objects, the waking up is only resumed after all `DisableQueueNotify` objects are destroyed.  
+`DisableQueueNotify` is useful to improve performance when batching adding events to the queue. For example, in a main loop of a game engine, `DisableQueueNotify` can be created on the start in a frame, then the game adding events to the queue, and the `DisableQueueNotify` is destroyed at the end of a frame and the events are processed.
 
 To use `DisableQueueNotify`, construct it with a pointer to event queue.
 
-Sampe code
+Sample code
 ```c++
 using EQ = eventpp::EventQueue<int, void ()>;
 EQ queue;
@@ -197,7 +204,7 @@ queue.enqueue(3);
 ## Internal data structure
 
 EventQueue uses three `std::list` to manage the event queue.  
-The first busy list holds all nodes with queued events.  
+The first busy list holds all nodes of queued events.  
 The second idle list holds all idle nodes. After an event is dispatched and removed from the queue, instead of freeing the memory, EventQueue moves the unused node to the idle list. This can improve performance and avoid memory fragment.  
 The third list is a local temporary list used in function `process()`. During processing, the busy list is swapped to the temporary list, all events are dispatched from the temporary list, then the temporary list is returned and appended to the idle list.
 
diff --git a/include/eventpp/eventqueue.h b/include/eventpp/eventqueue.h
index f501449..5f9cdb3 100644
--- a/include/eventpp/eventqueue.h
+++ b/include/eventpp/eventqueue.h
@@ -71,10 +71,11 @@ class EventQueueBase <
 	using Threading = typename super::Threading;
 	using ConditionVariable = typename Threading::ConditionVariable;
 
-	using QueuedEvent_ = std::tuple<
-		typename std::remove_cv<typename std::remove_reference<typename super::Event>::type>::type,
-		typename std::remove_cv<typename std::remove_reference<Args>::type>::type...
-	>;
+	struct QueuedEvent_
+	{
+		typename std::remove_cv<typename std::remove_reference<typename super::Event>::type>::type event;
+		std::tuple<typename std::remove_cv<typename std::remove_reference<Args>::type>::type...> arguments;
+	};
 
 	class QueuedItem
 	{
@@ -189,10 +190,10 @@ class EventQueueBase <
 
 		using GetEvent = typename SelectGetEvent<Policies_, EventType_, HasFunctionGetEvent<Policies_, Args...>::value>::Type;
 
-		doEnqueue(QueuedEvent(
+		doEnqueue(QueuedEvent{
 			GetEvent::getEvent(args...),
-			std::forward<A>(args)...
-		));
+			std::make_tuple(std::forward<A>(args)...)
+		});
 
 		if(doCanProcess()) {
 			queueListConditionVariable.notify_one();
@@ -206,10 +207,10 @@ class EventQueueBase <
 
 		using GetEvent = typename SelectGetEvent<Policies_, EventType_, HasFunctionGetEvent<Policies_, T &&, Args...>::value>::Type;
 
-		doEnqueue(QueuedEvent(
+		doEnqueue(QueuedEvent{
 			GetEvent::getEvent(std::forward<T>(first), args...),
-			std::forward<A>(args)...
-		));
+			std::make_tuple(std::forward<A>(args)...)
+		});
 
 		if(doCanProcess()) {
 			queueListConditionVariable.notify_one();
@@ -260,7 +261,7 @@ class EventQueueBase <
 				for(auto & item : tempList) {
 					doDispatchQueuedEvent(
 						item.get(),
-						typename internal_::MakeIndexSequence<sizeof...(Args) + 1>::Type()
+						typename internal_::MakeIndexSequence<sizeof...(Args)>::Type()
 					);
 					item.clear();
 				}
@@ -295,7 +296,7 @@ class EventQueueBase <
 				auto & item = tempList.front();
 				doDispatchQueuedEvent(
 					item.get(),
-					typename internal_::MakeIndexSequence<sizeof...(Args) + 1>::Type()
+					typename internal_::MakeIndexSequence<sizeof...(Args)>::Type()
 				);
 				item.clear();
 
@@ -330,11 +331,11 @@ class EventQueueBase <
 					if(doInvokeFuncWithQueuedEvent(
 							func,
 							it->get(),
-							typename internal_::MakeIndexSequence<sizeof...(Args) + 1>::Type())
+							typename internal_::MakeIndexSequence<sizeof...(Args)>::Type())
 						) {
 						doDispatchQueuedEvent(
 							it->get(),
-							typename internal_::MakeIndexSequence<sizeof...(Args) + 1>::Type()
+							typename internal_::MakeIndexSequence<sizeof...(Args)>::Type()
 						);
 						it->clear();
 						
@@ -386,7 +387,7 @@ class EventQueueBase <
 	{
 		doDispatchQueuedEvent(
 			queuedEvent,
-			typename internal_::MakeIndexSequence<sizeof...(Args) + 1>::Type()
+			typename internal_::MakeIndexSequence<sizeof...(Args)>::Type()
 		);
 	}
 
@@ -443,13 +444,13 @@ class EventQueueBase <
 	template <typename T, size_t ...Indexes>
 	void doDispatchQueuedEvent(T && item, IndexSequence<Indexes...>)
 	{
-		this->doDispatch(std::get<Indexes>(std::forward<T>(item))...);
+		this->doDispatch(item.event, std::get<Indexes>(item.arguments)...);
 	}
 
 	template <typename F, typename T, size_t ...Indexes>
 	bool doInvokeFuncWithQueuedEvent(F && func, T && item, IndexSequence<Indexes...>) const
 	{
-		return doInvokeFuncWithQueuedEventHelper(std::forward<F>(func), std::get<Indexes>(std::forward<T>(item))...);
+		return doInvokeFuncWithQueuedEventHelper(std::forward<F>(func), item.event, std::get<Indexes>(item.arguments)...);
 	}
 	
 	template <typename F>
diff --git a/tests/unittest/test_queue_basic.cpp b/tests/unittest/test_queue_basic.cpp
index 28b32a4..905227a 100644
--- a/tests/unittest/test_queue_basic.cpp
+++ b/tests/unittest/test_queue_basic.cpp
@@ -344,56 +344,56 @@ TEST_CASE("EventQueue, peekEvent/takeEvent/dispatch")
 	SECTION("peek") {
 		EQ::QueuedEvent event;
 		REQUIRE(queue->peekEvent(&event));
-		REQUIRE(std::get<0>(event) == 3);
-		REQUIRE(*std::get<1>(event) == 0);
+		REQUIRE(event.event == 3);
+		REQUIRE(*std::get<0>(event.arguments) == 0);
 		REQUIRE(wpList[0].use_count() == 2);
 	}
 
 	SECTION("peek/peek") {
 		EQ::QueuedEvent event;
 		REQUIRE(queue->peekEvent(&event));
-		REQUIRE(std::get<0>(event) == 3);
-		REQUIRE(*std::get<1>(event) == 0);
+		REQUIRE(event.event == 3);
+		REQUIRE(*std::get<0>(event.arguments) == 0);
 		REQUIRE(wpList[0].use_count() == 2);
 
 		EQ::QueuedEvent event2;
 		REQUIRE(queue->peekEvent(&event2));
-		REQUIRE(std::get<0>(event2) == 3);
-		REQUIRE(*std::get<1>(event2) == 0);
+		REQUIRE(event2.event == 3);
+		REQUIRE(*std::get<0>(event2.arguments) == 0);
 		REQUIRE(wpList[0].use_count() == 3);
 	}
 
 	SECTION("peek/take") {
 		EQ::QueuedEvent event;
 		REQUIRE(queue->peekEvent(&event));
-		REQUIRE(std::get<0>(event) == 3);
-		REQUIRE(*std::get<1>(event) == 0);
+		REQUIRE(event.event == 3);
+		REQUIRE(*std::get<0>(event.arguments) == 0);
 		REQUIRE(wpList[0].use_count() == 2);
 
 		EQ::QueuedEvent event2;
 		REQUIRE(queue->takeEvent(&event2));
-		REQUIRE(std::get<0>(event2) == 3);
-		REQUIRE(*std::get<1>(event2) == 0);
+		REQUIRE(event2.event == 3);
+		REQUIRE(*std::get<0>(event2.arguments) == 0);
 		REQUIRE(wpList[0].use_count() == 2);
 	}
 
 	SECTION("peek/take/peek") {
 		EQ::QueuedEvent event;
 		REQUIRE(queue->peekEvent(&event));
-		REQUIRE(std::get<0>(event) == 3);
-		REQUIRE(*std::get<1>(event) == 0);
+		REQUIRE(event.event == 3);
+		REQUIRE(*std::get<0>(event.arguments) == 0);
 		REQUIRE(wpList[0].use_count() == 2);
 
 		EQ::QueuedEvent event2;
 		REQUIRE(queue->takeEvent(&event2));
-		REQUIRE(std::get<0>(event2) == 3);
-		REQUIRE(*std::get<1>(event2) == 0);
+		REQUIRE(event2.event == 3);
+		REQUIRE(*std::get<0>(event2.arguments) == 0);
 		REQUIRE(wpList[0].use_count() == 2);
 
 		EQ::QueuedEvent event3;
 		REQUIRE(queue->peekEvent(&event3));
-		REQUIRE(std::get<0>(event3) == 3);
-		REQUIRE(*std::get<1>(event3) == 1);
+		REQUIRE(event3.event == 3);
+		REQUIRE(*std::get<0>(event3.arguments) == 1);
 		REQUIRE(wpList[0].use_count() == 2);
 		REQUIRE(wpList[1].use_count() == 2);
 	}
@@ -401,16 +401,16 @@ TEST_CASE("EventQueue, peekEvent/takeEvent/dispatch")
 	SECTION("peek/dispatch/peek/dispatch again") {
 		EQ::QueuedEvent event;
 		REQUIRE(queue->peekEvent(&event));
-		REQUIRE(std::get<0>(event) == 3);
-		REQUIRE(*std::get<1>(event) == 0);
+		REQUIRE(event.event == 3);
+		REQUIRE(*std::get<0>(event.arguments) == 0);
 		REQUIRE(wpList[0].use_count() == 2);
 
 		queue->dispatch(event);
 
 		EQ::QueuedEvent event2;
 		REQUIRE(queue->peekEvent(&event2));
-		REQUIRE(std::get<0>(event2) == 3);
-		REQUIRE(*std::get<1>(event2) == 0);
+		REQUIRE(event2.event == 3);
+		REQUIRE(*std::get<0>(event2.arguments) == 0);
 		REQUIRE(wpList[0].use_count() == 3);
 
 		REQUIRE(dataList == std::vector<int>{ 1, 0, 0 });

From 91e0b0f46d148df1e54f752feff980fe6e6829e0 Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Sat, 15 Dec 2018 10:32:43 +0800
Subject: [PATCH 11/38] Upgraded Catch2 to v2.5.0

---
 tests/catch.hpp | 22426 +++++++++++++++++++++++++---------------------
 1 file changed, 12388 insertions(+), 10038 deletions(-)

diff --git a/tests/catch.hpp b/tests/catch.hpp
index 362f869..dd9237b 100644
--- a/tests/catch.hpp
+++ b/tests/catch.hpp
@@ -1,18 +1,22 @@
 /*
- *  Catch v2.0.1
- *  Generated: 2017-11-03 11:53:39.642003
- *  ----------------------------------------------------------
- *  This file has been merged from multiple headers. Please don't edit it directly
- *  Copyright (c) 2017 Two Blue Cubes Ltd. All rights reserved.
- *
- *  Distributed under 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)
- */
+*  Catch v2.5.0
+*  Generated: 2018-11-26 20:46:12.165372
+*  ----------------------------------------------------------
+*  This file has been merged from multiple headers. Please don't edit it directly
+*  Copyright (c) 2018 Two Blue Cubes Ltd. All rights reserved.
+*
+*  Distributed under 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)
+*/
 #ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
 #define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
 // start catch.hpp
 
 
+#define CATCH_VERSION_MAJOR 2
+#define CATCH_VERSION_MINOR 5
+#define CATCH_VERSION_PATCH 0
+
 #ifdef __clang__
 #    pragma clang system_header
 #elif defined __GNUC__
@@ -26,37 +30,44 @@
 #       pragma warning(push)
 #       pragma warning(disable: 161 1682)
 #   else // __ICC
-#       pragma clang diagnostic ignored "-Wglobal-constructors"
-#       pragma clang diagnostic ignored "-Wvariadic-macros"
-#       pragma clang diagnostic ignored "-Wc99-extensions"
-#       pragma clang diagnostic ignored "-Wunused-variable"
 #       pragma clang diagnostic push
 #       pragma clang diagnostic ignored "-Wpadded"
 #       pragma clang diagnostic ignored "-Wswitch-enum"
 #       pragma clang diagnostic ignored "-Wcovered-switch-default"
 #    endif
 #elif defined __GNUC__
-#    pragma GCC diagnostic ignored "-Wvariadic-macros"
-#    pragma GCC diagnostic ignored "-Wunused-variable"
+// GCC likes to warn on REQUIREs, and we cannot suppress them
+// locally because g++'s support for _Pragma is lacking in older,
+// still supported, versions
 #    pragma GCC diagnostic ignored "-Wparentheses"
-
 #    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wunused-variable"
 #    pragma GCC diagnostic ignored "-Wpadded"
 #endif
 // end catch_suppress_warnings.h
 #if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)
 #  define CATCH_IMPL
+#  define CATCH_CONFIG_ALL_PARTS
+#endif
+
+// In the impl file, we want to have access to all parts of the headers
+// Can also be used to sanely support PCHs
+#if defined(CATCH_CONFIG_ALL_PARTS)
 #  define CATCH_CONFIG_EXTERNAL_INTERFACES
 #  if defined(CATCH_CONFIG_DISABLE_MATCHERS)
 #    undef CATCH_CONFIG_DISABLE_MATCHERS
 #  endif
+#  if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
+#    define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
+#  endif
 #endif
 
+#if !defined(CATCH_CONFIG_IMPL_ONLY)
 // start catch_platform.h
 
 #ifdef __APPLE__
 # include <TargetConditionals.h>
-# if TARGET_OS_MAC == 1
+# if TARGET_OS_OSX == 1
 #  define CATCH_PLATFORM_MAC
 # elif TARGET_OS_IPHONE == 1
 #  define CATCH_PLATFORM_IPHONE
@@ -65,11 +76,12 @@
 #elif defined(linux) || defined(__linux) || defined(__linux__)
 #  define CATCH_PLATFORM_LINUX
 
-#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER)
+#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__)
 #  define CATCH_PLATFORM_WINDOWS
 #endif
 
 // end catch_platform.h
+
 #ifdef CATCH_IMPL
 #  ifndef CLARA_CONFIG_MAIN
 #    define CLARA_CONFIG_MAIN_NOT_DEFINED
@@ -77,6 +89,13 @@
 #  endif
 #endif
 
+// start catch_user_interfaces.h
+
+namespace Catch {
+	unsigned int rngSeed();
+}
+
+// end catch_user_interfaces.h
 // start catch_tag_alias_autoregistrar.h
 
 // start catch_common.h
@@ -89,6 +108,7 @@
 // CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported?
 // CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported?
 // CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported?
+// CATCH_CONFIG_DISABLE_EXCEPTIONS : Are exceptions enabled?
 // ****************
 // Note to maintainers: if new toggles are added please document them
 // in configuration.md, too
@@ -101,10 +121,18 @@
 
 #ifdef __cplusplus
 
-#  if __cplusplus >= 201402L
+#  if (__cplusplus >= 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L)
 #    define CATCH_CPP14_OR_GREATER
 #  endif
 
+#  if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+#    define CATCH_CPP17_OR_GREATER
+#  endif
+
+#endif
+
+#if defined(CATCH_CPP17_OR_GREATER)
+#  define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
 #endif
 
 #ifdef __clang__
@@ -122,16 +150,24 @@
 #       define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
             _Pragma( "clang diagnostic pop" )
 
+#       define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
+            _Pragma( "clang diagnostic push" ) \
+            _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
+#       define CATCH_INTERNAL_UNSUPPRESS_UNUSED_WARNINGS \
+            _Pragma( "clang diagnostic pop" )
+
 #endif // __clang__
 
 ////////////////////////////////////////////////////////////////////////////////
-// We know some environments not to support full POSIX signals
-#if defined(__CYGWIN__) || defined(__QNX__)
-
-#   if !defined(CATCH_CONFIG_POSIX_SIGNALS)
-#       define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
-#   endif
+// Assume that non-Windows platforms support posix signals by default
+#if !defined(CATCH_PLATFORM_WINDOWS)
+#define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS
+#endif
 
+////////////////////////////////////////////////////////////////////////////////
+// We know some environments not to support full POSIX signals
+#if defined(__CYGWIN__) || defined(__QNX__) || defined(__EMSCRIPTEN__) || defined(__DJGPP__)
+#define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
 #endif
 
 #ifdef __OS400__
@@ -139,6 +175,24 @@
 #       define CATCH_CONFIG_COLOUR_NONE
 #endif
 
+////////////////////////////////////////////////////////////////////////////////
+// Android somehow still does not support std::to_string
+#if defined(__ANDROID__)
+#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Not all Windows environments support SEH properly
+#if defined(__MINGW32__)
+#    define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// PS4
+#if defined(__ORBIS__)
+#    define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE
+#endif
+
 ////////////////////////////////////////////////////////////////////////////////
 // Cygwin
 #ifdef __CYGWIN__
@@ -146,13 +200,24 @@
 // Required for some versions of Cygwin to declare gettimeofday
 // see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin
 #   define _BSD_SOURCE
+// some versions of cygwin (most) do not support std::to_string. Use the libstd check.
+// https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813
+# if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \
+	       && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))
+
+#	define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
 
+# endif
 #endif // __CYGWIN__
 
 ////////////////////////////////////////////////////////////////////////////////
 // Visual C++
 #ifdef _MSC_VER
 
+#  if _MSC_VER >= 1900 // Visual Studio 2015 or newer
+#    define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+#  endif
+
 // Universal Windows platform does not support SEH
 // Or console colours (or console at all...)
 #  if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
@@ -161,8 +226,33 @@
 #    define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
 #  endif
 
+// MSVC traditional preprocessor needs some workaround for __VA_ARGS__
+// _MSVC_TRADITIONAL == 0 means new conformant preprocessor
+// _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor
+#  if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL)
+#    define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#  endif
+
 #endif // _MSC_VER
 
+////////////////////////////////////////////////////////////////////////////////
+// Check if we are compiled with -fno-exceptions or equivalent
+#if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND)
+#  define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// DJGPP
+#ifdef __DJGPP__
+#  define CATCH_INTERNAL_CONFIG_NO_WCHAR
+#endif // __DJGPP__
+
+////////////////////////////////////////////////////////////////////////////////
+// Embarcadero C++Build
+#if defined(__BORLANDC__)
+#define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN
+#endif
+
 ////////////////////////////////////////////////////////////////////////////////
 
 // Use of __COUNTER__ is suppressed during code analysis in
@@ -171,19 +261,81 @@
 // Otherwise all supported compilers support COUNTER macro,
 // but user still might want to turn it off
 #if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L )
-    #define CATCH_INTERNAL_CONFIG_COUNTER
+#define CATCH_INTERNAL_CONFIG_COUNTER
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Check if string_view is available and usable
+// The check is split apart to work around v140 (VS2015) preprocessor issue...
+#if defined(__has_include)
+#if __has_include(<string_view>) && defined(CATCH_CPP17_OR_GREATER)
+#    define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW
 #endif
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Check if variant is available and usable
+#if defined(__has_include)
+#  if __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
+#    if defined(__clang__) && (__clang_major__ < 8)
+// work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852
+// fix should be in clang 8, workaround in libstdc++ 8.2
+#      include <ciso646>
+#      if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
+#        define CATCH_CONFIG_NO_CPP17_VARIANT
+#     else
+#        define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
+#      endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
+#    endif // defined(__clang__) && (__clang_major__ < 8)
+#  endif // __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
+#endif // __has_include
 
 #if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER)
 #   define CATCH_CONFIG_COUNTER
 #endif
-#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH)
+#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH)
 #   define CATCH_CONFIG_WINDOWS_SEH
 #endif
 // This is set by default, because we assume that unix compilers are posix-signal-compatible by default.
-#if !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS)
+#if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) && !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS)
 #   define CATCH_CONFIG_POSIX_SIGNALS
 #endif
+// This is set by default, because we assume that compilers with no wchar_t support are just rare exceptions.
+#if !defined(CATCH_INTERNAL_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_WCHAR)
+#   define CATCH_CONFIG_WCHAR
+#endif
+
+#if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING)
+#    define CATCH_CONFIG_CPP11_TO_STRING
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
+#  define CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW)
+#  define CATCH_CONFIG_CPP17_STRING_VIEW
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT)
+#  define CATCH_CONFIG_CPP17_VARIANT
+#endif
+
+#if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
+#  define CATCH_INTERNAL_CONFIG_NEW_CAPTURE
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CAPTURE)
+#  define CATCH_CONFIG_NEW_CAPTURE
+#endif
+
+#if !defined(CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+#  define CATCH_CONFIG_DISABLE_EXCEPTIONS
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN)
+#  define CATCH_CONFIG_POLYFILL_ISNAN
+#endif
 
 #if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
 #   define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
@@ -193,6 +345,24 @@
 #   define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
 #   define CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
 #endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS
+#   define CATCH_INTERNAL_UNSUPPRESS_UNUSED_WARNINGS
+#endif
+
+#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+#define CATCH_TRY if ((true))
+#define CATCH_CATCH_ALL if ((false))
+#define CATCH_CATCH_ANON(type) if ((false))
+#else
+#define CATCH_TRY try
+#define CATCH_CATCH_ALL catch (...)
+#define CATCH_CATCH_ANON(type) catch (type)
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR)
+#define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#endif
 
 // end catch_compiler_capabilities.h
 #define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line
@@ -207,60 +377,67 @@
 #include <string>
 #include <cstdint>
 
-namespace Catch {
-
-    struct CaseSensitive { enum Choice {
-        Yes,
-        No
-    }; };
-
-    class NonCopyable {
-        NonCopyable( NonCopyable const& )              = delete;
-        NonCopyable( NonCopyable && )                  = delete;
-        NonCopyable& operator = ( NonCopyable const& ) = delete;
-        NonCopyable& operator = ( NonCopyable && )     = delete;
-
-    protected:
-        NonCopyable();
-        virtual ~NonCopyable();
-    };
-
-    struct SourceLineInfo {
-
-        SourceLineInfo() = delete;
-        SourceLineInfo( char const* _file, std::size_t _line ) noexcept;
-
-        SourceLineInfo( SourceLineInfo const& other )        = default;
-        SourceLineInfo( SourceLineInfo && )                  = default;
-        SourceLineInfo& operator = ( SourceLineInfo const& ) = default;
-        SourceLineInfo& operator = ( SourceLineInfo && )     = default;
-
-        bool empty() const noexcept;
-        bool operator == ( SourceLineInfo const& other ) const noexcept;
-        bool operator < ( SourceLineInfo const& other ) const noexcept;
-
-        char const* file;
-        std::size_t line;
-    };
-
-    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info );
+// We need a dummy global operator<< so we can bring it into Catch namespace later
+struct Catch_global_namespace_dummy {};
+std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy);
 
-    // This is just here to avoid compiler warnings with macro constants and boolean literals
-    bool isTrue( bool value );
-    bool alwaysTrue();
-    bool alwaysFalse();
+namespace Catch {
 
-    // Use this in variadic streaming macros to allow
-    //    >> +StreamEndStop
-    // as well as
-    //    >> stuff +StreamEndStop
-    struct StreamEndStop {
-        std::string operator+() const;
-    };
-    template<typename T>
-    T const& operator + ( T const& value, StreamEndStop ) {
-        return value;
-    }
+	struct CaseSensitive { enum Choice {
+		Yes,
+		No
+	}; };
+
+	class NonCopyable {
+		NonCopyable( NonCopyable const& )              = delete;
+		NonCopyable( NonCopyable && )                  = delete;
+		NonCopyable& operator = ( NonCopyable const& ) = delete;
+		NonCopyable& operator = ( NonCopyable && )     = delete;
+
+	protected:
+		NonCopyable();
+		virtual ~NonCopyable();
+	};
+
+	struct SourceLineInfo {
+
+		SourceLineInfo() = delete;
+		SourceLineInfo( char const* _file, std::size_t _line ) noexcept
+			:   file( _file ),
+			line( _line )
+		{}
+
+		SourceLineInfo( SourceLineInfo const& other )        = default;
+		SourceLineInfo( SourceLineInfo && )                  = default;
+		SourceLineInfo& operator = ( SourceLineInfo const& ) = default;
+		SourceLineInfo& operator = ( SourceLineInfo && )     = default;
+
+		bool empty() const noexcept;
+		bool operator == ( SourceLineInfo const& other ) const noexcept;
+		bool operator < ( SourceLineInfo const& other ) const noexcept;
+
+		char const* file;
+		std::size_t line;
+	};
+
+	std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info );
+
+	// Bring in operator<< from global namespace into Catch namespace
+	// This is necessary because the overload of operator<< above makes
+	// lookup stop at namespace Catch
+	using ::operator<<;
+
+	// Use this in variadic streaming macros to allow
+	//    >> +StreamEndStop
+	// as well as
+	//    >> stuff +StreamEndStop
+	struct StreamEndStop {
+		std::string operator+() const;
+	};
+	template<typename T>
+	T const& operator + ( T const& value, StreamEndStop ) {
+		return value;
+	}
 }
 
 #define CATCH_INTERNAL_LINEINFO \
@@ -269,45 +446,48 @@ namespace Catch {
 // end catch_common.h
 namespace Catch {
 
-    struct RegistrarForTagAliases {
-        RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
-    };
+	struct RegistrarForTagAliases {
+		RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
+	};
 
 } // end namespace Catch
 
-#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); }
+#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+    namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \
+    CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
 
-// end catch_tag_alias_autoregistrar.h
-// start catch_test_registry.h
+  // end catch_tag_alias_autoregistrar.h
+  // start catch_test_registry.h
 
-// start catch_interfaces_testcase.h
+  // start catch_interfaces_testcase.h
 
 #include <vector>
 #include <memory>
 
 namespace Catch {
 
-    class TestSpec;
+	class TestSpec;
 
-    struct ITestInvoker {
-        virtual void invoke () const = 0;
-        virtual ~ITestInvoker();
-    };
+	struct ITestInvoker {
+		virtual void invoke () const = 0;
+		virtual ~ITestInvoker();
+	};
 
-    using ITestCasePtr = std::shared_ptr<ITestInvoker>;
+	using ITestCasePtr = std::shared_ptr<ITestInvoker>;
 
-    class TestCase;
-    struct IConfig;
+	class TestCase;
+	struct IConfig;
 
-    struct ITestCaseRegistry {
-        virtual ~ITestCaseRegistry();
-        virtual std::vector<TestCase> const& getAllTests() const = 0;
-        virtual std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const = 0;
-    };
+	struct ITestCaseRegistry {
+		virtual ~ITestCaseRegistry();
+		virtual std::vector<TestCase> const& getAllTests() const = 0;
+		virtual std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const = 0;
+	};
 
-    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
-    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
-    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
+	bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
+	std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
+	std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
 
 }
 
@@ -320,168 +500,507 @@ namespace Catch {
 
 namespace Catch {
 
-    class StringData;
+	class StringData;
+
+	/// A non-owning string class (similar to the forthcoming std::string_view)
+	/// Note that, because a StringRef may be a substring of another string,
+	/// it may not be null terminated. c_str() must return a null terminated
+	/// string, however, and so the StringRef will internally take ownership
+	/// (taking a copy), if necessary. In theory this ownership is not externally
+	/// visible - but it does mean (substring) StringRefs should not be shared between
+	/// threads.
+	class StringRef {
+	public:
+		using size_type = std::size_t;
+
+	private:
+		friend struct StringRefTestAccess;
+
+		char const* m_start;
+		size_type m_size;
 
-    /// A non-owning string class (similar to the forthcoming std::string_view)
-    /// Note that, because a StringRef may be a substring of another string,
-    /// it may not be null terminated. c_str() must return a null terminated
-    /// string, however, and so the StringRef will internally take ownership
-    /// (taking a copy), if necessary. In theory this ownership is not externally
-    /// visible - but it does mean (substring) StringRefs should not be shared between
-    /// threads.
-    class StringRef {
-        friend struct StringRefTestAccess;
+		char* m_data = nullptr;
 
-        using size_type = std::size_t;
+		void takeOwnership();
 
-        char const* m_start;
-        size_type m_size;
+		static constexpr char const* const s_empty = "";
 
-        char* m_data = nullptr;
+	public: // construction/ assignment
+		StringRef() noexcept
+			:   StringRef( s_empty, 0 )
+		{}
 
-        void takeOwnership();
+		StringRef( StringRef const& other ) noexcept
+			:   m_start( other.m_start ),
+			m_size( other.m_size )
+		{}
 
-    public: // construction/ assignment
-        StringRef() noexcept;
-        StringRef( StringRef const& other ) noexcept;
-        StringRef( StringRef&& other ) noexcept;
-        StringRef( char const* rawChars ) noexcept;
-        StringRef( char const* rawChars, size_type size ) noexcept;
-        StringRef( std::string const& stdString ) noexcept;
-        ~StringRef() noexcept;
+		StringRef( StringRef&& other ) noexcept
+			:   m_start( other.m_start ),
+			m_size( other.m_size ),
+			m_data( other.m_data )
+		{
+			other.m_data = nullptr;
+		}
 
-        auto operator = ( StringRef other ) noexcept -> StringRef&;
-        operator std::string() const;
+		StringRef( char const* rawChars ) noexcept;
 
-        void swap( StringRef& other ) noexcept;
+		StringRef( char const* rawChars, size_type size ) noexcept
+			:   m_start( rawChars ),
+			m_size( size )
+		{}
 
-    public: // operators
-        auto operator == ( StringRef const& other ) const noexcept -> bool;
-        auto operator != ( StringRef const& other ) const noexcept -> bool;
+		StringRef( std::string const& stdString ) noexcept
+			:   m_start( stdString.c_str() ),
+			m_size( stdString.size() )
+		{}
 
-        auto operator[] ( size_type index ) const noexcept -> char;
+		~StringRef() noexcept {
+			delete[] m_data;
+		}
 
-    public: // named queries
-        auto empty() const noexcept -> bool;
-        auto size() const noexcept -> size_type;
-        auto numberOfCharacters() const noexcept -> size_type;
-        auto c_str() const -> char const*;
+		auto operator = ( StringRef const &other ) noexcept -> StringRef& {
+			delete[] m_data;
+			m_data = nullptr;
+			m_start = other.m_start;
+			m_size = other.m_size;
+			return *this;
+		}
 
-    public: // substrings and searches
-        auto substr( size_type start, size_type size ) const noexcept -> StringRef;
+		operator std::string() const;
 
-    private: // ownership queries - may not be consistent between calls
-        auto isOwned() const noexcept -> bool;
-        auto isSubstring() const noexcept -> bool;
-        auto data() const noexcept -> char const*;
-    };
+		void swap( StringRef& other ) noexcept;
 
-    auto operator + ( StringRef const& lhs, StringRef const& rhs ) -> std::string;
-    auto operator + ( StringRef const& lhs, char const* rhs ) -> std::string;
-    auto operator + ( char const* lhs, StringRef const& rhs ) -> std::string;
+	public: // operators
+		auto operator == ( StringRef const& other ) const noexcept -> bool;
+		auto operator != ( StringRef const& other ) const noexcept -> bool;
 
-    auto operator << ( std::ostream& os, StringRef const& sr ) -> std::ostream&;
+		auto operator[] ( size_type index ) const noexcept -> char;
+
+	public: // named queries
+		auto empty() const noexcept -> bool {
+			return m_size == 0;
+		}
+		auto size() const noexcept -> size_type {
+			return m_size;
+		}
+
+		auto numberOfCharacters() const noexcept -> size_type;
+		auto c_str() const -> char const*;
+
+	public: // substrings and searches
+		auto substr( size_type start, size_type size ) const noexcept -> StringRef;
+
+		// Returns the current start pointer.
+		// Note that the pointer can change when if the StringRef is a substring
+		auto currentData() const noexcept -> char const*;
+
+	private: // ownership queries - may not be consistent between calls
+		auto isOwned() const noexcept -> bool;
+		auto isSubstring() const noexcept -> bool;
+	};
+
+	auto operator + ( StringRef const& lhs, StringRef const& rhs ) -> std::string;
+	auto operator + ( StringRef const& lhs, char const* rhs ) -> std::string;
+	auto operator + ( char const* lhs, StringRef const& rhs ) -> std::string;
+
+	auto operator += ( std::string& lhs, StringRef const& sr ) -> std::string&;
+	auto operator << ( std::ostream& os, StringRef const& sr ) -> std::ostream&;
+
+	inline auto operator "" _sr( char const* rawChars, std::size_t size ) noexcept -> StringRef {
+		return StringRef( rawChars, size );
+	}
 
 } // namespace Catch
 
+inline auto operator "" _catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef {
+	return Catch::StringRef( rawChars, size );
+}
+
 // end catch_stringref.h
-namespace Catch {
+// start catch_type_traits.hpp
+
 
-template<typename C>
-class TestInvokerAsMethod : public ITestInvoker {
-    void (C::*m_testAsMethod)();
-public:
-    TestInvokerAsMethod( void (C::*testAsMethod)() ) noexcept : m_testAsMethod( testAsMethod ) {}
+namespace Catch{
 
-    void invoke() const override {
-        C obj;
-        (obj.*m_testAsMethod)();
-    }
-};
+#ifdef CATCH_CPP17_OR_GREATER
+	template <typename...>
+	inline constexpr auto is_unique = std::true_type{};
 
-auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker*;
+	template <typename T, typename... Rest>
+	inline constexpr auto is_unique<T, Rest...> = std::bool_constant<
+		(!std::is_same_v<T, Rest> && ...) && is_unique<Rest...>
+	>{};
+#else
+
+	template <typename...>
+	struct is_unique : std::true_type{};
 
-template<typename C>
-auto makeTestInvoker( void (C::*testAsMethod)() ) noexcept -> ITestInvoker* {
-    return new(std::nothrow) TestInvokerAsMethod<C>( testAsMethod );
+	template <typename T0, typename T1, typename... Rest>
+	struct is_unique<T0, T1, Rest...> : std::integral_constant
+		<bool,
+		!std::is_same<T0, T1>::value
+		&& is_unique<T0, Rest...>::value
+		&& is_unique<T1, Rest...>::value
+		>{};
+
+#endif
 }
 
-struct NameAndTags {
-    NameAndTags( StringRef name_ = "", StringRef tags_ = "" ) noexcept;
-    StringRef name;
-    StringRef tags;
-};
+// end catch_type_traits.hpp
+// start catch_preprocessor.hpp
+
+
+#define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__
+#define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__)))
+
+#ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__
+// MSVC needs more evaluations
+#define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__)))
+#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__))
+#else
+#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL5(__VA_ARGS__)
+#endif
+
+#define CATCH_REC_END(...)
+#define CATCH_REC_OUT
+
+#define CATCH_EMPTY()
+#define CATCH_DEFER(id) id CATCH_EMPTY()
+
+#define CATCH_REC_GET_END2() 0, CATCH_REC_END
+#define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2
+#define CATCH_REC_GET_END(...) CATCH_REC_GET_END1
+#define CATCH_REC_NEXT0(test, next, ...) next CATCH_REC_OUT
+#define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0)
+#define CATCH_REC_NEXT(test, next)  CATCH_REC_NEXT1(CATCH_REC_GET_END test, next)
+
+#define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST2(f, x, peek, ...)   f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
+
+#define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...)   f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
+
+// Applies the function macro `f` to each of the remaining parameters, inserts commas between the results,
+// and passes userdata as the first parameter to each invocation,
+// e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c)
+#define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
+
+#define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
+
+#define INTERNAL_CATCH_EXPAND1(param) INTERNAL_CATCH_EXPAND2(param)
+#define INTERNAL_CATCH_EXPAND2(...) INTERNAL_CATCH_NO## __VA_ARGS__
+#define INTERNAL_CATCH_DEF(...) INTERNAL_CATCH_DEF __VA_ARGS__
+#define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
+
+#define INTERNAL_CATCH_REMOVE_PARENS(...) INTERNAL_CATCH_EXPAND1(INTERNAL_CATCH_DEF __VA_ARGS__)
+
+#define INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME2(Name, ...) INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME3(Name, __VA_ARGS__)
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME3(Name,...) Name " - " #__VA_ARGS__
+#define INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME(Name,...) INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME2(Name, INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))
+#else
+// MSVC is adding extra space and needs more calls to properly remove ()
+#define INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME3(Name,...) Name " -" #__VA_ARGS__
+#define INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME1(Name, ...) INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME2(Name, __VA_ARGS__)
+#define INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME(Name, ...) INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME1(Name, INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)))
+#endif
+
+// end catch_preprocessor.hpp
+namespace Catch {
+
+	template<typename C>
+	class TestInvokerAsMethod : public ITestInvoker {
+		void (C::*m_testAsMethod)();
+	public:
+		TestInvokerAsMethod( void (C::*testAsMethod)() ) noexcept : m_testAsMethod( testAsMethod ) {}
+
+		void invoke() const override {
+			C obj;
+			(obj.*m_testAsMethod)();
+		}
+	};
+
+	auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker*;
+
+	template<typename C>
+	auto makeTestInvoker( void (C::*testAsMethod)() ) noexcept -> ITestInvoker* {
+		return new(std::nothrow) TestInvokerAsMethod<C>( testAsMethod );
+	}
+
+	struct NameAndTags {
+		NameAndTags( StringRef const& name_ = StringRef(), StringRef const& tags_ = StringRef() ) noexcept;
+		StringRef name;
+		StringRef tags;
+	};
 
-struct AutoReg : NonCopyable {
-    AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef classOrMethod, NameAndTags const& nameAndTags ) noexcept;
-    ~AutoReg();
-};
+	struct AutoReg : NonCopyable {
+		AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept;
+		~AutoReg();
+	};
 
 } // end namespace Catch
 
 #if defined(CATCH_CONFIG_DISABLE)
-    #define INTERNAL_CATCH_TESTCASE_NO_REGISTRATION( TestName, ... ) \
+#define INTERNAL_CATCH_TESTCASE_NO_REGISTRATION( TestName, ... ) \
         static void TestName()
-    #define INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION( TestName, ClassName, ... ) \
+#define INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION( TestName, ClassName, ... ) \
         namespace{                        \
-            struct TestName : ClassName { \
+            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
                 void test();              \
             };                            \
         }                                 \
         void TestName::test()
-
+#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION( TestName, ... )  \
+        template<typename TestType>                                             \
+        static void TestName()
+#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( TestName, ClassName, ... )    \
+        namespace{                                                                                  \
+            template<typename TestType>                                                             \
+            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) {     \
+                void test();                                                                        \
+            };                                                                                      \
+        }                                                                                           \
+        template<typename TestType>                                                                 \
+        void TestName::test()
 #endif
 
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \
+  ///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \
         static void TestName(); \
         CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, "", Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
         CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \
         static void TestName()
-    #define INTERNAL_CATCH_TESTCASE( ... ) \
+#define INTERNAL_CATCH_TESTCASE( ... ) \
         INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), __VA_ARGS__ )
 
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
+  ///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
         CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
         namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &QualifiedMethod ), CATCH_INTERNAL_LINEINFO, "&" #QualifiedMethod, Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
         CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
 
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\
+  ///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\
         CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
         namespace{ \
-            struct TestName : ClassName{ \
+            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
                 void test(); \
             }; \
             Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( Catch::makeTestInvoker( &TestName::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
         } \
         CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \
         void TestName::test()
-    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \
+#define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \
         INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), ClassName, __VA_ARGS__ )
 
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \
+  ///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \
         CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( Function ), CATCH_INTERNAL_LINEINFO, "", Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
+        Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( Function ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
         CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
 
-// end catch_test_registry.h
-// start catch_capture.hpp
+  ///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_2(TestName, TestFunc, Name, Tags, ... )\
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        template<typename TestType> \
+        static void TestFunc();\
+        namespace {\
+            template<typename...Types> \
+            struct TestName{\
+                template<typename...Ts> \
+                TestName(Ts...names){\
+                    CATCH_INTERNAL_CHECK_UNIQUE_TYPES(CATCH_REC_LIST(INTERNAL_CATCH_REMOVE_PARENS, __VA_ARGS__)) \
+                    using expander = int[];\
+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ names, Tags } ), 0)... };/* NOLINT */ \
+                }\
+            };\
+            INTERNAL_CATCH_TEMPLATE_REGISTRY_INITIATE(TestName, Name, __VA_ARGS__) \
+        }\
+        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \
+        template<typename TestType> \
+        static void TestFunc()
+
+#if defined(CATCH_CPP17_OR_GREATER)
+#define CATCH_INTERNAL_CHECK_UNIQUE_TYPES(...) static_assert(Catch::is_unique<__VA_ARGS__>,"Duplicate type detected in declaration of template test case");
+#else
+#define CATCH_INTERNAL_CHECK_UNIQUE_TYPES(...) static_assert(Catch::is_unique<__VA_ARGS__>::value,"Duplicate type detected in declaration of template test case");
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, __VA_ARGS__ )
+#else
+#define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, __VA_ARGS__ ) )
+#endif
+
+#define INTERNAL_CATCH_TEMPLATE_REGISTRY_INITIATE(TestName, Name, ...)\
+        static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+            TestName<CATCH_REC_LIST(INTERNAL_CATCH_REMOVE_PARENS, __VA_ARGS__)>(CATCH_REC_LIST_UD(INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME,Name, __VA_ARGS__));\
+            return 0;\
+        }();
+
+#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, ... ) \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        namespace{ \
+            template<typename TestType> \
+            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
+                void test();\
+            };\
+            template<typename...Types> \
+            struct TestNameClass{\
+                template<typename...Ts> \
+                TestNameClass(Ts...names){\
+                    CATCH_INTERNAL_CHECK_UNIQUE_TYPES(CATCH_REC_LIST(INTERNAL_CATCH_REMOVE_PARENS, __VA_ARGS__)) \
+                    using expander = int[];\
+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ names, Tags } ), 0)... };/* NOLINT */ \
+                }\
+            };\
+            INTERNAL_CATCH_TEMPLATE_REGISTRY_INITIATE(TestNameClass, Name, __VA_ARGS__)\
+        }\
+        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS\
+        template<typename TestType> \
+        void TestName<TestType>::test()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, __VA_ARGS__ )
+#else
+#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, __VA_ARGS__ ) )
+#endif
+
+  // end catch_test_registry.h
+  // start catch_capture.hpp
 
-// start catch_assertionhandler.h
+  // start catch_assertionhandler.h
 
-// start catch_decomposer.h
+  // start catch_assertioninfo.h
 
-// start catch_tostring.h
+  // start catch_result_type.h
+
+namespace Catch {
+
+	// ResultWas::OfType enum
+	struct ResultWas { enum OfType {
+		Unknown = -1,
+		Ok = 0,
+		Info = 1,
+		Warning = 2,
+
+		FailureBit = 0x10,
+
+		ExpressionFailed = FailureBit | 1,
+		ExplicitFailure = FailureBit | 2,
+
+		Exception = 0x100 | FailureBit,
+
+		ThrewException = Exception | 1,
+		DidntThrowException = Exception | 2,
+
+		FatalErrorCondition = 0x200 | FailureBit
+
+	}; };
+
+	bool isOk( ResultWas::OfType resultType );
+	bool isJustInfo( int flags );
+
+	// ResultDisposition::Flags enum
+	struct ResultDisposition { enum Flags {
+		Normal = 0x01,
+
+		ContinueOnFailure = 0x02,   // Failures fail test, but execution continues
+		FalseTest = 0x04,           // Prefix expression with !
+		SuppressFail = 0x08         // Failures are reported but do not fail the test
+	}; };
+
+	ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs );
+
+	bool shouldContinueOnFailure( int flags );
+	inline bool isFalseTest( int flags ) { return ( flags & ResultDisposition::FalseTest ) != 0; }
+	bool shouldSuppressFailure( int flags );
+
+} // end namespace Catch
+
+  // end catch_result_type.h
+namespace Catch {
+
+	struct AssertionInfo
+	{
+		StringRef macroName;
+		SourceLineInfo lineInfo;
+		StringRef capturedExpression;
+		ResultDisposition::Flags resultDisposition;
+
+		// We want to delete this constructor but a compiler bug in 4.8 means
+		// the struct is then treated as non-aggregate
+		//AssertionInfo() = delete;
+	};
+
+} // end namespace Catch
+
+  // end catch_assertioninfo.h
+  // start catch_decomposer.h
+
+  // start catch_tostring.h
 
-#include <sstream>
 #include <vector>
 #include <cstddef>
 #include <type_traits>
 #include <string>
+  // start catch_stream.h
+
+#include <iosfwd>
+#include <cstddef>
+#include <ostream>
+
+namespace Catch {
+
+	std::ostream& cout();
+	std::ostream& cerr();
+	std::ostream& clog();
+
+	class StringRef;
+
+	struct IStream {
+		virtual ~IStream();
+		virtual std::ostream& stream() const = 0;
+	};
+
+	auto makeStream( StringRef const &filename ) -> IStream const*;
+
+	class ReusableStringStream {
+		std::size_t m_index;
+		std::ostream* m_oss;
+	public:
+		ReusableStringStream();
+		~ReusableStringStream();
+
+		auto str() const -> std::string;
+
+		template<typename T>
+		auto operator << ( T const& value ) -> ReusableStringStream& {
+			*m_oss << value;
+			return *this;
+		}
+		auto get() -> std::ostream& { return *m_oss; }
+	};
+}
+
+// end catch_stream.h
+
+#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+#include <string_view>
+#endif
 
 #ifdef __OBJC__
 // start catch_objc_arc.hpp
@@ -499,12 +1018,12 @@ id performOptionalSelector( id obj, SEL sel );
 
 #if !CATCH_ARC_ENABLED
 inline void arcSafeRelease( NSObject* obj ) {
-    [obj release];
+	[obj release];
 }
 inline id performOptionalSelector( id obj, SEL sel ) {
-    if( [obj respondsToSelector: sel] )
-        return [obj performSelector: sel];
-    return nil;
+	if( [obj respondsToSelector: sel] )
+		return [obj performSelector: sel];
+	return nil;
 }
 #define CATCH_UNSAFE_UNRETAINED
 #define CATCH_ARC_STRONG
@@ -515,12 +1034,12 @@ inline id performOptionalSelector( id obj, SEL sel ) {
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Warc-performSelector-leaks"
 #endif
-    if( [obj respondsToSelector: sel] )
-        return [obj performSelector: sel];
+	if( [obj respondsToSelector: sel] )
+		return [obj performSelector: sel];
 #ifdef __clang__
 #pragma clang diagnostic pop
 #endif
-    return nil;
+	return nil;
 }
 #define CATCH_UNSAFE_UNRETAINED __unsafe_unretained
 #define CATCH_ARC_STRONG __strong
@@ -534,279 +1053,341 @@ inline id performOptionalSelector( id obj, SEL sel ) {
 #pragma warning(disable:4180) // We attempt to stream a function (address) by const&, which MSVC complains about but is harmless
 #endif
 
-// We need a dummy global operator<< so we can bring it into Catch namespace later
-struct Catch_global_namespace_dummy;
-std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy);
-
 namespace Catch {
-    // Bring in operator<< from global namespace into Catch namespace
-    using ::operator<<;
-
-    namespace Detail {
-
-        extern const std::string unprintableString;
-
-        std::string rawMemoryToString( const void *object, std::size_t size );
-
-        template<typename T>
-        std::string rawMemoryToString( const T& object ) {
-          return rawMemoryToString( &object, sizeof(object) );
-        }
-
-        template<typename T>
-        class IsStreamInsertable {
-            template<typename SS, typename TT>
-            static auto test(int)
-                -> decltype(std::declval<SS&>() << std::declval<TT>(), std::true_type());
-
-            template<typename, typename>
-            static auto test(...)->std::false_type;
-
-        public:
-            static const bool value = decltype(test<std::ostream, const T&>(0))::value;
-        };
-
-    } // namespace Detail
-
-    // If we decide for C++14, change these to enable_if_ts
-    template <typename T>
-    struct StringMaker {
-        template <typename Fake = T>
-        static
-        typename std::enable_if<::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
-            convert(const Fake& t) {
-                std::ostringstream sstr;
-                sstr << t;
-                return sstr.str();
-        }
-
-        template <typename Fake = T>
-        static
-        typename std::enable_if<!::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
-            convert(const Fake&) {
-                return Detail::unprintableString;
-        }
-    };
-
-    namespace Detail {
-
-        // This function dispatches all stringification requests inside of Catch.
-        // Should be preferably called fully qualified, like ::Catch::Detail::stringify
-        template <typename T>
-        std::string stringify(const T& e) {
-            return ::Catch::StringMaker<typename std::remove_cv<typename std::remove_reference<T>::type>::type>::convert(e);
-        }
-
-    } // namespace Detail
-
-    // Some predefined specializations
-
-    template<>
-    struct StringMaker<std::string> {
-        static std::string convert(const std::string& str);
-    };
-    template<>
-    struct StringMaker<std::wstring> {
-        static std::string convert(const std::wstring& wstr);
-    };
-
-    template<>
-    struct StringMaker<char const *> {
-        static std::string convert(char const * str);
-    };
-    template<>
-    struct StringMaker<char *> {
-        static std::string convert(char * str);
-    };
-    template<>
-    struct StringMaker<wchar_t const *> {
-        static std::string convert(wchar_t const * str);
-    };
-    template<>
-    struct StringMaker<wchar_t *> {
-        static std::string convert(wchar_t * str);
-    };
-
-    template<int SZ>
-    struct StringMaker<char[SZ]> {
-        static std::string convert(const char* str) {
-            return ::Catch::Detail::stringify(std::string{ str });
-        }
-    };
-    template<int SZ>
-    struct StringMaker<signed char[SZ]> {
-        static std::string convert(const char* str) {
-            return ::Catch::Detail::stringify(std::string{ str });
-        }
-    };
-    template<int SZ>
-    struct StringMaker<unsigned char[SZ]> {
-        static std::string convert(const char* str) {
-            return ::Catch::Detail::stringify(std::string{ str });
-        }
-    };
-
-    template<>
-    struct StringMaker<int> {
-        static std::string convert(int value);
-    };
-    template<>
-    struct StringMaker<long> {
-        static std::string convert(long value);
-    };
-    template<>
-    struct StringMaker<long long> {
-        static std::string convert(long long value);
-    };
-    template<>
-    struct StringMaker<unsigned int> {
-        static std::string convert(unsigned int value);
-    };
-    template<>
-    struct StringMaker<unsigned long> {
-        static std::string convert(unsigned long value);
-    };
-    template<>
-    struct StringMaker<unsigned long long> {
-        static std::string convert(unsigned long long value);
-    };
-
-    template<>
-    struct StringMaker<bool> {
-        static std::string convert(bool b);
-    };
-
-    template<>
-    struct StringMaker<char> {
-        static std::string convert(char c);
-    };
-    template<>
-    struct StringMaker<signed char> {
-        static std::string convert(signed char c);
-    };
-    template<>
-    struct StringMaker<unsigned char> {
-        static std::string convert(unsigned char c);
-    };
-
-    template<>
-    struct StringMaker<std::nullptr_t> {
-        static std::string convert(std::nullptr_t);
-    };
-
-    template<>
-    struct StringMaker<float> {
-        static std::string convert(float value);
-    };
-    template<>
-    struct StringMaker<double> {
-        static std::string convert(double value);
-    };
-
-    template <typename T>
-    struct StringMaker<T*> {
-        template <typename U>
-        static std::string convert(U* p) {
-            if (p) {
-                return ::Catch::Detail::rawMemoryToString(p);
-            } else {
-                return "nullptr";
-            }
-        }
-    };
-
-    template <typename R, typename C>
-    struct StringMaker<R C::*> {
-        static std::string convert(R C::* p) {
-            if (p) {
-                return ::Catch::Detail::rawMemoryToString(p);
-            } else {
-                return "nullptr";
-            }
-        }
-    };
-
-    namespace Detail {
-        template<typename InputIterator>
-        std::string rangeToString(InputIterator first, InputIterator last) {
-            std::ostringstream oss;
-            oss << "{ ";
-            if (first != last) {
-                oss << ::Catch::Detail::stringify(*first);
-                for (++first; first != last; ++first)
-                    oss << ", " << ::Catch::Detail::stringify(*first);
-            }
-            oss << " }";
-            return oss.str();
-        }
-    }
-
-    template<typename T, typename Allocator>
-    struct StringMaker<std::vector<T, Allocator> > {
-        static std::string convert( std::vector<T,Allocator> const& v ) {
-            return ::Catch::Detail::rangeToString( v.begin(), v.end() );
-        }
-    };
-
-    template<typename T>
-    struct EnumStringMaker {
-        static std::string convert(const T& t) {
-            return ::Catch::Detail::stringify(static_cast<typename std::underlying_type<T>::type>(t));
-        }
-    };
+	namespace Detail {
+
+		extern const std::string unprintableString;
+
+		std::string rawMemoryToString( const void *object, std::size_t size );
+
+		template<typename T>
+		std::string rawMemoryToString( const T& object ) {
+			return rawMemoryToString( &object, sizeof(object) );
+		}
+
+		template<typename T>
+		class IsStreamInsertable {
+			template<typename SS, typename TT>
+			static auto test(int)
+				-> decltype(std::declval<SS&>() << std::declval<TT>(), std::true_type());
+
+			template<typename, typename>
+			static auto test(...)->std::false_type;
+
+		public:
+			static const bool value = decltype(test<std::ostream, const T&>(0))::value;
+		};
+
+		template<typename E>
+		std::string convertUnknownEnumToString( E e );
+
+		template<typename T>
+		typename std::enable_if<
+			!std::is_enum<T>::value && !std::is_base_of<std::exception, T>::value,
+			std::string>::type convertUnstreamable( T const& ) {
+			return Detail::unprintableString;
+		}
+		template<typename T>
+		typename std::enable_if<
+			!std::is_enum<T>::value && std::is_base_of<std::exception, T>::value,
+			std::string>::type convertUnstreamable(T const& ex) {
+			return ex.what();
+		}
+
+		template<typename T>
+		typename std::enable_if<
+			std::is_enum<T>::value
+			, std::string>::type convertUnstreamable( T const& value ) {
+			return convertUnknownEnumToString( value );
+		}
+
+#if defined(_MANAGED)
+		//! Convert a CLR string to a utf8 std::string
+		template<typename T>
+		std::string clrReferenceToString( T^ ref ) {
+			if (ref == nullptr)
+				return std::string("null");
+			auto bytes = System::Text::Encoding::UTF8->GetBytes(ref->ToString());
+			cli::pin_ptr<System::Byte> p = &bytes[0];
+			return std::string(reinterpret_cast<char const *>(p), bytes->Length);
+		}
+#endif
+
+	} // namespace Detail
+
+	  // If we decide for C++14, change these to enable_if_ts
+	template <typename T, typename = void>
+	struct StringMaker {
+		template <typename Fake = T>
+		static
+			typename std::enable_if<::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
+			convert(const Fake& value) {
+			ReusableStringStream rss;
+			// NB: call using the function-like syntax to avoid ambiguity with
+			// user-defined templated operator<< under clang.
+			rss.operator<<(value);
+			return rss.str();
+		}
+
+		template <typename Fake = T>
+		static
+			typename std::enable_if<!::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
+			convert( const Fake& value ) {
+#if !defined(CATCH_CONFIG_FALLBACK_STRINGIFIER)
+			return Detail::convertUnstreamable(value);
+#else
+			return CATCH_CONFIG_FALLBACK_STRINGIFIER(value);
+#endif
+		}
+	};
+
+	namespace Detail {
+
+		// This function dispatches all stringification requests inside of Catch.
+		// Should be preferably called fully qualified, like ::Catch::Detail::stringify
+		template <typename T>
+		std::string stringify(const T& e) {
+			return ::Catch::StringMaker<typename std::remove_cv<typename std::remove_reference<T>::type>::type>::convert(e);
+		}
+
+		template<typename E>
+		std::string convertUnknownEnumToString( E e ) {
+			return ::Catch::Detail::stringify(static_cast<typename std::underlying_type<E>::type>(e));
+		}
+
+#if defined(_MANAGED)
+		template <typename T>
+		std::string stringify( T^ e ) {
+			return ::Catch::StringMaker<T^>::convert(e);
+		}
+#endif
+
+	} // namespace Detail
+
+	  // Some predefined specializations
+
+	template<>
+	struct StringMaker<std::string> {
+		static std::string convert(const std::string& str);
+	};
+
+#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+	template<>
+	struct StringMaker<std::string_view> {
+		static std::string convert(std::string_view str);
+	};
+#endif
+
+	template<>
+	struct StringMaker<char const *> {
+		static std::string convert(char const * str);
+	};
+	template<>
+	struct StringMaker<char *> {
+		static std::string convert(char * str);
+	};
+
+#ifdef CATCH_CONFIG_WCHAR
+	template<>
+	struct StringMaker<std::wstring> {
+		static std::string convert(const std::wstring& wstr);
+	};
+
+# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+	template<>
+	struct StringMaker<std::wstring_view> {
+		static std::string convert(std::wstring_view str);
+	};
+# endif
+
+	template<>
+	struct StringMaker<wchar_t const *> {
+		static std::string convert(wchar_t const * str);
+	};
+	template<>
+	struct StringMaker<wchar_t *> {
+		static std::string convert(wchar_t * str);
+	};
+#endif
+
+	// TBD: Should we use `strnlen` to ensure that we don't go out of the buffer,
+	//      while keeping string semantics?
+	template<int SZ>
+	struct StringMaker<char[SZ]> {
+		static std::string convert(char const* str) {
+			return ::Catch::Detail::stringify(std::string{ str });
+		}
+	};
+	template<int SZ>
+	struct StringMaker<signed char[SZ]> {
+		static std::string convert(signed char const* str) {
+			return ::Catch::Detail::stringify(std::string{ reinterpret_cast<char const *>(str) });
+		}
+	};
+	template<int SZ>
+	struct StringMaker<unsigned char[SZ]> {
+		static std::string convert(unsigned char const* str) {
+			return ::Catch::Detail::stringify(std::string{ reinterpret_cast<char const *>(str) });
+		}
+	};
+
+	template<>
+	struct StringMaker<int> {
+		static std::string convert(int value);
+	};
+	template<>
+	struct StringMaker<long> {
+		static std::string convert(long value);
+	};
+	template<>
+	struct StringMaker<long long> {
+		static std::string convert(long long value);
+	};
+	template<>
+	struct StringMaker<unsigned int> {
+		static std::string convert(unsigned int value);
+	};
+	template<>
+	struct StringMaker<unsigned long> {
+		static std::string convert(unsigned long value);
+	};
+	template<>
+	struct StringMaker<unsigned long long> {
+		static std::string convert(unsigned long long value);
+	};
+
+	template<>
+	struct StringMaker<bool> {
+		static std::string convert(bool b);
+	};
+
+	template<>
+	struct StringMaker<char> {
+		static std::string convert(char c);
+	};
+	template<>
+	struct StringMaker<signed char> {
+		static std::string convert(signed char c);
+	};
+	template<>
+	struct StringMaker<unsigned char> {
+		static std::string convert(unsigned char c);
+	};
+
+	template<>
+	struct StringMaker<std::nullptr_t> {
+		static std::string convert(std::nullptr_t);
+	};
+
+	template<>
+	struct StringMaker<float> {
+		static std::string convert(float value);
+	};
+	template<>
+	struct StringMaker<double> {
+		static std::string convert(double value);
+	};
+
+	template <typename T>
+	struct StringMaker<T*> {
+		template <typename U>
+		static std::string convert(U* p) {
+			if (p) {
+				return ::Catch::Detail::rawMemoryToString(p);
+			} else {
+				return "nullptr";
+			}
+		}
+	};
+
+	template <typename R, typename C>
+	struct StringMaker<R C::*> {
+		static std::string convert(R C::* p) {
+			if (p) {
+				return ::Catch::Detail::rawMemoryToString(p);
+			} else {
+				return "nullptr";
+			}
+		}
+	};
+
+#if defined(_MANAGED)
+	template <typename T>
+	struct StringMaker<T^> {
+		static std::string convert( T^ ref ) {
+			return ::Catch::Detail::clrReferenceToString(ref);
+		}
+	};
+#endif
+
+	namespace Detail {
+		template<typename InputIterator>
+		std::string rangeToString(InputIterator first, InputIterator last) {
+			ReusableStringStream rss;
+			rss << "{ ";
+			if (first != last) {
+				rss << ::Catch::Detail::stringify(*first);
+				for (++first; first != last; ++first)
+					rss << ", " << ::Catch::Detail::stringify(*first);
+			}
+			rss << " }";
+			return rss.str();
+		}
+	}
 
 #ifdef __OBJC__
-    template<>
-    struct StringMaker<NSString*> {
-        static std::string convert(NSString * nsstring) {
-            if (!nsstring)
-                return "nil";
-            return std::string("@") + [nsstring UTF8String];
-        }
-    };
-    template<>
-    struct StringMaker<NSObject*> {
-        static std::string convert(NSObject* nsObject) {
-            return ::Catch::Detail::stringify([nsObject description]);
-        }
-
-    };
-    namespace Detail {
-        inline std::string stringify( NSString* nsstring ) {
-            return StringMaker<NSString*>::convert( nsstring );
-        }
-
-    } // namespace Detail
+	template<>
+	struct StringMaker<NSString*> {
+		static std::string convert(NSString * nsstring) {
+			if (!nsstring)
+				return "nil";
+			return std::string("@") + [nsstring UTF8String];
+		}
+	};
+	template<>
+	struct StringMaker<NSObject*> {
+		static std::string convert(NSObject* nsObject) {
+			return ::Catch::Detail::stringify([nsObject description]);
+		}
+
+	};
+	namespace Detail {
+		inline std::string stringify( NSString* nsstring ) {
+			return StringMaker<NSString*>::convert( nsstring );
+		}
+
+	} // namespace Detail
 #endif // __OBJC__
 
 } // namespace Catch
 
-//////////////////////////////////////////////////////
-// Separate std-lib types stringification, so it can be selectively enabled
-// This means that we do not bring in
+  //////////////////////////////////////////////////////
+  // Separate std-lib types stringification, so it can be selectively enabled
+  // This means that we do not bring in
 
 #if defined(CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS)
 #  define CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
 #  define CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
+#  define CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
 #  define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
 #endif
 
-// Separate std::pair specialization
+  // Separate std::pair specialization
 #if defined(CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER)
 #include <utility>
 namespace Catch {
-    template<typename T1, typename T2>
-    struct StringMaker<std::pair<T1, T2> > {
-        static std::string convert(const std::pair<T1, T2>& pair) {
-            std::ostringstream oss;
-            oss << "{ "
-                << ::Catch::Detail::stringify(pair.first)
-                << ", "
-                << ::Catch::Detail::stringify(pair.second)
-                << " }";
-            return oss.str();
-        }
-    };
+	template<typename T1, typename T2>
+	struct StringMaker<std::pair<T1, T2> > {
+		static std::string convert(const std::pair<T1, T2>& pair) {
+			ReusableStringStream rss;
+			rss << "{ "
+				<< ::Catch::Detail::stringify(pair.first)
+				<< ", "
+				<< ::Catch::Detail::stringify(pair.second)
+				<< " }";
+			return rss.str();
+		}
+	};
 }
 #endif // CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
 
@@ -814,156 +1395,247 @@ namespace Catch {
 #if defined(CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER)
 #include <tuple>
 namespace Catch {
-    namespace Detail {
-        template<
-            typename Tuple,
-            std::size_t N = 0,
-            bool = (N < std::tuple_size<Tuple>::value)
-            >
-            struct TupleElementPrinter {
-            static void print(const Tuple& tuple, std::ostream& os) {
-                os << (N ? ", " : " ")
-                    << ::Catch::Detail::stringify(std::get<N>(tuple));
-                TupleElementPrinter<Tuple, N + 1>::print(tuple, os);
-            }
-        };
-
-        template<
-            typename Tuple,
-            std::size_t N
-        >
-            struct TupleElementPrinter<Tuple, N, false> {
-            static void print(const Tuple&, std::ostream&) {}
-        };
-
-    }
-
-    template<typename ...Types>
-    struct StringMaker<std::tuple<Types...>> {
-        static std::string convert(const std::tuple<Types...>& tuple) {
-            std::ostringstream os;
-            os << '{';
-            Detail::TupleElementPrinter<std::tuple<Types...>>::print(tuple, os);
-            os << " }";
-            return os.str();
-        }
-    };
+	namespace Detail {
+		template<
+			typename Tuple,
+			std::size_t N = 0,
+			bool = (N < std::tuple_size<Tuple>::value)
+			>
+			struct TupleElementPrinter {
+			static void print(const Tuple& tuple, std::ostream& os) {
+				os << (N ? ", " : " ")
+					<< ::Catch::Detail::stringify(std::get<N>(tuple));
+				TupleElementPrinter<Tuple, N + 1>::print(tuple, os);
+			}
+		};
+
+		template<
+			typename Tuple,
+			std::size_t N
+		>
+			struct TupleElementPrinter<Tuple, N, false> {
+			static void print(const Tuple&, std::ostream&) {}
+		};
+
+	}
+
+	template<typename ...Types>
+	struct StringMaker<std::tuple<Types...>> {
+		static std::string convert(const std::tuple<Types...>& tuple) {
+			ReusableStringStream rss;
+			rss << '{';
+			Detail::TupleElementPrinter<std::tuple<Types...>>::print(tuple, rss.get());
+			rss << " }";
+			return rss.str();
+		}
+	};
 }
 #endif // CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
 
-// Separate std::chrono::duration specialization
+#if defined(CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_VARIANT)
+#include <variant>
+namespace Catch {
+	template<>
+	struct StringMaker<std::monostate> {
+		static std::string convert(const std::monostate&) {
+			return "{ }";
+		}
+	};
+
+	template<typename... Elements>
+	struct StringMaker<std::variant<Elements...>> {
+		static std::string convert(const std::variant<Elements...>& variant) {
+			if (variant.valueless_by_exception()) {
+				return "{valueless variant}";
+			} else {
+				return std::visit(
+					[](const auto& value) {
+					return ::Catch::Detail::stringify(value);
+				},
+					variant
+					);
+			}
+		}
+	};
+}
+#endif // CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
+
+namespace Catch {
+	struct not_this_one {}; // Tag type for detecting which begin/ end are being selected
+
+							// Import begin/ end from std here so they are considered alongside the fallback (...) overloads in this namespace
+	using std::begin;
+	using std::end;
+
+	not_this_one begin( ... );
+	not_this_one end( ... );
+
+	template <typename T>
+	struct is_range {
+		static const bool value =
+			!std::is_same<decltype(begin(std::declval<T>())), not_this_one>::value &&
+			!std::is_same<decltype(end(std::declval<T>())), not_this_one>::value;
+	};
+
+#if defined(_MANAGED) // Managed types are never ranges
+	template <typename T>
+	struct is_range<T^> {
+		static const bool value = false;
+	};
+#endif
+
+	template<typename Range>
+	std::string rangeToString( Range const& range ) {
+		return ::Catch::Detail::rangeToString( begin( range ), end( range ) );
+	}
+
+	// Handle vector<bool> specially
+	template<typename Allocator>
+	std::string rangeToString( std::vector<bool, Allocator> const& v ) {
+		ReusableStringStream rss;
+		rss << "{ ";
+		bool first = true;
+		for( bool b : v ) {
+			if( first )
+				first = false;
+			else
+				rss << ", ";
+			rss << ::Catch::Detail::stringify( b );
+		}
+		rss << " }";
+		return rss.str();
+	}
+
+	template<typename R>
+	struct StringMaker<R, typename std::enable_if<is_range<R>::value && !::Catch::Detail::IsStreamInsertable<R>::value>::type> {
+		static std::string convert( R const& range ) {
+			return rangeToString( range );
+		}
+	};
+
+	template <typename T, int SZ>
+	struct StringMaker<T[SZ]> {
+		static std::string convert(T const(&arr)[SZ]) {
+			return rangeToString(arr);
+		}
+	};
+
+} // namespace Catch
+
+  // Separate std::chrono::duration specialization
 #if defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
 #include <ctime>
 #include <ratio>
 #include <chrono>
 
-template <class Ratio>
-struct ratio_string {
-    static std::string symbol();
-};
-
-template <class Ratio>
-std::string ratio_string<Ratio>::symbol() {
-    std::ostringstream oss;
-    oss << '[' << Ratio::num << '/'
-        << Ratio::den << ']';
-    return oss.str();
-}
-template <>
-struct ratio_string<std::atto> {
-    static std::string symbol() { return "a"; }
-};
-template <>
-struct ratio_string<std::femto> {
-    static std::string symbol() { return "f"; }
-};
-template <>
-struct ratio_string<std::pico> {
-    static std::string symbol() { return "p"; }
-};
-template <>
-struct ratio_string<std::nano> {
-    static std::string symbol() { return "n"; }
-};
-template <>
-struct ratio_string<std::micro> {
-    static std::string symbol() { return "u"; }
-};
-template <>
-struct ratio_string<std::milli> {
-    static std::string symbol() { return "m"; }
-};
-
-namespace Catch {
-    ////////////
-    // std::chrono::duration specializations
-    template<typename Value, typename Ratio>
-    struct StringMaker<std::chrono::duration<Value, Ratio>> {
-        static std::string convert(std::chrono::duration<Value, Ratio> const& duration) {
-            std::ostringstream oss;
-            oss << duration.count() << ' ' << ratio_string<Ratio>::symbol() << 's';
-            return oss.str();
-        }
-    };
-    template<typename Value>
-    struct StringMaker<std::chrono::duration<Value, std::ratio<1>>> {
-        static std::string convert(std::chrono::duration<Value, std::ratio<1>> const& duration) {
-            std::ostringstream oss;
-            oss << duration.count() << " s";
-            return oss.str();
-        }
-    };
-    template<typename Value>
-    struct StringMaker<std::chrono::duration<Value, std::ratio<60>>> {
-        static std::string convert(std::chrono::duration<Value, std::ratio<60>> const& duration) {
-            std::ostringstream oss;
-            oss << duration.count() << " m";
-            return oss.str();
-        }
-    };
-    template<typename Value>
-    struct StringMaker<std::chrono::duration<Value, std::ratio<3600>>> {
-        static std::string convert(std::chrono::duration<Value, std::ratio<3600>> const& duration) {
-            std::ostringstream oss;
-            oss << duration.count() << " h";
-            return oss.str();
-        }
-    };
-
-    ////////////
-    // std::chrono::time_point specialization
-    // Generic time_point cannot be specialized, only std::chrono::time_point<system_clock>
-    template<typename Clock, typename Duration>
-    struct StringMaker<std::chrono::time_point<Clock, Duration>> {
-        static std::string convert(std::chrono::time_point<Clock, Duration> const& time_point) {
-            return ::Catch::Detail::stringify(time_point.time_since_epoch()) + " since epoch";
-        }
-    };
-    // std::chrono::time_point<system_clock> specialization
-    template<typename Duration>
-    struct StringMaker<std::chrono::time_point<std::chrono::system_clock, Duration>> {
-        static std::string convert(std::chrono::time_point<std::chrono::system_clock, Duration> const& time_point) {
-            auto converted = std::chrono::system_clock::to_time_t(time_point);
+namespace Catch {
+
+	template <class Ratio>
+	struct ratio_string {
+		static std::string symbol();
+	};
+
+	template <class Ratio>
+	std::string ratio_string<Ratio>::symbol() {
+		Catch::ReusableStringStream rss;
+		rss << '[' << Ratio::num << '/'
+			<< Ratio::den << ']';
+		return rss.str();
+	}
+	template <>
+	struct ratio_string<std::atto> {
+		static std::string symbol();
+	};
+	template <>
+	struct ratio_string<std::femto> {
+		static std::string symbol();
+	};
+	template <>
+	struct ratio_string<std::pico> {
+		static std::string symbol();
+	};
+	template <>
+	struct ratio_string<std::nano> {
+		static std::string symbol();
+	};
+	template <>
+	struct ratio_string<std::micro> {
+		static std::string symbol();
+	};
+	template <>
+	struct ratio_string<std::milli> {
+		static std::string symbol();
+	};
+
+	////////////
+	// std::chrono::duration specializations
+	template<typename Value, typename Ratio>
+	struct StringMaker<std::chrono::duration<Value, Ratio>> {
+		static std::string convert(std::chrono::duration<Value, Ratio> const& duration) {
+			ReusableStringStream rss;
+			rss << duration.count() << ' ' << ratio_string<Ratio>::symbol() << 's';
+			return rss.str();
+		}
+	};
+	template<typename Value>
+	struct StringMaker<std::chrono::duration<Value, std::ratio<1>>> {
+		static std::string convert(std::chrono::duration<Value, std::ratio<1>> const& duration) {
+			ReusableStringStream rss;
+			rss << duration.count() << " s";
+			return rss.str();
+		}
+	};
+	template<typename Value>
+	struct StringMaker<std::chrono::duration<Value, std::ratio<60>>> {
+		static std::string convert(std::chrono::duration<Value, std::ratio<60>> const& duration) {
+			ReusableStringStream rss;
+			rss << duration.count() << " m";
+			return rss.str();
+		}
+	};
+	template<typename Value>
+	struct StringMaker<std::chrono::duration<Value, std::ratio<3600>>> {
+		static std::string convert(std::chrono::duration<Value, std::ratio<3600>> const& duration) {
+			ReusableStringStream rss;
+			rss << duration.count() << " h";
+			return rss.str();
+		}
+	};
+
+	////////////
+	// std::chrono::time_point specialization
+	// Generic time_point cannot be specialized, only std::chrono::time_point<system_clock>
+	template<typename Clock, typename Duration>
+	struct StringMaker<std::chrono::time_point<Clock, Duration>> {
+		static std::string convert(std::chrono::time_point<Clock, Duration> const& time_point) {
+			return ::Catch::Detail::stringify(time_point.time_since_epoch()) + " since epoch";
+		}
+	};
+	// std::chrono::time_point<system_clock> specialization
+	template<typename Duration>
+	struct StringMaker<std::chrono::time_point<std::chrono::system_clock, Duration>> {
+		static std::string convert(std::chrono::time_point<std::chrono::system_clock, Duration> const& time_point) {
+			auto converted = std::chrono::system_clock::to_time_t(time_point);
 
 #ifdef _MSC_VER
-            std::tm timeInfo = {};
-            gmtime_s(&timeInfo, &converted);
+			std::tm timeInfo = {};
+			gmtime_s(&timeInfo, &converted);
 #else
-            std::tm* timeInfo = std::gmtime(&converted);
+			std::tm* timeInfo = std::gmtime(&converted);
 #endif
 
-            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
-            char timeStamp[timeStampSize];
-            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
+			auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
+			char timeStamp[timeStampSize];
+			const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
 
 #ifdef _MSC_VER
-            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
+			std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
 #else
-            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
+			std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
 #endif
-            return std::string(timeStamp);
-        }
-    };
+			return std::string(timeStamp);
+		}
+	};
 }
 #endif // CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
 
@@ -972,7 +1644,7 @@ namespace Catch {
 #endif
 
 // end catch_tostring.h
-#include <ostream>
+#include <iosfwd>
 
 #ifdef _MSC_VER
 #pragma warning(push)
@@ -984,140 +1656,146 @@ namespace Catch {
 
 namespace Catch {
 
-    struct ITransientExpression {
-        virtual auto isBinaryExpression() const -> bool = 0;
-        virtual auto getResult() const -> bool = 0;
-        virtual void streamReconstructedExpression( std::ostream &os ) const = 0;
-
-        // We don't actually need a virtual destructore, but many static analysers
-        // complain if it's not here :-(
-        virtual ~ITransientExpression();
-    };
-
-    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs );
-
-    template<typename LhsT, typename RhsT>
-    class BinaryExpr  : public ITransientExpression {
-        bool m_result;
-        LhsT m_lhs;
-        StringRef m_op;
-        RhsT m_rhs;
-
-        auto isBinaryExpression() const -> bool override { return true; }
-        auto getResult() const -> bool override { return m_result; }
-
-        void streamReconstructedExpression( std::ostream &os ) const override {
-            formatReconstructedExpression
-                    ( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
-        }
-
-    public:
-        BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )
-        :   m_result( comparisonResult ),
-            m_lhs( lhs ),
-            m_op( op ),
-            m_rhs( rhs )
-        {}
-    };
-
-    template<typename LhsT>
-    class UnaryExpr : public ITransientExpression {
-        LhsT m_lhs;
-
-        auto isBinaryExpression() const -> bool override { return false; }
-        auto getResult() const -> bool override { return m_lhs ? true : false; }
-
-        void streamReconstructedExpression( std::ostream &os ) const override {
-            os << Catch::Detail::stringify( m_lhs );
-        }
-
-    public:
-        UnaryExpr( LhsT lhs ) : m_lhs( lhs ) {}
-    };
-
-    // Specialised comparison functions to handle equality comparisons between ints and pointers (NULL deduces as an int)
-    template<typename LhsT, typename RhsT>
-    auto compareEqual( LhsT const& lhs, RhsT const& rhs ) -> bool { return lhs == rhs; };
-    template<typename T>
-    auto compareEqual( T* const& lhs, int rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
-    template<typename T>
-    auto compareEqual( T* const& lhs, long rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
-    template<typename T>
-    auto compareEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
-    template<typename T>
-    auto compareEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
-
-    template<typename LhsT, typename RhsT>
-    auto compareNotEqual( LhsT const& lhs, RhsT&& rhs ) -> bool { return lhs != rhs; };
-    template<typename T>
-    auto compareNotEqual( T* const& lhs, int rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
-    template<typename T>
-    auto compareNotEqual( T* const& lhs, long rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
-    template<typename T>
-    auto compareNotEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
-    template<typename T>
-    auto compareNotEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
-
-    template<typename LhsT>
-    class ExprLhs {
-        LhsT m_lhs;
-    public:
-        ExprLhs( LhsT lhs ) : m_lhs( lhs ) {}
-
-        template<typename RhsT>
-        auto operator == ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return BinaryExpr<LhsT, RhsT const&>( compareEqual( m_lhs, rhs ), m_lhs, "==", rhs );
-        }
-        auto operator == ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
-            return BinaryExpr<LhsT, bool>( m_lhs == rhs, m_lhs, "==", rhs );
-        }
-
-        template<typename RhsT>
-        auto operator != ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return BinaryExpr<LhsT, RhsT const&>( compareNotEqual( m_lhs, rhs ), m_lhs, "!=", rhs );
-        }
-        auto operator != ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
-            return BinaryExpr<LhsT, bool>( m_lhs != rhs, m_lhs, "!=", rhs );
-        }
-
-        template<typename RhsT>
-        auto operator > ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return BinaryExpr<LhsT, RhsT const&>( m_lhs > rhs, m_lhs, ">", rhs );
-        }
-        template<typename RhsT>
-        auto operator < ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return BinaryExpr<LhsT, RhsT const&>( m_lhs < rhs, m_lhs, "<", rhs );
-        }
-        template<typename RhsT>
-        auto operator >= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return BinaryExpr<LhsT, RhsT const&>( m_lhs >= rhs, m_lhs, ">=", rhs );
-        }
-        template<typename RhsT>
-        auto operator <= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return BinaryExpr<LhsT, RhsT const&>( m_lhs <= rhs, m_lhs, "<=", rhs );
-        }
-
-        auto makeUnaryExpr() const -> UnaryExpr<LhsT> {
-            return UnaryExpr<LhsT>( m_lhs );
-        }
-    };
-
-    void handleExpression( ITransientExpression const& expr );
-
-    template<typename T>
-    void handleExpression( ExprLhs<T> const& expr ) {
-        handleExpression( expr.makeUnaryExpr() );
-    }
-
-    struct Decomposer {
-        template<typename T>
-        auto operator <= ( T const& lhs ) -> ExprLhs<T const&> {
-            return ExprLhs<T const&>( lhs );
-        }
-        auto operator <=( bool value ) -> ExprLhs<bool> {
-            return ExprLhs<bool>( value );
-        }
-    };
+	struct ITransientExpression {
+		auto isBinaryExpression() const -> bool { return m_isBinaryExpression; }
+		auto getResult() const -> bool { return m_result; }
+		virtual void streamReconstructedExpression( std::ostream &os ) const = 0;
+
+		ITransientExpression( bool isBinaryExpression, bool result )
+			:   m_isBinaryExpression( isBinaryExpression ),
+			m_result( result )
+		{}
+
+		// We don't actually need a virtual destructor, but many static analysers
+		// complain if it's not here :-(
+		virtual ~ITransientExpression();
+
+		bool m_isBinaryExpression;
+		bool m_result;
+
+	};
+
+	void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs );
+
+	template<typename LhsT, typename RhsT>
+	class BinaryExpr  : public ITransientExpression {
+		LhsT m_lhs;
+		StringRef m_op;
+		RhsT m_rhs;
+
+		void streamReconstructedExpression( std::ostream &os ) const override {
+			formatReconstructedExpression
+			( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
+		}
+
+	public:
+		BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )
+			:   ITransientExpression{ true, comparisonResult },
+			m_lhs( lhs ),
+			m_op( op ),
+			m_rhs( rhs )
+		{}
+	};
+
+	template<typename LhsT>
+	class UnaryExpr : public ITransientExpression {
+		LhsT m_lhs;
+
+		void streamReconstructedExpression( std::ostream &os ) const override {
+			os << Catch::Detail::stringify( m_lhs );
+		}
+
+	public:
+		explicit UnaryExpr( LhsT lhs )
+			:   ITransientExpression{ false, lhs ? true : false },
+			m_lhs( lhs )
+		{}
+	};
+
+	// Specialised comparison functions to handle equality comparisons between ints and pointers (NULL deduces as an int)
+	template<typename LhsT, typename RhsT>
+	auto compareEqual( LhsT const& lhs, RhsT const& rhs ) -> bool { return static_cast<bool>(lhs == rhs); }
+	template<typename T>
+	auto compareEqual( T* const& lhs, int rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
+	template<typename T>
+	auto compareEqual( T* const& lhs, long rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
+	template<typename T>
+	auto compareEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
+	template<typename T>
+	auto compareEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
+
+	template<typename LhsT, typename RhsT>
+	auto compareNotEqual( LhsT const& lhs, RhsT&& rhs ) -> bool { return static_cast<bool>(lhs != rhs); }
+	template<typename T>
+	auto compareNotEqual( T* const& lhs, int rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
+	template<typename T>
+	auto compareNotEqual( T* const& lhs, long rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
+	template<typename T>
+	auto compareNotEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
+	template<typename T>
+	auto compareNotEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
+
+	template<typename LhsT>
+	class ExprLhs {
+		LhsT m_lhs;
+	public:
+		explicit ExprLhs( LhsT lhs ) : m_lhs( lhs ) {}
+
+		template<typename RhsT>
+		auto operator == ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+			return { compareEqual( m_lhs, rhs ), m_lhs, "==", rhs };
+		}
+		auto operator == ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
+			return { m_lhs == rhs, m_lhs, "==", rhs };
+		}
+
+		template<typename RhsT>
+		auto operator != ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+			return { compareNotEqual( m_lhs, rhs ), m_lhs, "!=", rhs };
+		}
+		auto operator != ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
+			return { m_lhs != rhs, m_lhs, "!=", rhs };
+		}
+
+		template<typename RhsT>
+		auto operator > ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+			return { static_cast<bool>(m_lhs > rhs), m_lhs, ">", rhs };
+		}
+		template<typename RhsT>
+		auto operator < ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+			return { static_cast<bool>(m_lhs < rhs), m_lhs, "<", rhs };
+		}
+		template<typename RhsT>
+		auto operator >= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+			return { static_cast<bool>(m_lhs >= rhs), m_lhs, ">=", rhs };
+		}
+		template<typename RhsT>
+		auto operator <= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+			return { static_cast<bool>(m_lhs <= rhs), m_lhs, "<=", rhs };
+		}
+
+		auto makeUnaryExpr() const -> UnaryExpr<LhsT> {
+			return UnaryExpr<LhsT>{ m_lhs };
+		}
+	};
+
+	void handleExpression( ITransientExpression const& expr );
+
+	template<typename T>
+	void handleExpression( ExprLhs<T> const& expr ) {
+		handleExpression( expr.makeUnaryExpr() );
+	}
+
+	struct Decomposer {
+		template<typename T>
+		auto operator <= ( T const& lhs ) -> ExprLhs<T const&> {
+			return ExprLhs<T const&>{ lhs };
+		}
+
+		auto operator <=( bool value ) -> ExprLhs<bool> {
+			return ExprLhs<bool>{ value };
+		}
+	};
 
 } // end namespace Catch
 
@@ -1125,456 +1803,408 @@ namespace Catch {
 #pragma warning(pop)
 #endif
 
-// end catch_decomposer.h
-// start catch_assertioninfo.h
+  // end catch_decomposer.h
+  // start catch_interfaces_capture.h
 
-// start catch_result_type.h
+#include <string>
 
 namespace Catch {
 
-    // ResultWas::OfType enum
-    struct ResultWas { enum OfType {
-        Unknown = -1,
-        Ok = 0,
-        Info = 1,
-        Warning = 2,
+	class AssertionResult;
+	struct AssertionInfo;
+	struct SectionInfo;
+	struct SectionEndInfo;
+	struct MessageInfo;
+	struct Counts;
+	struct BenchmarkInfo;
+	struct BenchmarkStats;
+	struct AssertionReaction;
+	struct SourceLineInfo;
+
+	struct ITransientExpression;
+	struct IGeneratorTracker;
+
+	struct IResultCapture {
+
+		virtual ~IResultCapture();
+
+		virtual bool sectionStarted(    SectionInfo const& sectionInfo,
+			Counts& assertions ) = 0;
+		virtual void sectionEnded( SectionEndInfo const& endInfo ) = 0;
+		virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) = 0;
+
+		virtual auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& = 0;
+
+		virtual void benchmarkStarting( BenchmarkInfo const& info ) = 0;
+		virtual void benchmarkEnded( BenchmarkStats const& stats ) = 0;
+
+		virtual void pushScopedMessage( MessageInfo const& message ) = 0;
+		virtual void popScopedMessage( MessageInfo const& message ) = 0;
+
+		virtual void handleFatalErrorCondition( StringRef message ) = 0;
+
+		virtual void handleExpr
+		(   AssertionInfo const& info,
+			ITransientExpression const& expr,
+			AssertionReaction& reaction ) = 0;
+		virtual void handleMessage
+		(   AssertionInfo const& info,
+			ResultWas::OfType resultType,
+			StringRef const& message,
+			AssertionReaction& reaction ) = 0;
+		virtual void handleUnexpectedExceptionNotThrown
+		(   AssertionInfo const& info,
+			AssertionReaction& reaction ) = 0;
+		virtual void handleUnexpectedInflightException
+		(   AssertionInfo const& info,
+			std::string const& message,
+			AssertionReaction& reaction ) = 0;
+		virtual void handleIncomplete
+		(   AssertionInfo const& info ) = 0;
+		virtual void handleNonExpr
+		(   AssertionInfo const &info,
+			ResultWas::OfType resultType,
+			AssertionReaction &reaction ) = 0;
+
+		virtual bool lastAssertionPassed() = 0;
+		virtual void assertionPassed() = 0;
+
+		// Deprecated, do not use:
+		virtual std::string getCurrentTestName() const = 0;
+		virtual const AssertionResult* getLastResult() const = 0;
+		virtual void exceptionEarlyReported() = 0;
+	};
+
+	IResultCapture& getResultCapture();
+}
 
-        FailureBit = 0x10,
+// end catch_interfaces_capture.h
+namespace Catch {
 
-        ExpressionFailed = FailureBit | 1,
-        ExplicitFailure = FailureBit | 2,
+	struct TestFailureException{};
+	struct AssertionResultData;
+	struct IResultCapture;
+	class RunContext;
+
+	class LazyExpression {
+		friend class AssertionHandler;
+		friend struct AssertionStats;
+		friend class RunContext;
+
+		ITransientExpression const* m_transientExpression = nullptr;
+		bool m_isNegated;
+	public:
+		LazyExpression( bool isNegated );
+		LazyExpression( LazyExpression const& other );
+		LazyExpression& operator = ( LazyExpression const& ) = delete;
+
+		explicit operator bool() const;
+
+		friend auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream&;
+	};
+
+	struct AssertionReaction {
+		bool shouldDebugBreak = false;
+		bool shouldThrow = false;
+	};
+
+	class AssertionHandler {
+		AssertionInfo m_assertionInfo;
+		AssertionReaction m_reaction;
+		bool m_completed = false;
+		IResultCapture& m_resultCapture;
+
+	public:
+		AssertionHandler
+		(   StringRef const& macroName,
+			SourceLineInfo const& lineInfo,
+			StringRef capturedExpression,
+			ResultDisposition::Flags resultDisposition );
+		~AssertionHandler() {
+			if ( !m_completed ) {
+				m_resultCapture.handleIncomplete( m_assertionInfo );
+			}
+		}
+
+		template<typename T>
+		void handleExpr( ExprLhs<T> const& expr ) {
+			handleExpr( expr.makeUnaryExpr() );
+		}
+		void handleExpr( ITransientExpression const& expr );
+
+		void handleMessage(ResultWas::OfType resultType, StringRef const& message);
+
+		void handleExceptionThrownAsExpected();
+		void handleUnexpectedExceptionNotThrown();
+		void handleExceptionNotThrownAsExpected();
+		void handleThrowingCallSkipped();
+		void handleUnexpectedInflightException();
+
+		void complete();
+		void setCompleted();
+
+		// query
+		auto allowThrows() const -> bool;
+	};
+
+	void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString );
 
-        Exception = 0x100 | FailureBit,
+} // namespace Catch
 
-        ThrewException = Exception | 1,
-        DidntThrowException = Exception | 2,
+  // end catch_assertionhandler.h
+  // start catch_message.h
 
-        FatalErrorCondition = 0x200 | FailureBit
+#include <string>
+#include <vector>
 
-    }; };
-
-    bool isOk( ResultWas::OfType resultType );
-    bool isJustInfo( int flags );
-
-    // ResultDisposition::Flags enum
-    struct ResultDisposition { enum Flags {
-        Normal = 0x01,
-
-        ContinueOnFailure = 0x02,   // Failures fail test, but execution continues
-        FalseTest = 0x04,           // Prefix expression with !
-        SuppressFail = 0x08         // Failures are reported but do not fail the test
-    }; };
-
-    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs );
-
-    bool shouldContinueOnFailure( int flags );
-    bool isFalseTest( int flags );
-    bool shouldSuppressFailure( int flags );
-
-} // end namespace Catch
-
-// end catch_result_type.h
 namespace Catch {
 
-    struct AssertionInfo
-    {
-        StringRef macroName;
-        SourceLineInfo lineInfo;
-        StringRef capturedExpression;
-        ResultDisposition::Flags resultDisposition;
-
-        // We want to delete this constructor but a compiler bug in 4.8 means
-        // the struct is then treated as non-aggregate
-        //AssertionInfo() = delete;
-    };
-
-} // end namespace Catch
-
-// end catch_assertioninfo.h
-namespace Catch {
-
-    struct TestFailureException{};
-    struct AssertionResultData;
-
-    class LazyExpression {
-        friend class AssertionHandler;
-        friend struct AssertionStats;
-
-        ITransientExpression const* m_transientExpression = nullptr;
-        bool m_isNegated;
-    public:
-        LazyExpression( bool isNegated );
-        LazyExpression( LazyExpression const& other );
-        LazyExpression& operator = ( LazyExpression const& ) = delete;
+	struct MessageInfo {
+		MessageInfo(    StringRef const& _macroName,
+			SourceLineInfo const& _lineInfo,
+			ResultWas::OfType _type );
 
-        explicit operator bool() const;
+		StringRef macroName;
+		std::string message;
+		SourceLineInfo lineInfo;
+		ResultWas::OfType type;
+		unsigned int sequence;
 
-        friend auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream&;
-    };
+		bool operator == ( MessageInfo const& other ) const;
+		bool operator < ( MessageInfo const& other ) const;
+	private:
+		static unsigned int globalCount;
+	};
 
-    class AssertionHandler {
-        AssertionInfo m_assertionInfo;
-        bool m_shouldDebugBreak = false;
-        bool m_shouldThrow = false;
-        bool m_inExceptionGuard = false;
+	struct MessageStream {
 
-    public:
-        AssertionHandler
-            (   StringRef macroName,
-                SourceLineInfo const& lineInfo,
-                StringRef capturedExpression,
-                ResultDisposition::Flags resultDisposition );
-        ~AssertionHandler();
+		template<typename T>
+		MessageStream& operator << ( T const& value ) {
+			m_stream << value;
+			return *this;
+		}
 
-        void handle( ITransientExpression const& expr );
+		ReusableStringStream m_stream;
+	};
 
-        template<typename T>
-        void handle( ExprLhs<T> const& expr ) {
-            handle( expr.makeUnaryExpr() );
-        }
-        void handle( ResultWas::OfType resultType );
-        void handle( ResultWas::OfType resultType, StringRef const& message );
-        void handle( ResultWas::OfType resultType, ITransientExpression const* expr, bool negated );
-        void handle( AssertionResultData const& resultData, ITransientExpression const* expr );
+	struct MessageBuilder : MessageStream {
+		MessageBuilder( StringRef const& macroName,
+			SourceLineInfo const& lineInfo,
+			ResultWas::OfType type );
 
-        auto shouldDebugBreak() const -> bool;
-        auto allowThrows() const -> bool;
-        void reactWithDebugBreak() const;
-        void reactWithoutDebugBreak() const;
-        void useActiveException();
-        void setExceptionGuard();
-        void unsetExceptionGuard();
-    };
+		template<typename T>
+		MessageBuilder& operator << ( T const& value ) {
+			m_stream << value;
+			return *this;
+		}
 
-    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef matcherString );
+		MessageInfo m_info;
+	};
 
-} // namespace Catch
-
-// end catch_assertionhandler.h
-// start catch_message.h
-
-#include <string>
-#include <sstream>
-
-namespace Catch {
-
-    struct MessageInfo {
-        MessageInfo(    std::string const& _macroName,
-                        SourceLineInfo const& _lineInfo,
-                        ResultWas::OfType _type );
+	class ScopedMessage {
+	public:
+		explicit ScopedMessage( MessageBuilder const& builder );
+		~ScopedMessage();
 
-        std::string macroName;
-        std::string message;
-        SourceLineInfo lineInfo;
-        ResultWas::OfType type;
-        unsigned int sequence;
+		MessageInfo m_info;
+	};
 
-        bool operator == ( MessageInfo const& other ) const;
-        bool operator < ( MessageInfo const& other ) const;
-    private:
-        static unsigned int globalCount;
-    };
+	class Capturer {
+		std::vector<MessageInfo> m_messages;
+		IResultCapture& m_resultCapture = getResultCapture();
+		size_t m_captured = 0;
+	public:
+		Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names );
+		~Capturer();
 
-    struct MessageStream {
+		void captureValue( size_t index, std::string const& value );
 
-        template<typename T>
-        MessageStream& operator << ( T const& value ) {
-            m_stream << value;
-            return *this;
-        }
+		template<typename T>
+		void captureValues( size_t index, T const& value ) {
+			captureValue( index, Catch::Detail::stringify( value ) );
+		}
 
-        // !TBD reuse a global/ thread-local stream
-        std::ostringstream m_stream;
-    };
-
-    struct MessageBuilder : MessageStream {
-        MessageBuilder( std::string const& macroName,
-                        SourceLineInfo const& lineInfo,
-                        ResultWas::OfType type );
-
-        template<typename T>
-        MessageBuilder& operator << ( T const& value ) {
-            m_stream << value;
-            return *this;
-        }
-
-        MessageInfo m_info;
-    };
-
-    class ScopedMessage {
-    public:
-        ScopedMessage( MessageBuilder const& builder );
-        ~ScopedMessage();
-
-        MessageInfo m_info;
-    };
+		template<typename T, typename... Ts>
+		void captureValues( size_t index, T const& value, Ts const&... values ) {
+			captureValue( index, Catch::Detail::stringify(value) );
+			captureValues( index+1, values... );
+		}
+	};
 
 } // end namespace Catch
 
-// end catch_message.h
-// start catch_interfaces_capture.h
-
-#include <string>
-
-namespace Catch {
-
-    class AssertionResult;
-    struct AssertionInfo;
-    struct SectionInfo;
-    struct SectionEndInfo;
-    struct MessageInfo;
-    struct Counts;
-    struct BenchmarkInfo;
-    struct BenchmarkStats;
-
-    struct IResultCapture {
-
-        virtual ~IResultCapture();
-
-        virtual void assertionStarting( AssertionInfo const& info ) = 0;
-        virtual void assertionEnded( AssertionResult const& result ) = 0;
-        virtual bool sectionStarted(    SectionInfo const& sectionInfo,
-                                        Counts& assertions ) = 0;
-        virtual void sectionEnded( SectionEndInfo const& endInfo ) = 0;
-        virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) = 0;
-
-        virtual void benchmarkStarting( BenchmarkInfo const& info ) = 0;
-        virtual void benchmarkEnded( BenchmarkStats const& stats ) = 0;
-
-        virtual void pushScopedMessage( MessageInfo const& message ) = 0;
-        virtual void popScopedMessage( MessageInfo const& message ) = 0;
-
-        virtual std::string getCurrentTestName() const = 0;
-        virtual const AssertionResult* getLastResult() const = 0;
-
-        virtual void exceptionEarlyReported() = 0;
-
-        virtual void handleFatalErrorCondition( StringRef message ) = 0;
-
-        virtual bool lastAssertionPassed() = 0;
-        virtual void assertionPassed() = 0;
-        virtual void assertionRun() = 0;
-    };
-
-    IResultCapture& getResultCapture();
-}
-
-// end catch_interfaces_capture.h
-// start catch_debugger.h
-
-namespace Catch {
-    bool isDebuggerActive();
-}
-
-#ifdef CATCH_PLATFORM_MAC
-
-    #define CATCH_TRAP() __asm__("int $3\n" : : ) /* NOLINT */
-
-#elif defined(CATCH_PLATFORM_LINUX)
-    // If we can use inline assembler, do it because this allows us to break
-    // directly at the location of the failing check instead of breaking inside
-    // raise() called from it, i.e. one stack frame below.
-    #if defined(__GNUC__) && (defined(__i386) || defined(__x86_64))
-        #define CATCH_TRAP() asm volatile ("int $3") /* NOLINT */
-    #else // Fall back to the generic way.
-        #include <signal.h>
-
-        #define CATCH_TRAP() raise(SIGTRAP)
-    #endif
-#elif defined(_MSC_VER)
-    #define CATCH_TRAP() __debugbreak()
-#elif defined(__MINGW32__)
-    extern "C" __declspec(dllimport) void __stdcall DebugBreak();
-    #define CATCH_TRAP() DebugBreak()
-#endif
-
-#ifdef CATCH_TRAP
-    #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) { CATCH_TRAP(); }
-#else
-    #define CATCH_BREAK_INTO_DEBUGGER() Catch::alwaysTrue();
-#endif
-
-// end catch_debugger.h
+  // end catch_message.h
 #if !defined(CATCH_CONFIG_DISABLE)
 
 #if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION)
-  #define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__
+#define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__
 #else
-  #define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"
+#define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"
 #endif
 
-#if defined(CATCH_CONFIG_FAST_COMPILE)
-///////////////////////////////////////////////////////////////////////////////
-// We can speedup compilation significantly by breaking into debugger lower in
-// the callstack, because then we don't have to expand CATCH_BREAK_INTO_DEBUGGER
-// macro in each assertion
-#define INTERNAL_CATCH_REACT( handler ) \
-    handler.reactWithDebugBreak();
+#if defined(CATCH_CONFIG_FAST_COMPILE) || defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
 
-///////////////////////////////////////////////////////////////////////////////
-// Another way to speed-up compilation is to omit local try-catch for REQUIRE*
-// macros.
-// This can potentially cause false negative, if the test code catches
-// the exception before it propagates back up to the runner.
-#define INTERNAL_CATCH_TRY( capturer ) capturer.setExceptionGuard();
-#define INTERNAL_CATCH_CATCH( capturer ) capturer.unsetExceptionGuard();
+  ///////////////////////////////////////////////////////////////////////////////
+  // Another way to speed-up compilation is to omit local try-catch for REQUIRE*
+  // macros.
+#define INTERNAL_CATCH_TRY
+#define INTERNAL_CATCH_CATCH( capturer )
 
 #else // CATCH_CONFIG_FAST_COMPILE
 
-///////////////////////////////////////////////////////////////////////////////
-// In the event of a failure works out if the debugger needs to be invoked
-// and/or an exception thrown and takes appropriate action.
-// This needs to be done as a macro so the debugger will stop in the user
-// source code rather than in Catch library code
-#define INTERNAL_CATCH_REACT( handler ) \
-    if( handler.shouldDebugBreak() ) CATCH_BREAK_INTO_DEBUGGER(); \
-    handler.reactWithoutDebugBreak();
-
-#define INTERNAL_CATCH_TRY( capturer ) try
-#define INTERNAL_CATCH_CATCH( capturer ) catch(...) { capturer.useActiveException(); }
+#define INTERNAL_CATCH_TRY try
+#define INTERNAL_CATCH_CATCH( handler ) catch(...) { handler.handleUnexpectedInflightException(); }
 
 #endif
 
-///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_REACT( handler ) handler.complete();
+
+  ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_TEST( macroName, resultDisposition, ... ) \
     do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
-        INTERNAL_CATCH_TRY( catchAssertionHandler ) { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
+        INTERNAL_CATCH_TRY { \
             CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
-            catchAssertionHandler.handle( Catch::Decomposer() <= __VA_ARGS__ ); \
+            catchAssertionHandler.handleExpr( Catch::Decomposer() <= __VA_ARGS__ ); \
             CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
         } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
         INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( Catch::isTrue( false && static_cast<bool>( !!(__VA_ARGS__) ) ) ) // the expression here is never evaluated at runtime but it forces the compiler to give it a look
-    // The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&.
+    } while( (void)0, false && static_cast<bool>( !!(__VA_ARGS__) ) ) // the expression here is never evaluated at runtime but it forces the compiler to give it a look
+  // The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&.
 
-///////////////////////////////////////////////////////////////////////////////
+  ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_IF( macroName, resultDisposition, ... ) \
     INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
     if( Catch::getResultCapture().lastAssertionPassed() )
 
-///////////////////////////////////////////////////////////////////////////////
+  ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_ELSE( macroName, resultDisposition, ... ) \
     INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
     if( !Catch::getResultCapture().lastAssertionPassed() )
 
-///////////////////////////////////////////////////////////////////////////////
+  ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, ... ) \
     do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
         try { \
             static_cast<void>(__VA_ARGS__); \
-            catchAssertionHandler.handle( Catch::ResultWas::Ok ); \
+            catchAssertionHandler.handleExceptionNotThrownAsExpected(); \
         } \
         catch( ... ) { \
-            catchAssertionHandler.useActiveException(); \
+            catchAssertionHandler.handleUnexpectedInflightException(); \
         } \
         INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( Catch::alwaysFalse() )
+    } while( false )
 
-///////////////////////////////////////////////////////////////////////////////
+  ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_THROWS( macroName, resultDisposition, ... ) \
     do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition); \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition); \
         if( catchAssertionHandler.allowThrows() ) \
             try { \
                 static_cast<void>(__VA_ARGS__); \
-                catchAssertionHandler.handle( Catch::ResultWas::DidntThrowException ); \
+                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
             } \
             catch( ... ) { \
-                catchAssertionHandler.handle( Catch::ResultWas::Ok ); \
+                catchAssertionHandler.handleExceptionThrownAsExpected(); \
             } \
         else \
-            catchAssertionHandler.handle( Catch::ResultWas::Ok ); \
+            catchAssertionHandler.handleThrowingCallSkipped(); \
         INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( Catch::alwaysFalse() )
+    } while( false )
 
-///////////////////////////////////////////////////////////////////////////////
+  ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \
     do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
         if( catchAssertionHandler.allowThrows() ) \
             try { \
                 static_cast<void>(expr); \
-                catchAssertionHandler.handle( Catch::ResultWas::DidntThrowException ); \
+                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
             } \
             catch( exceptionType const& ) { \
-                catchAssertionHandler.handle( Catch::ResultWas::Ok ); \
+                catchAssertionHandler.handleExceptionThrownAsExpected(); \
             } \
             catch( ... ) { \
-                catchAssertionHandler.useActiveException(); \
+                catchAssertionHandler.handleUnexpectedInflightException(); \
             } \
         else \
-            catchAssertionHandler.handle( Catch::ResultWas::Ok ); \
+            catchAssertionHandler.handleThrowingCallSkipped(); \
         INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( Catch::alwaysFalse() )
+    } while( false )
 
-///////////////////////////////////////////////////////////////////////////////
+  ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \
     do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \
-        catchAssertionHandler.handle( messageType, ( Catch::MessageStream() << __VA_ARGS__ + ::Catch::StreamEndStop() ).m_stream.str() ); \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::StringRef(), resultDisposition ); \
+        catchAssertionHandler.handleMessage( messageType, ( Catch::MessageStream() << __VA_ARGS__ + ::Catch::StreamEndStop() ).m_stream.str() ); \
         INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( Catch::alwaysFalse() )
+    } while( false )
 
-///////////////////////////////////////////////////////////////////////////////
+  ///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_CAPTURE( varName, macroName, ... ) \
+    auto varName = Catch::Capturer( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info, #__VA_ARGS__ ); \
+    varName.captureValues( 0, __VA_ARGS__ )
+
+  ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_INFO( macroName, log ) \
-    Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage ) = Catch::MessageBuilder( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log;
+    Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log );
 
-///////////////////////////////////////////////////////////////////////////////
-// Although this is matcher-based, it can be used with just a string
+  ///////////////////////////////////////////////////////////////////////////////
+  // Although this is matcher-based, it can be used with just a string
 #define INTERNAL_CATCH_THROWS_STR_MATCHES( macroName, resultDisposition, matcher, ... ) \
     do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
         if( catchAssertionHandler.allowThrows() ) \
             try { \
                 static_cast<void>(__VA_ARGS__); \
-                catchAssertionHandler.handle( Catch::ResultWas::DidntThrowException ); \
+                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
             } \
             catch( ... ) { \
-                handleExceptionMatchExpr( catchAssertionHandler, matcher, #matcher ); \
+                Catch::handleExceptionMatchExpr( catchAssertionHandler, matcher, #matcher##_catch_sr ); \
             } \
         else \
-            catchAssertionHandler.handle( Catch::ResultWas::Ok ); \
+            catchAssertionHandler.handleThrowingCallSkipped(); \
         INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( Catch::alwaysFalse() )
+    } while( false )
 
 #endif // CATCH_CONFIG_DISABLE
 
-// end catch_capture.hpp
-// start catch_section.h
+  // end catch_capture.hpp
+  // start catch_section.h
 
-// start catch_section_info.h
+  // start catch_section_info.h
 
-// start catch_totals.h
+  // start catch_totals.h
 
 #include <cstddef>
 
 namespace Catch {
 
-    struct Counts {
-        Counts operator - ( Counts const& other ) const;
-        Counts& operator += ( Counts const& other );
+	struct Counts {
+		Counts operator - ( Counts const& other ) const;
+		Counts& operator += ( Counts const& other );
 
-        std::size_t total() const;
-        bool allPassed() const;
-        bool allOk() const;
+		std::size_t total() const;
+		bool allPassed() const;
+		bool allOk() const;
 
-        std::size_t passed = 0;
-        std::size_t failed = 0;
-        std::size_t failedButOk = 0;
-    };
+		std::size_t passed = 0;
+		std::size_t failed = 0;
+		std::size_t failedButOk = 0;
+	};
 
-    struct Totals {
+	struct Totals {
 
-        Totals operator - ( Totals const& other ) const;
-        Totals& operator += ( Totals const& other );
+		Totals operator - ( Totals const& other ) const;
+		Totals& operator += ( Totals const& other );
 
-        Totals delta( Totals const& prevTotals ) const;
+		Totals delta( Totals const& prevTotals ) const;
 
-        Counts assertions;
-        Counts testCases;
-    };
+		int error = 0;
+		Counts assertions;
+		Counts testCases;
+	};
 }
 
 // end catch_totals.h
@@ -1582,175 +2212,185 @@ namespace Catch {
 
 namespace Catch {
 
-    struct SectionInfo {
-        SectionInfo
-            (   SourceLineInfo const& _lineInfo,
-                std::string const& _name,
-                std::string const& _description = std::string() );
+	struct SectionInfo {
+		SectionInfo
+		(   SourceLineInfo const& _lineInfo,
+			std::string const& _name );
 
-        std::string name;
-        std::string description;
-        SourceLineInfo lineInfo;
-    };
+		// Deprecated
+		SectionInfo
+		(   SourceLineInfo const& _lineInfo,
+			std::string const& _name,
+			std::string const& ) : SectionInfo( _lineInfo, _name ) {}
 
-    struct SectionEndInfo {
-        SectionEndInfo( SectionInfo const& _sectionInfo, Counts const& _prevAssertions, double _durationInSeconds );
+		std::string name;
+		std::string description; // !Deprecated: this will always be empty
+		SourceLineInfo lineInfo;
+	};
 
-        SectionInfo sectionInfo;
-        Counts prevAssertions;
-        double durationInSeconds;
-    };
+	struct SectionEndInfo {
+		SectionInfo sectionInfo;
+		Counts prevAssertions;
+		double durationInSeconds;
+	};
 
 } // end namespace Catch
 
-// end catch_section_info.h
-// start catch_timer.h
+  // end catch_section_info.h
+  // start catch_timer.h
 
 #include <cstdint>
 
 namespace Catch {
 
-    auto getCurrentNanosecondsSinceEpoch() -> uint64_t;
-    auto getEstimatedClockResolution() -> uint64_t;
+	auto getCurrentNanosecondsSinceEpoch() -> uint64_t;
+	auto getEstimatedClockResolution() -> uint64_t;
 
-    class Timer {
-        uint64_t m_nanoseconds = 0;
-    public:
-        void start();
-        auto getElapsedNanoseconds() const -> unsigned int;
-        auto getElapsedMicroseconds() const -> unsigned int;
-        auto getElapsedMilliseconds() const -> unsigned int;
-        auto getElapsedSeconds() const -> double;
-    };
+	class Timer {
+		uint64_t m_nanoseconds = 0;
+	public:
+		void start();
+		auto getElapsedNanoseconds() const -> uint64_t;
+		auto getElapsedMicroseconds() const -> uint64_t;
+		auto getElapsedMilliseconds() const -> unsigned int;
+		auto getElapsedSeconds() const -> double;
+	};
 
 } // namespace Catch
 
-// end catch_timer.h
+  // end catch_timer.h
 #include <string>
 
 namespace Catch {
 
-    class Section : NonCopyable {
-    public:
-        Section( SectionInfo const& info );
-        ~Section();
+	class Section : NonCopyable {
+	public:
+		Section( SectionInfo const& info );
+		~Section();
 
-        // This indicates whether the section should be executed or not
-        explicit operator bool() const;
+		// This indicates whether the section should be executed or not
+		explicit operator bool() const;
 
-    private:
-        SectionInfo m_info;
+	private:
+		SectionInfo m_info;
 
-        std::string m_name;
-        Counts m_assertions;
-        bool m_sectionIncluded;
-        Timer m_timer;
-    };
+		std::string m_name;
+		Counts m_assertions;
+		bool m_sectionIncluded;
+		Timer m_timer;
+	};
 
 } // end namespace Catch
 
-    #define INTERNAL_CATCH_SECTION( ... ) \
-        if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) )
+#define INTERNAL_CATCH_SECTION( ... ) \
+    CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
+    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) \
+    CATCH_INTERNAL_UNSUPPRESS_UNUSED_WARNINGS
 
-// end catch_section.h
-// start catch_benchmark.h
+#define INTERNAL_CATCH_DYNAMIC_SECTION( ... ) \
+    CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
+    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, (Catch::ReusableStringStream() << __VA_ARGS__).str() ) ) \
+    CATCH_INTERNAL_UNSUPPRESS_UNUSED_WARNINGS
+
+  // end catch_section.h
+  // start catch_benchmark.h
 
 #include <cstdint>
 #include <string>
 
 namespace Catch {
 
-    class BenchmarkLooper {
+	class BenchmarkLooper {
 
-        std::string m_name;
-        std::size_t m_count = 0;
-        std::size_t m_iterationsToRun = 1;
-        uint64_t m_resolution;
-        Timer m_timer;
+		std::string m_name;
+		std::size_t m_count = 0;
+		std::size_t m_iterationsToRun = 1;
+		uint64_t m_resolution;
+		Timer m_timer;
 
-        static auto getResolution() -> uint64_t;
-    public:
-        // Keep most of this inline as it's on the code path that is being timed
-        BenchmarkLooper( StringRef name )
-        :   m_name( name ),
-            m_resolution( getResolution() )
-        {
-            reportStart();
-            m_timer.start();
-        }
+		static auto getResolution() -> uint64_t;
+	public:
+		// Keep most of this inline as it's on the code path that is being timed
+		BenchmarkLooper( StringRef name )
+			:   m_name( name ),
+			m_resolution( getResolution() )
+		{
+			reportStart();
+			m_timer.start();
+		}
 
-        explicit operator bool() {
-            if( m_count < m_iterationsToRun )
-                return true;
-            return needsMoreIterations();
-        }
+		explicit operator bool() {
+			if( m_count < m_iterationsToRun )
+				return true;
+			return needsMoreIterations();
+		}
 
-        void increment() {
-            ++m_count;
-        }
+		void increment() {
+			++m_count;
+		}
 
-        void reportStart();
-        auto needsMoreIterations() -> bool;
-    };
+		void reportStart();
+		auto needsMoreIterations() -> bool;
+	};
 
 } // end namespace Catch
 
 #define BENCHMARK( name ) \
     for( Catch::BenchmarkLooper looper( name ); looper; looper.increment() )
 
-// end catch_benchmark.h
-// start catch_interfaces_exception.h
+  // end catch_benchmark.h
+  // start catch_interfaces_exception.h
 
-// start catch_interfaces_registry_hub.h
+  // start catch_interfaces_registry_hub.h
 
 #include <string>
 #include <memory>
 
 namespace Catch {
 
-    class TestCase;
-    struct ITestCaseRegistry;
-    struct IExceptionTranslatorRegistry;
-    struct IExceptionTranslator;
-    struct IReporterRegistry;
-    struct IReporterFactory;
-    struct ITagAliasRegistry;
-    class StartupExceptionRegistry;
+	class TestCase;
+	struct ITestCaseRegistry;
+	struct IExceptionTranslatorRegistry;
+	struct IExceptionTranslator;
+	struct IReporterRegistry;
+	struct IReporterFactory;
+	struct ITagAliasRegistry;
+	class StartupExceptionRegistry;
 
-    using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
+	using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
 
-    struct IRegistryHub {
-        virtual ~IRegistryHub();
+	struct IRegistryHub {
+		virtual ~IRegistryHub();
 
-        virtual IReporterRegistry const& getReporterRegistry() const = 0;
-        virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
-        virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0;
+		virtual IReporterRegistry const& getReporterRegistry() const = 0;
+		virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
+		virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0;
 
-        virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() = 0;
+		virtual IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const = 0;
 
-        virtual StartupExceptionRegistry const& getStartupExceptionRegistry() const = 0;
-    };
+		virtual StartupExceptionRegistry const& getStartupExceptionRegistry() const = 0;
+	};
 
-    struct IMutableRegistryHub {
-        virtual ~IMutableRegistryHub();
-        virtual void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) = 0;
-        virtual void registerListener( IReporterFactoryPtr const& factory ) = 0;
-        virtual void registerTest( TestCase const& testInfo ) = 0;
-        virtual void registerTranslator( const IExceptionTranslator* translator ) = 0;
-        virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) = 0;
-        virtual void registerStartupException() noexcept = 0;
-    };
+	struct IMutableRegistryHub {
+		virtual ~IMutableRegistryHub();
+		virtual void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) = 0;
+		virtual void registerListener( IReporterFactoryPtr const& factory ) = 0;
+		virtual void registerTest( TestCase const& testInfo ) = 0;
+		virtual void registerTranslator( const IExceptionTranslator* translator ) = 0;
+		virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) = 0;
+		virtual void registerStartupException() noexcept = 0;
+	};
 
-    IRegistryHub& getRegistryHub();
-    IMutableRegistryHub& getMutableRegistryHub();
-    void cleanUp();
-    std::string translateActiveException();
+	IRegistryHub const& getRegistryHub();
+	IMutableRegistryHub& getMutableRegistryHub();
+	void cleanUp();
+	std::string translateActiveException();
 
 }
 
 // end catch_interfaces_registry_hub.h
 #if defined(CATCH_CONFIG_DISABLE)
-    #define INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( translatorName, signature) \
+#define INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( translatorName, signature) \
         static std::string translatorName( signature )
 #endif
 
@@ -1759,60 +2399,62 @@ namespace Catch {
 #include <vector>
 
 namespace Catch {
-    using exceptionTranslateFunction = std::string(*)();
-
-    struct IExceptionTranslator;
-    using ExceptionTranslators = std::vector<std::unique_ptr<IExceptionTranslator const>>;
-
-    struct IExceptionTranslator {
-        virtual ~IExceptionTranslator();
-        virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const = 0;
-    };
-
-    struct IExceptionTranslatorRegistry {
-        virtual ~IExceptionTranslatorRegistry();
-
-        virtual std::string translateActiveException() const = 0;
-    };
-
-    class ExceptionTranslatorRegistrar {
-        template<typename T>
-        class ExceptionTranslator : public IExceptionTranslator {
-        public:
-
-            ExceptionTranslator( std::string(*translateFunction)( T& ) )
-            : m_translateFunction( translateFunction )
-            {}
-
-            std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const override {
-                try {
-                    if( it == itEnd )
-                        std::rethrow_exception(std::current_exception());
-                    else
-                        return (*it)->translate( it+1, itEnd );
-                }
-                catch( T& ex ) {
-                    return m_translateFunction( ex );
-                }
-            }
-
-        protected:
-            std::string(*m_translateFunction)( T& );
-        };
-
-    public:
-        template<typename T>
-        ExceptionTranslatorRegistrar( std::string(*translateFunction)( T& ) ) {
-            getMutableRegistryHub().registerTranslator
-                ( new ExceptionTranslator<T>( translateFunction ) );
-        }
-    };
+	using exceptionTranslateFunction = std::string(*)();
+
+	struct IExceptionTranslator;
+	using ExceptionTranslators = std::vector<std::unique_ptr<IExceptionTranslator const>>;
+
+	struct IExceptionTranslator {
+		virtual ~IExceptionTranslator();
+		virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const = 0;
+	};
+
+	struct IExceptionTranslatorRegistry {
+		virtual ~IExceptionTranslatorRegistry();
+
+		virtual std::string translateActiveException() const = 0;
+	};
+
+	class ExceptionTranslatorRegistrar {
+		template<typename T>
+		class ExceptionTranslator : public IExceptionTranslator {
+		public:
+
+			ExceptionTranslator( std::string(*translateFunction)( T& ) )
+				: m_translateFunction( translateFunction )
+			{}
+
+			std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const override {
+				try {
+					if( it == itEnd )
+						std::rethrow_exception(std::current_exception());
+					else
+						return (*it)->translate( it+1, itEnd );
+				}
+				catch( T& ex ) {
+					return m_translateFunction( ex );
+				}
+			}
+
+		protected:
+			std::string(*m_translateFunction)( T& );
+		};
+
+	public:
+		template<typename T>
+		ExceptionTranslatorRegistrar( std::string(*translateFunction)( T& ) ) {
+			getMutableRegistryHub().registerTranslator
+			( new ExceptionTranslator<T>( translateFunction ) );
+		}
+	};
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_TRANSLATE_EXCEPTION2( translatorName, signature ) \
     static std::string translatorName( signature ); \
-    namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &translatorName ); }\
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+    namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &translatorName ); } \
+    CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \
     static std::string translatorName( signature )
 
 #define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION2( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
@@ -1820,158 +2462,150 @@ namespace Catch {
 // end catch_interfaces_exception.h
 // start catch_approx.h
 
-// start catch_enforce.h
-
-#include <sstream>
-#include <stdexcept>
-
-#define CATCH_PREPARE_EXCEPTION( type, msg ) \
-    type( static_cast<std::ostringstream&&>( std::ostringstream() << msg ).str() )
-#define CATCH_INTERNAL_ERROR( msg ) \
-    throw CATCH_PREPARE_EXCEPTION( std::logic_error, CATCH_INTERNAL_LINEINFO << ": Internal Catch error: " << msg);
-#define CATCH_ERROR( msg ) \
-    throw CATCH_PREPARE_EXCEPTION( std::domain_error, msg )
-#define CATCH_ENFORCE( condition, msg ) \
-    do{ if( !(condition) ) CATCH_ERROR( msg ); } while(false)
-
-// end catch_enforce.h
 #include <type_traits>
 
 namespace Catch {
-namespace Detail {
-
-    class Approx {
-    private:
-        bool equalityComparisonImpl(double other) const;
-
-    public:
-        explicit Approx ( double value );
-
-        static Approx custom();
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx operator()( T const& value ) {
-            Approx approx( static_cast<double>(value) );
-            approx.epsilon( m_epsilon );
-            approx.margin( m_margin );
-            approx.scale( m_scale );
-            return approx;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        explicit Approx( T const& value ): Approx(static_cast<double>(value))
-        {}
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator == ( const T& lhs, Approx const& rhs ) {
-            auto lhs_v = static_cast<double>(lhs);
-            return rhs.equalityComparisonImpl(lhs_v);
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator == ( Approx const& lhs, const T& rhs ) {
-            return operator==( rhs, lhs );
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator != ( T const& lhs, Approx const& rhs ) {
-            return !operator==( lhs, rhs );
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator != ( Approx const& lhs, T const& rhs ) {
-            return !operator==( rhs, lhs );
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator <= ( T const& lhs, Approx const& rhs ) {
-            return static_cast<double>(lhs) < rhs.m_value || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator <= ( Approx const& lhs, T const& rhs ) {
-            return lhs.m_value < static_cast<double>(rhs) || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator >= ( T const& lhs, Approx const& rhs ) {
-            return static_cast<double>(lhs) > rhs.m_value || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator >= ( Approx const& lhs, T const& rhs ) {
-            return lhs.m_value > static_cast<double>(rhs) || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx& epsilon( T const& newEpsilon ) {
-            double epsilonAsDouble = static_cast<double>(newEpsilon);
-            CATCH_ENFORCE(epsilonAsDouble >= 0 && epsilonAsDouble <= 1.0,
-                          "Invalid Approx::epsilon: " << epsilonAsDouble
-                          << ", Approx::epsilon has to be between 0 and 1");
-            m_epsilon = epsilonAsDouble;
-            return *this;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx& margin( T const& newMargin ) {
-            double marginAsDouble = static_cast<double>(newMargin);
-            CATCH_ENFORCE(marginAsDouble >= 0,
-                          "Invalid Approx::margin: " << marginAsDouble
-                          << ", Approx::Margin has to be non-negative.");
-            m_margin = marginAsDouble;
-            return *this;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx& scale( T const& newScale ) {
-            m_scale = static_cast<double>(newScale);
-            return *this;
-        }
-
-        std::string toString() const;
-
-    private:
-        double m_epsilon;
-        double m_margin;
-        double m_scale;
-        double m_value;
-    };
-}
-
-template<>
-struct StringMaker<Catch::Detail::Approx> {
-    static std::string convert(Catch::Detail::Approx const& value);
-};
+	namespace Detail {
+
+		class Approx {
+		private:
+			bool equalityComparisonImpl(double other) const;
+			// Validates the new margin (margin >= 0)
+			// out-of-line to avoid including stdexcept in the header
+			void setMargin(double margin);
+			// Validates the new epsilon (0 < epsilon < 1)
+			// out-of-line to avoid including stdexcept in the header
+			void setEpsilon(double epsilon);
+
+		public:
+			explicit Approx ( double value );
+
+			static Approx custom();
+
+			Approx operator-() const;
+
+			template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+			Approx operator()( T const& value ) {
+				Approx approx( static_cast<double>(value) );
+				approx.m_epsilon = m_epsilon;
+				approx.m_margin = m_margin;
+				approx.m_scale = m_scale;
+				return approx;
+			}
+
+			template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+			explicit Approx( T const& value ): Approx(static_cast<double>(value))
+			{}
+
+			template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+			friend bool operator == ( const T& lhs, Approx const& rhs ) {
+				auto lhs_v = static_cast<double>(lhs);
+				return rhs.equalityComparisonImpl(lhs_v);
+			}
+
+			template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+			friend bool operator == ( Approx const& lhs, const T& rhs ) {
+				return operator==( rhs, lhs );
+			}
+
+			template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+			friend bool operator != ( T const& lhs, Approx const& rhs ) {
+				return !operator==( lhs, rhs );
+			}
+
+			template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+			friend bool operator != ( Approx const& lhs, T const& rhs ) {
+				return !operator==( rhs, lhs );
+			}
+
+			template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+			friend bool operator <= ( T const& lhs, Approx const& rhs ) {
+				return static_cast<double>(lhs) < rhs.m_value || lhs == rhs;
+			}
+
+			template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+			friend bool operator <= ( Approx const& lhs, T const& rhs ) {
+				return lhs.m_value < static_cast<double>(rhs) || lhs == rhs;
+			}
+
+			template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+			friend bool operator >= ( T const& lhs, Approx const& rhs ) {
+				return static_cast<double>(lhs) > rhs.m_value || lhs == rhs;
+			}
+
+			template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+			friend bool operator >= ( Approx const& lhs, T const& rhs ) {
+				return lhs.m_value > static_cast<double>(rhs) || lhs == rhs;
+			}
+
+			template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+			Approx& epsilon( T const& newEpsilon ) {
+				double epsilonAsDouble = static_cast<double>(newEpsilon);
+				setEpsilon(epsilonAsDouble);
+				return *this;
+			}
+
+			template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+			Approx& margin( T const& newMargin ) {
+				double marginAsDouble = static_cast<double>(newMargin);
+				setMargin(marginAsDouble);
+				return *this;
+			}
+
+			template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+			Approx& scale( T const& newScale ) {
+				m_scale = static_cast<double>(newScale);
+				return *this;
+			}
+
+			std::string toString() const;
+
+		private:
+			double m_epsilon;
+			double m_margin;
+			double m_scale;
+			double m_value;
+		};
+	} // end namespace Detail
+
+	namespace literals {
+		Detail::Approx operator "" _a(long double val);
+		Detail::Approx operator "" _a(unsigned long long val);
+	} // end namespace literals
+
+	template<>
+	struct StringMaker<Catch::Detail::Approx> {
+		static std::string convert(Catch::Detail::Approx const& value);
+	};
 
 } // end namespace Catch
 
-// end catch_approx.h
-// start catch_string_manip.h
+  // end catch_approx.h
+  // start catch_string_manip.h
 
 #include <string>
 #include <iosfwd>
 
 namespace Catch {
 
-    bool startsWith( std::string const& s, std::string const& prefix );
-    bool startsWith( std::string const& s, char prefix );
-    bool endsWith( std::string const& s, std::string const& suffix );
-    bool endsWith( std::string const& s, char suffix );
-    bool contains( std::string const& s, std::string const& infix );
-    void toLowerInPlace( std::string& s );
-    std::string toLower( std::string const& s );
-    std::string trim( std::string const& str );
-    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );
+	bool startsWith( std::string const& s, std::string const& prefix );
+	bool startsWith( std::string const& s, char prefix );
+	bool endsWith( std::string const& s, std::string const& suffix );
+	bool endsWith( std::string const& s, char suffix );
+	bool contains( std::string const& s, std::string const& infix );
+	void toLowerInPlace( std::string& s );
+	std::string toLower( std::string const& s );
+	std::string trim( std::string const& str );
+	bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );
 
-    struct pluralise {
-        pluralise( std::size_t count, std::string const& label );
+	struct pluralise {
+		pluralise( std::size_t count, std::string const& label );
 
-        friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser );
+		friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser );
 
-        std::size_t m_count;
-        std::string m_label;
-    };
+		std::size_t m_count;
+		std::string m_label;
+	};
 }
 
 // end catch_string_manip.h
@@ -1984,386 +2618,855 @@ namespace Catch {
 #include <vector>
 
 namespace Catch {
-namespace Matchers {
-    namespace Impl {
-
-        template<typename ArgT> struct MatchAllOf;
-        template<typename ArgT> struct MatchAnyOf;
-        template<typename ArgT> struct MatchNotOf;
-
-        class MatcherUntypedBase {
-        public:
-            MatcherUntypedBase() = default;
-            MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
-            MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = delete;
-            std::string toString() const;
-
-        protected:
-            virtual ~MatcherUntypedBase();
-            virtual std::string describe() const = 0;
-            mutable std::string m_cachedToString;
-        };
-
-        template<typename ObjectT>
-        struct MatcherMethod {
-            virtual bool match( ObjectT const& arg ) const = 0;
-        };
-        template<typename PtrT>
-        struct MatcherMethod<PtrT*> {
-            virtual bool match( PtrT* arg ) const = 0;
-        };
-
-        template<typename ObjectT, typename ComparatorT = ObjectT>
-        struct MatcherBase : MatcherUntypedBase, MatcherMethod<ObjectT> {
-
-            MatchAllOf<ComparatorT> operator && ( MatcherBase const& other ) const;
-            MatchAnyOf<ComparatorT> operator || ( MatcherBase const& other ) const;
-            MatchNotOf<ComparatorT> operator ! () const;
-        };
-
-        template<typename ArgT>
-        struct MatchAllOf : MatcherBase<ArgT> {
-            bool match( ArgT const& arg ) const override {
-                for( auto matcher : m_matchers ) {
-                    if (!matcher->match(arg))
-                        return false;
-                }
-                return true;
-            }
-            std::string describe() const override {
-                std::string description;
-                description.reserve( 4 + m_matchers.size()*32 );
-                description += "( ";
-                bool first = true;
-                for( auto matcher : m_matchers ) {
-                    if( first )
-                        first = false;
-                    else
-                        description += " and ";
-                    description += matcher->toString();
-                }
-                description += " )";
-                return description;
-            }
-
-            MatchAllOf<ArgT>& operator && ( MatcherBase<ArgT> const& other ) {
-                m_matchers.push_back( &other );
-                return *this;
-            }
-
-            std::vector<MatcherBase<ArgT> const*> m_matchers;
-        };
-        template<typename ArgT>
-        struct MatchAnyOf : MatcherBase<ArgT> {
-
-            bool match( ArgT const& arg ) const override {
-                for( auto matcher : m_matchers ) {
-                    if (matcher->match(arg))
-                        return true;
-                }
-                return false;
-            }
-            std::string describe() const override {
-                std::string description;
-                description.reserve( 4 + m_matchers.size()*32 );
-                description += "( ";
-                bool first = true;
-                for( auto matcher : m_matchers ) {
-                    if( first )
-                        first = false;
-                    else
-                        description += " or ";
-                    description += matcher->toString();
-                }
-                description += " )";
-                return description;
-            }
-
-            MatchAnyOf<ArgT>& operator || ( MatcherBase<ArgT> const& other ) {
-                m_matchers.push_back( &other );
-                return *this;
-            }
-
-            std::vector<MatcherBase<ArgT> const*> m_matchers;
-        };
-
-        template<typename ArgT>
-        struct MatchNotOf : MatcherBase<ArgT> {
-
-            MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_underlyingMatcher( underlyingMatcher ) {}
-
-            bool match( ArgT const& arg ) const override {
-                return !m_underlyingMatcher.match( arg );
-            }
-
-            std::string describe() const override {
-                return "not " + m_underlyingMatcher.toString();
-            }
-            MatcherBase<ArgT> const& m_underlyingMatcher;
-        };
-
-        template<typename ObjectT, typename ComparatorT>
-        MatchAllOf<ComparatorT> MatcherBase<ObjectT, ComparatorT>::operator && ( MatcherBase const& other ) const {
-            return MatchAllOf<ComparatorT>() && *this && other;
-        }
-        template<typename ObjectT, typename ComparatorT>
-        MatchAnyOf<ComparatorT> MatcherBase<ObjectT, ComparatorT>::operator || ( MatcherBase const& other ) const {
-            return MatchAnyOf<ComparatorT>() || *this || other;
-        }
-        template<typename ObjectT, typename ComparatorT>
-        MatchNotOf<ComparatorT> MatcherBase<ObjectT, ComparatorT>::operator ! () const {
-            return MatchNotOf<ComparatorT>( *this );
-        }
-
-    } // namespace Impl
-
-} // namespace Matchers
-
-using namespace Matchers;
-using Matchers::Impl::MatcherBase;
+	namespace Matchers {
+		namespace Impl {
+
+			template<typename ArgT> struct MatchAllOf;
+			template<typename ArgT> struct MatchAnyOf;
+			template<typename ArgT> struct MatchNotOf;
+
+			class MatcherUntypedBase {
+			public:
+				MatcherUntypedBase() = default;
+				MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
+				MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = delete;
+				std::string toString() const;
+
+			protected:
+				virtual ~MatcherUntypedBase();
+				virtual std::string describe() const = 0;
+				mutable std::string m_cachedToString;
+			};
+
+#ifdef __clang__
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wnon-virtual-dtor"
+#endif
+
+			template<typename ObjectT>
+			struct MatcherMethod {
+				virtual bool match( ObjectT const& arg ) const = 0;
+			};
+
+#ifdef __clang__
+#    pragma clang diagnostic pop
+#endif
+
+			template<typename T>
+			struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
+
+				MatchAllOf<T> operator && ( MatcherBase const& other ) const;
+				MatchAnyOf<T> operator || ( MatcherBase const& other ) const;
+				MatchNotOf<T> operator ! () const;
+			};
+
+			template<typename ArgT>
+			struct MatchAllOf : MatcherBase<ArgT> {
+				bool match( ArgT const& arg ) const override {
+					for( auto matcher : m_matchers ) {
+						if (!matcher->match(arg))
+							return false;
+					}
+					return true;
+				}
+				std::string describe() const override {
+					std::string description;
+					description.reserve( 4 + m_matchers.size()*32 );
+					description += "( ";
+					bool first = true;
+					for( auto matcher : m_matchers ) {
+						if( first )
+							first = false;
+						else
+							description += " and ";
+						description += matcher->toString();
+					}
+					description += " )";
+					return description;
+				}
+
+				MatchAllOf<ArgT>& operator && ( MatcherBase<ArgT> const& other ) {
+					m_matchers.push_back( &other );
+					return *this;
+				}
+
+				std::vector<MatcherBase<ArgT> const*> m_matchers;
+			};
+			template<typename ArgT>
+			struct MatchAnyOf : MatcherBase<ArgT> {
+
+				bool match( ArgT const& arg ) const override {
+					for( auto matcher : m_matchers ) {
+						if (matcher->match(arg))
+							return true;
+					}
+					return false;
+				}
+				std::string describe() const override {
+					std::string description;
+					description.reserve( 4 + m_matchers.size()*32 );
+					description += "( ";
+					bool first = true;
+					for( auto matcher : m_matchers ) {
+						if( first )
+							first = false;
+						else
+							description += " or ";
+						description += matcher->toString();
+					}
+					description += " )";
+					return description;
+				}
+
+				MatchAnyOf<ArgT>& operator || ( MatcherBase<ArgT> const& other ) {
+					m_matchers.push_back( &other );
+					return *this;
+				}
+
+				std::vector<MatcherBase<ArgT> const*> m_matchers;
+			};
+
+			template<typename ArgT>
+			struct MatchNotOf : MatcherBase<ArgT> {
+
+				MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_underlyingMatcher( underlyingMatcher ) {}
+
+				bool match( ArgT const& arg ) const override {
+					return !m_underlyingMatcher.match( arg );
+				}
+
+				std::string describe() const override {
+					return "not " + m_underlyingMatcher.toString();
+				}
+				MatcherBase<ArgT> const& m_underlyingMatcher;
+			};
+
+			template<typename T>
+			MatchAllOf<T> MatcherBase<T>::operator && ( MatcherBase const& other ) const {
+				return MatchAllOf<T>() && *this && other;
+			}
+			template<typename T>
+			MatchAnyOf<T> MatcherBase<T>::operator || ( MatcherBase const& other ) const {
+				return MatchAnyOf<T>() || *this || other;
+			}
+			template<typename T>
+			MatchNotOf<T> MatcherBase<T>::operator ! () const {
+				return MatchNotOf<T>( *this );
+			}
+
+		} // namespace Impl
+
+	} // namespace Matchers
+
+	using namespace Matchers;
+	using Matchers::Impl::MatcherBase;
+
+} // namespace Catch
+
+  // end catch_matchers.h
+  // start catch_matchers_floating.h
+
+#include <type_traits>
+#include <cmath>
+
+namespace Catch {
+	namespace Matchers {
+
+		namespace Floating {
+
+			enum class FloatingPointKind : uint8_t;
+
+			struct WithinAbsMatcher : MatcherBase<double> {
+				WithinAbsMatcher(double target, double margin);
+				bool match(double const& matchee) const override;
+				std::string describe() const override;
+			private:
+				double m_target;
+				double m_margin;
+			};
+
+			struct WithinUlpsMatcher : MatcherBase<double> {
+				WithinUlpsMatcher(double target, int ulps, FloatingPointKind baseType);
+				bool match(double const& matchee) const override;
+				std::string describe() const override;
+			private:
+				double m_target;
+				int m_ulps;
+				FloatingPointKind m_type;
+			};
+
+		} // namespace Floating
+
+		  // The following functions create the actual matcher objects.
+		  // This allows the types to be inferred
+		Floating::WithinUlpsMatcher WithinULP(double target, int maxUlpDiff);
+		Floating::WithinUlpsMatcher WithinULP(float target, int maxUlpDiff);
+		Floating::WithinAbsMatcher WithinAbs(double target, double margin);
+
+	} // namespace Matchers
+} // namespace Catch
+
+  // end catch_matchers_floating.h
+  // start catch_matchers_generic.hpp
+
+#include <functional>
+#include <string>
+
+namespace Catch {
+	namespace Matchers {
+		namespace Generic {
+
+			namespace Detail {
+				std::string finalizeDescription(const std::string& desc);
+			}
 
+			template <typename T>
+			class PredicateMatcher : public MatcherBase<T> {
+				std::function<bool(T const&)> m_predicate;
+				std::string m_description;
+			public:
+
+				PredicateMatcher(std::function<bool(T const&)> const& elem, std::string const& descr)
+					:m_predicate(std::move(elem)),
+					m_description(Detail::finalizeDescription(descr))
+				{}
+
+				bool match( T const& item ) const override {
+					return m_predicate(item);
+				}
+
+				std::string describe() const override {
+					return m_description;
+				}
+			};
+
+		} // namespace Generic
+
+		  // The following functions create the actual matcher objects.
+		  // The user has to explicitly specify type to the function, because
+		  // infering std::function<bool(T const&)> is hard (but possible) and
+		  // requires a lot of TMP.
+		template<typename T>
+		Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)> const& predicate, std::string const& description = "") {
+			return Generic::PredicateMatcher<T>(predicate, description);
+		}
+
+	} // namespace Matchers
 } // namespace Catch
 
-// end catch_matchers.h
-// start catch_matchers_string.h
+  // end catch_matchers_generic.hpp
+  // start catch_matchers_string.h
 
 #include <string>
 
 namespace Catch {
-namespace Matchers {
-
-    namespace StdString {
-
-        struct CasedString
-        {
-            CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity );
-            std::string adjustString( std::string const& str ) const;
-            std::string caseSensitivitySuffix() const;
-
-            CaseSensitive::Choice m_caseSensitivity;
-            std::string m_str;
-        };
-
-        struct StringMatcherBase : MatcherBase<std::string> {
-            StringMatcherBase( std::string const& operation, CasedString const& comparator );
-            std::string describe() const override;
-
-            CasedString m_comparator;
-            std::string m_operation;
-        };
-
-        struct EqualsMatcher : StringMatcherBase {
-            EqualsMatcher( CasedString const& comparator );
-            bool match( std::string const& source ) const override;
-        };
-        struct ContainsMatcher : StringMatcherBase {
-            ContainsMatcher( CasedString const& comparator );
-            bool match( std::string const& source ) const override;
-        };
-        struct StartsWithMatcher : StringMatcherBase {
-            StartsWithMatcher( CasedString const& comparator );
-            bool match( std::string const& source ) const override;
-        };
-        struct EndsWithMatcher : StringMatcherBase {
-            EndsWithMatcher( CasedString const& comparator );
-            bool match( std::string const& source ) const override;
-        };
-
-    } // namespace StdString
-
-    // The following functions create the actual matcher objects.
-    // This allows the types to be inferred
-
-    StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-    StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-    StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-    StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-
-} // namespace Matchers
+	namespace Matchers {
+
+		namespace StdString {
+
+			struct CasedString
+			{
+				CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity );
+				std::string adjustString( std::string const& str ) const;
+				std::string caseSensitivitySuffix() const;
+
+				CaseSensitive::Choice m_caseSensitivity;
+				std::string m_str;
+			};
+
+			struct StringMatcherBase : MatcherBase<std::string> {
+				StringMatcherBase( std::string const& operation, CasedString const& comparator );
+				std::string describe() const override;
+
+				CasedString m_comparator;
+				std::string m_operation;
+			};
+
+			struct EqualsMatcher : StringMatcherBase {
+				EqualsMatcher( CasedString const& comparator );
+				bool match( std::string const& source ) const override;
+			};
+			struct ContainsMatcher : StringMatcherBase {
+				ContainsMatcher( CasedString const& comparator );
+				bool match( std::string const& source ) const override;
+			};
+			struct StartsWithMatcher : StringMatcherBase {
+				StartsWithMatcher( CasedString const& comparator );
+				bool match( std::string const& source ) const override;
+			};
+			struct EndsWithMatcher : StringMatcherBase {
+				EndsWithMatcher( CasedString const& comparator );
+				bool match( std::string const& source ) const override;
+			};
+
+			struct RegexMatcher : MatcherBase<std::string> {
+				RegexMatcher( std::string regex, CaseSensitive::Choice caseSensitivity );
+				bool match( std::string const& matchee ) const override;
+				std::string describe() const override;
+
+			private:
+				std::string m_regex;
+				CaseSensitive::Choice m_caseSensitivity;
+			};
+
+		} // namespace StdString
+
+		  // The following functions create the actual matcher objects.
+		  // This allows the types to be inferred
+
+		StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+		StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+		StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+		StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+		StdString::RegexMatcher Matches( std::string const& regex, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+
+	} // namespace Matchers
 } // namespace Catch
 
-// end catch_matchers_string.h
-// start catch_matchers_vector.h
-
-namespace Catch {
-namespace Matchers {
-
-    namespace Vector {
-
-        template<typename T>
-        struct ContainsElementMatcher : MatcherBase<std::vector<T>, T> {
-
-            ContainsElementMatcher(T const &comparator) : m_comparator( comparator) {}
-
-            bool match(std::vector<T> const &v) const override {
-                for (auto const& el : v) {
-                    if (el == m_comparator) {
-                        return true;
-                    }
-                }
-                return false;
-            }
-
-            std::string describe() const override {
-                return "Contains: " + ::Catch::Detail::stringify( m_comparator );
-            }
-
-            T const& m_comparator;
-        };
-
-        template<typename T>
-        struct ContainsMatcher : MatcherBase<std::vector<T>, std::vector<T> > {
-
-            ContainsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
-
-            bool match(std::vector<T> const &v) const override {
-                // !TBD: see note in EqualsMatcher
-                if (m_comparator.size() > v.size())
-                    return false;
-                for (auto const& comparator : m_comparator) {
-                    auto present = false;
-                    for (const auto& el : v) {
-                        if (el == comparator) {
-                            present = true;
-                            break;
-                        }
-                    }
-                    if (!present) {
-                        return false;
-                    }
-                }
-                return true;
-            }
-            std::string describe() const override {
-                return "Contains: " + ::Catch::Detail::stringify( m_comparator );
-            }
-
-            std::vector<T> const& m_comparator;
-        };
-
-        template<typename T>
-        struct EqualsMatcher : MatcherBase<std::vector<T>, std::vector<T> > {
-
-            EqualsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
-
-            bool match(std::vector<T> const &v) const override {
-                // !TBD: This currently works if all elements can be compared using !=
-                // - a more general approach would be via a compare template that defaults
-                // to using !=. but could be specialised for, e.g. std::vector<T> etc
-                // - then just call that directly
-                if (m_comparator.size() != v.size())
-                    return false;
-                for (std::size_t i = 0; i < v.size(); ++i)
-                    if (m_comparator[i] != v[i])
-                        return false;
-                return true;
-            }
-            std::string describe() const override {
-                return "Equals: " + ::Catch::Detail::stringify( m_comparator );
-            }
-            std::vector<T> const& m_comparator;
-        };
-
-    } // namespace Vector
-
-    // The following functions create the actual matcher objects.
-    // This allows the types to be inferred
-
-    template<typename T>
-    Vector::ContainsMatcher<T> Contains( std::vector<T> const& comparator ) {
-        return Vector::ContainsMatcher<T>( comparator );
-    }
-
-    template<typename T>
-    Vector::ContainsElementMatcher<T> VectorContains( T const& comparator ) {
-        return Vector::ContainsElementMatcher<T>( comparator );
-    }
-
-    template<typename T>
-    Vector::EqualsMatcher<T> Equals( std::vector<T> const& comparator ) {
-        return Vector::EqualsMatcher<T>( comparator );
-    }
-
-} // namespace Matchers
+  // end catch_matchers_string.h
+  // start catch_matchers_vector.h
+
+#include <algorithm>
+
+namespace Catch {
+	namespace Matchers {
+
+		namespace Vector {
+			namespace Detail {
+				template <typename InputIterator, typename T>
+				size_t count(InputIterator first, InputIterator last, T const& item) {
+					size_t cnt = 0;
+					for (; first != last; ++first) {
+						if (*first == item) {
+							++cnt;
+						}
+					}
+					return cnt;
+				}
+				template <typename InputIterator, typename T>
+				bool contains(InputIterator first, InputIterator last, T const& item) {
+					for (; first != last; ++first) {
+						if (*first == item) {
+							return true;
+						}
+					}
+					return false;
+				}
+			}
+
+			template<typename T>
+			struct ContainsElementMatcher : MatcherBase<std::vector<T>> {
+
+				ContainsElementMatcher(T const &comparator) : m_comparator( comparator) {}
+
+				bool match(std::vector<T> const &v) const override {
+					for (auto const& el : v) {
+						if (el == m_comparator) {
+							return true;
+						}
+					}
+					return false;
+				}
+
+				std::string describe() const override {
+					return "Contains: " + ::Catch::Detail::stringify( m_comparator );
+				}
+
+				T const& m_comparator;
+			};
+
+			template<typename T>
+			struct ContainsMatcher : MatcherBase<std::vector<T>> {
+
+				ContainsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
+
+				bool match(std::vector<T> const &v) const override {
+					// !TBD: see note in EqualsMatcher
+					if (m_comparator.size() > v.size())
+						return false;
+					for (auto const& comparator : m_comparator) {
+						auto present = false;
+						for (const auto& el : v) {
+							if (el == comparator) {
+								present = true;
+								break;
+							}
+						}
+						if (!present) {
+							return false;
+						}
+					}
+					return true;
+				}
+				std::string describe() const override {
+					return "Contains: " + ::Catch::Detail::stringify( m_comparator );
+				}
+
+				std::vector<T> const& m_comparator;
+			};
+
+			template<typename T>
+			struct EqualsMatcher : MatcherBase<std::vector<T>> {
+
+				EqualsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
+
+				bool match(std::vector<T> const &v) const override {
+					// !TBD: This currently works if all elements can be compared using !=
+					// - a more general approach would be via a compare template that defaults
+					// to using !=. but could be specialised for, e.g. std::vector<T> etc
+					// - then just call that directly
+					if (m_comparator.size() != v.size())
+						return false;
+					for (std::size_t i = 0; i < v.size(); ++i)
+						if (m_comparator[i] != v[i])
+							return false;
+					return true;
+				}
+				std::string describe() const override {
+					return "Equals: " + ::Catch::Detail::stringify( m_comparator );
+				}
+				std::vector<T> const& m_comparator;
+			};
+
+			template<typename T>
+			struct UnorderedEqualsMatcher : MatcherBase<std::vector<T>> {
+				UnorderedEqualsMatcher(std::vector<T> const& target) : m_target(target) {}
+				bool match(std::vector<T> const& vec) const override {
+					// Note: This is a reimplementation of std::is_permutation,
+					//       because I don't want to include <algorithm> inside the common path
+					if (m_target.size() != vec.size()) {
+						return false;
+					}
+					auto lfirst = m_target.begin(), llast = m_target.end();
+					auto rfirst = vec.begin(), rlast = vec.end();
+					// Cut common prefix to optimize checking of permuted parts
+					while (lfirst != llast && *lfirst == *rfirst) {
+						++lfirst; ++rfirst;
+					}
+					if (lfirst == llast) {
+						return true;
+					}
+
+					for (auto mid = lfirst; mid != llast; ++mid) {
+						// Skip already counted items
+						if (Detail::contains(lfirst, mid, *mid)) {
+							continue;
+						}
+						size_t num_vec = Detail::count(rfirst, rlast, *mid);
+						if (num_vec == 0 || Detail::count(lfirst, llast, *mid) != num_vec) {
+							return false;
+						}
+					}
+
+					return true;
+				}
+
+				std::string describe() const override {
+					return "UnorderedEquals: " + ::Catch::Detail::stringify(m_target);
+				}
+			private:
+				std::vector<T> const& m_target;
+			};
+
+		} // namespace Vector
+
+		  // The following functions create the actual matcher objects.
+		  // This allows the types to be inferred
+
+		template<typename T>
+		Vector::ContainsMatcher<T> Contains( std::vector<T> const& comparator ) {
+			return Vector::ContainsMatcher<T>( comparator );
+		}
+
+		template<typename T>
+		Vector::ContainsElementMatcher<T> VectorContains( T const& comparator ) {
+			return Vector::ContainsElementMatcher<T>( comparator );
+		}
+
+		template<typename T>
+		Vector::EqualsMatcher<T> Equals( std::vector<T> const& comparator ) {
+			return Vector::EqualsMatcher<T>( comparator );
+		}
+
+		template<typename T>
+		Vector::UnorderedEqualsMatcher<T> UnorderedEquals(std::vector<T> const& target) {
+			return Vector::UnorderedEqualsMatcher<T>(target);
+		}
+
+	} // namespace Matchers
 } // namespace Catch
 
-// end catch_matchers_vector.h
-namespace Catch {
-
-    template<typename ArgT, typename MatcherT>
-    class MatchExpr : public ITransientExpression {
-        ArgT const& m_arg;
-        MatcherT m_matcher;
-        StringRef m_matcherString;
-        bool m_result;
-    public:
-        MatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef matcherString )
-        :   m_arg( arg ),
-            m_matcher( matcher ),
-            m_matcherString( matcherString ),
-            m_result( matcher.match( arg ) )
-        {}
-
-        auto isBinaryExpression() const -> bool  override { return true; }
-        auto getResult() const -> bool override { return m_result; }
-
-        void streamReconstructedExpression( std::ostream &os ) const override {
-            auto matcherAsString = m_matcher.toString();
-            os << Catch::Detail::stringify( m_arg ) << ' ';
-            if( matcherAsString == Detail::unprintableString )
-                os << m_matcherString;
-            else
-                os << matcherAsString;
-        }
-    };
-
-    using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
-
-    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef matcherString  );
-
-    template<typename ArgT, typename MatcherT>
-    auto makeMatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef matcherString  ) -> MatchExpr<ArgT, MatcherT> {
-        return MatchExpr<ArgT, MatcherT>( arg, matcher, matcherString );
-    }
+  // end catch_matchers_vector.h
+namespace Catch {
+
+	template<typename ArgT, typename MatcherT>
+	class MatchExpr : public ITransientExpression {
+		ArgT const& m_arg;
+		MatcherT m_matcher;
+		StringRef m_matcherString;
+	public:
+		MatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString )
+			:   ITransientExpression{ true, matcher.match( arg ) },
+			m_arg( arg ),
+			m_matcher( matcher ),
+			m_matcherString( matcherString )
+		{}
+
+		void streamReconstructedExpression( std::ostream &os ) const override {
+			auto matcherAsString = m_matcher.toString();
+			os << Catch::Detail::stringify( m_arg ) << ' ';
+			if( matcherAsString == Detail::unprintableString )
+				os << m_matcherString;
+			else
+				os << matcherAsString;
+		}
+	};
+
+	using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
+
+	void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString  );
+
+	template<typename ArgT, typename MatcherT>
+	auto makeMatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString  ) -> MatchExpr<ArgT, MatcherT> {
+		return MatchExpr<ArgT, MatcherT>( arg, matcher, matcherString );
+	}
 
 } // namespace Catch
 
-///////////////////////////////////////////////////////////////////////////////
+  ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
     do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
-        INTERNAL_CATCH_TRY( catchAssertionHandler ) { \
-            catchAssertionHandler.handle( Catch::makeMatchExpr( arg, matcher, #matcher ) ); \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+        INTERNAL_CATCH_TRY { \
+            catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher, #matcher##_catch_sr ) ); \
         } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
         INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( Catch::alwaysFalse() )
+    } while( false )
 
-///////////////////////////////////////////////////////////////////////////////
+  ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_THROWS_MATCHES( macroName, exceptionType, resultDisposition, matcher, ... ) \
     do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(exceptionType) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(exceptionType) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
         if( catchAssertionHandler.allowThrows() ) \
             try { \
                 static_cast<void>(__VA_ARGS__ ); \
-                catchAssertionHandler.handle( Catch::ResultWas::DidntThrowException ); \
+                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
             } \
             catch( exceptionType const& ex ) { \
-                catchAssertionHandler.handle( Catch::makeMatchExpr( ex, matcher, #matcher ) ); \
+                catchAssertionHandler.handleExpr( Catch::makeMatchExpr( ex, matcher, #matcher##_catch_sr ) ); \
             } \
             catch( ... ) { \
-                catchAssertionHandler.useActiveException(); \
+                catchAssertionHandler.handleUnexpectedInflightException(); \
             } \
         else \
-            catchAssertionHandler.handle( Catch::ResultWas::Ok ); \
+            catchAssertionHandler.handleThrowingCallSkipped(); \
         INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( Catch::alwaysFalse() )
+    } while( false )
+
+  // end catch_capture_matchers.h
+#endif
+  // start catch_generators.hpp
+
+  // start catch_interfaces_generatortracker.h
 
-// end catch_capture_matchers.h
+
+#include <memory>
+
+namespace Catch {
+
+	namespace Generators {
+		class GeneratorBase {
+		protected:
+			size_t m_size = 0;
+
+		public:
+			GeneratorBase( size_t size ) : m_size( size ) {}
+			virtual ~GeneratorBase();
+			auto size() const -> size_t { return m_size; }
+		};
+		using GeneratorBasePtr = std::unique_ptr<GeneratorBase>;
+
+	} // namespace Generators
+
+	struct IGeneratorTracker {
+		virtual ~IGeneratorTracker();
+		virtual auto hasGenerator() const -> bool = 0;
+		virtual auto getGenerator() const -> Generators::GeneratorBasePtr const& = 0;
+		virtual void setGenerator( Generators::GeneratorBasePtr&& generator ) = 0;
+		virtual auto getIndex() const -> std::size_t = 0;
+	};
+
+} // namespace Catch
+
+  // end catch_interfaces_generatortracker.h
+  // start catch_enforce.h
+
+#include <stdexcept>
+
+namespace Catch {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+	template <typename Ex>
+	[[noreturn]]
+	void throw_exception(Ex const& e) {
+		throw e;
+	}
+#else // ^^ Exceptions are enabled //  Exceptions are disabled vv
+	[[noreturn]]
+	void throw_exception(std::exception const& e);
 #endif
+} // namespace Catch;
 
-// These files are included here so the single_include script doesn't put them
-// in the conditionally compiled sections
-// start catch_test_case_info.h
+#define CATCH_PREPARE_EXCEPTION( type, msg ) \
+    type( ( Catch::ReusableStringStream() << msg ).str() )
+#define CATCH_INTERNAL_ERROR( msg ) \
+    Catch::throw_exception(CATCH_PREPARE_EXCEPTION( std::logic_error, CATCH_INTERNAL_LINEINFO << ": Internal Catch error: " << msg))
+#define CATCH_ERROR( msg ) \
+    Catch::throw_exception(CATCH_PREPARE_EXCEPTION( std::domain_error, msg ))
+#define CATCH_RUNTIME_ERROR( msg ) \
+    Catch::throw_exception(CATCH_PREPARE_EXCEPTION( std::runtime_error, msg ))
+#define CATCH_ENFORCE( condition, msg ) \
+    do{ if( !(condition) ) CATCH_ERROR( msg ); } while(false)
+
+  // end catch_enforce.h
+#include <memory>
+#include <vector>
+#include <cassert>
+
+#include <utility>
+
+namespace Catch {
+	namespace Generators {
+
+		// !TBD move this into its own location?
+		namespace pf{
+			template<typename T, typename... Args>
+			std::unique_ptr<T> make_unique( Args&&... args ) {
+				return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+			}
+		}
+
+		template<typename T>
+		struct IGenerator {
+			virtual ~IGenerator() {}
+			virtual auto get( size_t index ) const -> T = 0;
+		};
+
+		template<typename T>
+		class SingleValueGenerator : public IGenerator<T> {
+			T m_value;
+		public:
+			SingleValueGenerator( T const& value ) : m_value( value ) {}
+
+			auto get( size_t ) const -> T override {
+				return m_value;
+			}
+		};
+
+		template<typename T>
+		class FixedValuesGenerator : public IGenerator<T> {
+			std::vector<T> m_values;
+
+		public:
+			FixedValuesGenerator( std::initializer_list<T> values ) : m_values( values ) {}
+
+			auto get( size_t index ) const -> T override {
+				return m_values[index];
+			}
+		};
+
+		template<typename T>
+		class RangeGenerator : public IGenerator<T> {
+			T const m_first;
+			T const m_last;
+
+		public:
+			RangeGenerator( T const& first, T const& last ) : m_first( first ), m_last( last ) {
+				assert( m_last > m_first );
+			}
+
+			auto get( size_t index ) const -> T override {
+				// ToDo:: introduce a safe cast to catch potential overflows
+				return static_cast<T>(m_first+index);
+			}
+		};
+
+		template<typename T>
+		struct NullGenerator : IGenerator<T> {
+			auto get( size_t ) const -> T override {
+				CATCH_INTERNAL_ERROR("A Null Generator is always empty");
+			}
+		};
+
+		template<typename T>
+		class Generator {
+			std::unique_ptr<IGenerator<T>> m_generator;
+			size_t m_size;
+
+		public:
+			Generator( size_t size, std::unique_ptr<IGenerator<T>> generator )
+				:   m_generator( std::move( generator ) ),
+				m_size( size )
+			{}
+
+			auto size() const -> size_t { return m_size; }
+			auto operator[]( size_t index ) const -> T {
+				assert( index < m_size );
+				return m_generator->get( index );
+			}
+		};
+
+		std::vector<size_t> randomiseIndices( size_t selectionSize, size_t sourceSize );
+
+		template<typename T>
+		class GeneratorRandomiser : public IGenerator<T> {
+			Generator<T> m_baseGenerator;
+
+			std::vector<size_t> m_indices;
+		public:
+			GeneratorRandomiser( Generator<T>&& baseGenerator, size_t numberOfItems )
+				:   m_baseGenerator( std::move( baseGenerator ) ),
+				m_indices( randomiseIndices( numberOfItems, m_baseGenerator.size() ) )
+			{}
+
+			auto get( size_t index ) const -> T override {
+				return m_baseGenerator[m_indices[index]];
+			}
+		};
+
+		template<typename T>
+		struct RequiresASpecialisationFor;
+
+		template<typename T>
+		auto all() -> Generator<T> { return RequiresASpecialisationFor<T>(); }
+
+		template<>
+		auto all<int>() -> Generator<int>;
+
+		template<typename T>
+		auto range( T const& first, T const& last ) -> Generator<T> {
+			return Generator<T>( (last-first), pf::make_unique<RangeGenerator<T>>( first, last ) );
+		}
+
+		template<typename T>
+		auto random( T const& first, T const& last ) -> Generator<T> {
+			auto gen = range( first, last );
+			auto size = gen.size();
+
+			return Generator<T>( size, pf::make_unique<GeneratorRandomiser<T>>( std::move( gen ), size ) );
+		}
+		template<typename T>
+		auto random( size_t size ) -> Generator<T> {
+			return Generator<T>( size, pf::make_unique<GeneratorRandomiser<T>>( all<T>(), size ) );
+		}
+
+		template<typename T>
+		auto values( std::initializer_list<T> values ) -> Generator<T> {
+			return Generator<T>( values.size(), pf::make_unique<FixedValuesGenerator<T>>( values ) );
+		}
+		template<typename T>
+		auto value( T const& val ) -> Generator<T> {
+			return Generator<T>( 1, pf::make_unique<SingleValueGenerator<T>>( val ) );
+		}
+
+		template<typename T>
+		auto as() -> Generator<T> {
+			return Generator<T>( 0, pf::make_unique<NullGenerator<T>>() );
+		}
+
+		template<typename... Ts>
+		auto table( std::initializer_list<std::tuple<Ts...>>&& tuples ) -> Generator<std::tuple<Ts...>> {
+			return values<std::tuple<Ts...>>( std::forward<std::initializer_list<std::tuple<Ts...>>>( tuples ) );
+		}
+
+		template<typename T>
+		struct Generators : GeneratorBase {
+			std::vector<Generator<T>> m_generators;
+
+			using type = T;
+
+			Generators() : GeneratorBase( 0 ) {}
+
+			void populate( T&& val ) {
+				m_size += 1;
+				m_generators.emplace_back( value( std::move( val ) ) );
+			}
+			template<typename U>
+			void populate( U&& val ) {
+				populate( T( std::move( val ) ) );
+			}
+			void populate( Generator<T>&& generator ) {
+				m_size += generator.size();
+				m_generators.emplace_back( std::move( generator ) );
+			}
+
+			template<typename U, typename... Gs>
+			void populate( U&& valueOrGenerator, Gs... moreGenerators ) {
+				populate( std::forward<U>( valueOrGenerator ) );
+				populate( std::forward<Gs>( moreGenerators )... );
+			}
+
+			auto operator[]( size_t index ) const -> T {
+				size_t sizes = 0;
+				for( auto const& gen : m_generators ) {
+					auto localIndex = index-sizes;
+					sizes += gen.size();
+					if( index < sizes )
+						return gen[localIndex];
+				}
+				CATCH_INTERNAL_ERROR("Index '" << index << "' is out of range (" << sizes << ')');
+			}
+		};
+
+		template<typename T, typename... Gs>
+		auto makeGenerators( Generator<T>&& generator, Gs... moreGenerators ) -> Generators<T> {
+			Generators<T> generators;
+			generators.m_generators.reserve( 1+sizeof...(Gs) );
+			generators.populate( std::move( generator ), std::forward<Gs>( moreGenerators )... );
+			return generators;
+		}
+		template<typename T>
+		auto makeGenerators( Generator<T>&& generator ) -> Generators<T> {
+			Generators<T> generators;
+			generators.populate( std::move( generator ) );
+			return generators;
+		}
+		template<typename T, typename... Gs>
+		auto makeGenerators( T&& val, Gs... moreGenerators ) -> Generators<T> {
+			return makeGenerators( value( std::forward<T>( val ) ), std::forward<Gs>( moreGenerators )... );
+		}
+		template<typename T, typename U, typename... Gs>
+		auto makeGenerators( U&& val, Gs... moreGenerators ) -> Generators<T> {
+			return makeGenerators( value( T( std::forward<U>( val ) ) ), std::forward<Gs>( moreGenerators )... );
+		}
+
+		auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker&;
+
+		template<typename L>
+		// Note: The type after -> is weird, because VS2015 cannot parse
+		//       the expression used in the typedef inside, when it is in
+		//       return type.
+		auto generate( SourceLineInfo const& lineInfo, L const& generatorExpression ) -> decltype(std::declval<decltype(generatorExpression())>()[0]) {
+			using UnderlyingType = typename decltype(generatorExpression())::type;
+
+			IGeneratorTracker& tracker = acquireGeneratorTracker( lineInfo );
+			if( !tracker.hasGenerator() )
+				tracker.setGenerator( pf::make_unique<Generators<UnderlyingType>>( generatorExpression() ) );
+
+			auto const& generator = static_cast<Generators<UnderlyingType> const&>( *tracker.getGenerator() );
+			return generator[tracker.getIndex()];
+		}
+
+	} // namespace Generators
+} // namespace Catch
+
+#define GENERATE( ... ) \
+    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, []{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } )
+
+  // end catch_generators.hpp
+
+  // These files are included here so the single_include script doesn't put them
+  // in the conditionally compiled sections
+  // start catch_test_case_info.h
 
 #include <string>
 #include <vector>
@@ -2376,66 +3479,65 @@ namespace Catch {
 
 namespace Catch {
 
-    struct ITestInvoker;
+	struct ITestInvoker;
 
-    struct TestCaseInfo {
-        enum SpecialProperties{
-            None = 0,
-            IsHidden = 1 << 1,
-            ShouldFail = 1 << 2,
-            MayFail = 1 << 3,
-            Throws = 1 << 4,
-            NonPortable = 1 << 5,
-            Benchmark = 1 << 6
-        };
+	struct TestCaseInfo {
+		enum SpecialProperties{
+			None = 0,
+			IsHidden = 1 << 1,
+			ShouldFail = 1 << 2,
+			MayFail = 1 << 3,
+			Throws = 1 << 4,
+			NonPortable = 1 << 5,
+			Benchmark = 1 << 6
+		};
 
-        TestCaseInfo(   std::string const& _name,
-                        std::string const& _className,
-                        std::string const& _description,
-                        std::vector<std::string> const& _tags,
-                        SourceLineInfo const& _lineInfo );
+		TestCaseInfo(   std::string const& _name,
+			std::string const& _className,
+			std::string const& _description,
+			std::vector<std::string> const& _tags,
+			SourceLineInfo const& _lineInfo );
 
-        friend void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags );
+		friend void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags );
 
-        bool isHidden() const;
-        bool throws() const;
-        bool okToFail() const;
-        bool expectedToFail() const;
+		bool isHidden() const;
+		bool throws() const;
+		bool okToFail() const;
+		bool expectedToFail() const;
 
-        std::string tagsAsString() const;
+		std::string tagsAsString() const;
 
-        std::string name;
-        std::string className;
-        std::string description;
-        std::vector<std::string> tags;
-        std::vector<std::string> lcaseTags;
-        SourceLineInfo lineInfo;
-        SpecialProperties properties;
-    };
+		std::string name;
+		std::string className;
+		std::string description;
+		std::vector<std::string> tags;
+		std::vector<std::string> lcaseTags;
+		SourceLineInfo lineInfo;
+		SpecialProperties properties;
+	};
 
-    class TestCase : public TestCaseInfo {
-    public:
+	class TestCase : public TestCaseInfo {
+	public:
 
-        TestCase( ITestInvoker* testCase, TestCaseInfo const& info );
+		TestCase( ITestInvoker* testCase, TestCaseInfo&& info );
 
-        TestCase withName( std::string const& _newName ) const;
+		TestCase withName( std::string const& _newName ) const;
 
-        void invoke() const;
+		void invoke() const;
 
-        TestCaseInfo const& getTestCaseInfo() const;
+		TestCaseInfo const& getTestCaseInfo() const;
 
-        bool operator == ( TestCase const& other ) const;
-        bool operator < ( TestCase const& other ) const;
+		bool operator == ( TestCase const& other ) const;
+		bool operator < ( TestCase const& other ) const;
 
-    private:
-        std::shared_ptr<ITestInvoker> test;
-    };
+	private:
+		std::shared_ptr<ITestInvoker> test;
+	};
 
-    TestCase makeTestCase(  ITestInvoker* testCase,
-                            std::string const& className,
-                            std::string const& name,
-                            std::string const& description,
-                            SourceLineInfo const& lineInfo );
+	TestCase makeTestCase(  ITestInvoker* testCase,
+		std::string const& className,
+		NameAndTags const& nameAndTags,
+		SourceLineInfo const& lineInfo );
 }
 
 #ifdef __clang__
@@ -2447,10 +3549,10 @@ namespace Catch {
 
 namespace Catch {
 
-    struct IRunner {
-        virtual ~IRunner();
-        virtual bool aborting() const = 0;
-    };
+	struct IRunner {
+		virtual ~IRunner();
+		virtual bool aborting() const = 0;
+	};
 }
 
 // end catch_interfaces_runner.h
@@ -2480,168 +3582,168 @@ namespace Catch {
 
 namespace Catch {
 
-    class OcMethod : public ITestInvoker {
-
-    public:
-        OcMethod( Class cls, SEL sel ) : m_cls( cls ), m_sel( sel ) {}
-
-        virtual void invoke() const {
-            id obj = [[m_cls alloc] init];
-
-            performOptionalSelector( obj, @selector(setUp)  );
-            performOptionalSelector( obj, m_sel );
-            performOptionalSelector( obj, @selector(tearDown)  );
-
-            arcSafeRelease( obj );
-        }
-    private:
-        virtual ~OcMethod() {}
-
-        Class m_cls;
-        SEL m_sel;
-    };
-
-    namespace Detail{
-
-        inline std::string getAnnotation(   Class cls,
-                                            std::string const& annotationName,
-                                            std::string const& testCaseName ) {
-            NSString* selStr = [[NSString alloc] initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()];
-            SEL sel = NSSelectorFromString( selStr );
-            arcSafeRelease( selStr );
-            id value = performOptionalSelector( cls, sel );
-            if( value )
-                return [(NSString*)value UTF8String];
-            return "";
-        }
-    }
-
-    inline std::size_t registerTestMethods() {
-        std::size_t noTestMethods = 0;
-        int noClasses = objc_getClassList( nullptr, 0 );
-
-        Class* classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc( sizeof(Class) * noClasses);
-        objc_getClassList( classes, noClasses );
-
-        for( int c = 0; c < noClasses; c++ ) {
-            Class cls = classes[c];
-            {
-                u_int count;
-                Method* methods = class_copyMethodList( cls, &count );
-                for( u_int m = 0; m < count ; m++ ) {
-                    SEL selector = method_getName(methods[m]);
-                    std::string methodName = sel_getName(selector);
-                    if( startsWith( methodName, "Catch_TestCase_" ) ) {
-                        std::string testCaseName = methodName.substr( 15 );
-                        std::string name = Detail::getAnnotation( cls, "Name", testCaseName );
-                        std::string desc = Detail::getAnnotation( cls, "Description", testCaseName );
-                        const char* className = class_getName( cls );
-
-                        getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, name.c_str(), desc.c_str(), SourceLineInfo("",0) ) );
-                        noTestMethods++;
-                    }
-                }
-                free(methods);
-            }
-        }
-        return noTestMethods;
-    }
+	class OcMethod : public ITestInvoker {
+
+	public:
+		OcMethod( Class cls, SEL sel ) : m_cls( cls ), m_sel( sel ) {}
+
+		virtual void invoke() const {
+			id obj = [[m_cls alloc] init];
+
+			performOptionalSelector( obj, @selector(setUp)  );
+			performOptionalSelector( obj, m_sel );
+			performOptionalSelector( obj, @selector(tearDown)  );
+
+			arcSafeRelease( obj );
+		}
+	private:
+		virtual ~OcMethod() {}
+
+		Class m_cls;
+		SEL m_sel;
+	};
+
+	namespace Detail{
+
+		inline std::string getAnnotation(   Class cls,
+			std::string const& annotationName,
+			std::string const& testCaseName ) {
+			NSString* selStr = [[NSString alloc] initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()];
+				SEL sel = NSSelectorFromString( selStr );
+			arcSafeRelease( selStr );
+			id value = performOptionalSelector( cls, sel );
+			if( value )
+				return [(NSString*)value UTF8String];
+			return "";
+		}
+	}
+
+	inline std::size_t registerTestMethods() {
+		std::size_t noTestMethods = 0;
+		int noClasses = objc_getClassList( nullptr, 0 );
+
+		Class* classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc( sizeof(Class) * noClasses);
+		objc_getClassList( classes, noClasses );
+
+		for( int c = 0; c < noClasses; c++ ) {
+			Class cls = classes[c];
+			{
+				u_int count;
+				Method* methods = class_copyMethodList( cls, &count );
+				for( u_int m = 0; m < count ; m++ ) {
+					SEL selector = method_getName(methods[m]);
+					std::string methodName = sel_getName(selector);
+					if( startsWith( methodName, "Catch_TestCase_" ) ) {
+						std::string testCaseName = methodName.substr( 15 );
+						std::string name = Detail::getAnnotation( cls, "Name", testCaseName );
+						std::string desc = Detail::getAnnotation( cls, "Description", testCaseName );
+						const char* className = class_getName( cls );
+
+						getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, NameAndTags( name.c_str(), desc.c_str() ), SourceLineInfo("",0) ) );
+						noTestMethods++;
+					}
+				}
+				free(methods);
+			}
+		}
+		return noTestMethods;
+	}
 
 #if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
 
-    namespace Matchers {
-        namespace Impl {
-        namespace NSStringMatchers {
+	namespace Matchers {
+		namespace Impl {
+			namespace NSStringMatchers {
 
-            struct StringHolder : MatcherBase<NSString*>{
-                StringHolder( NSString* substr ) : m_substr( [substr copy] ){}
-                StringHolder( StringHolder const& other ) : m_substr( [other.m_substr copy] ){}
-                StringHolder() {
-                    arcSafeRelease( m_substr );
-                }
+				struct StringHolder : MatcherBase<NSString*>{
+					StringHolder( NSString* substr ) : m_substr( [substr copy] ){}
+					StringHolder( StringHolder const& other ) : m_substr( [other.m_substr copy] ){}
+					StringHolder() {
+						arcSafeRelease( m_substr );
+					}
 
-                bool match( NSString* arg ) const override {
-                    return false;
-                }
+					bool match( NSString* arg ) const override {
+						return false;
+					}
 
-                NSString* CATCH_ARC_STRONG m_substr;
-            };
+					NSString* CATCH_ARC_STRONG m_substr;
+				};
 
-            struct Equals : StringHolder {
-                Equals( NSString* substr ) : StringHolder( substr ){}
+				struct Equals : StringHolder {
+					Equals( NSString* substr ) : StringHolder( substr ){}
 
-                bool match( NSString* str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str isEqualToString:m_substr];
-                }
+					bool match( NSString* str ) const override {
+						return  (str != nil || m_substr == nil ) &&
+							[str isEqualToString:m_substr];
+					}
 
-                std::string describe() const override {
-                    return "equals string: " + Catch::Detail::stringify( m_substr );
-                }
-            };
+					std::string describe() const override {
+						return "equals string: " + Catch::Detail::stringify( m_substr );
+					}
+				};
 
-            struct Contains : StringHolder {
-                Contains( NSString* substr ) : StringHolder( substr ){}
+				struct Contains : StringHolder {
+					Contains( NSString* substr ) : StringHolder( substr ){}
 
-                bool match( NSString* str ) const {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location != NSNotFound;
-                }
+					bool match( NSString* str ) const {
+						return  (str != nil || m_substr == nil ) &&
+							[str rangeOfString:m_substr].location != NSNotFound;
+					}
 
-                std::string describe() const override {
-                    return "contains string: " + Catch::Detail::stringify( m_substr );
-                }
-            };
+					std::string describe() const override {
+						return "contains string: " + Catch::Detail::stringify( m_substr );
+					}
+				};
 
-            struct StartsWith : StringHolder {
-                StartsWith( NSString* substr ) : StringHolder( substr ){}
+				struct StartsWith : StringHolder {
+					StartsWith( NSString* substr ) : StringHolder( substr ){}
 
-                bool match( NSString* str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location == 0;
-                }
+					bool match( NSString* str ) const override {
+						return  (str != nil || m_substr == nil ) &&
+							[str rangeOfString:m_substr].location == 0;
+					}
 
-                std::string describe() const override {
-                    return "starts with: " + Catch::Detail::stringify( m_substr );
-                }
-            };
-            struct EndsWith : StringHolder {
-                EndsWith( NSString* substr ) : StringHolder( substr ){}
+					std::string describe() const override {
+						return "starts with: " + Catch::Detail::stringify( m_substr );
+					}
+				};
+				struct EndsWith : StringHolder {
+					EndsWith( NSString* substr ) : StringHolder( substr ){}
 
-                bool match( NSString* str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location == [str length] - [m_substr length];
-                }
+					bool match( NSString* str ) const override {
+						return  (str != nil || m_substr == nil ) &&
+							[str rangeOfString:m_substr].location == [str length] - [m_substr length];
+					}
 
-                std::string describe() const override {
-                    return "ends with: " + Catch::Detail::stringify( m_substr );
-                }
-            };
+					std::string describe() const override {
+						return "ends with: " + Catch::Detail::stringify( m_substr );
+					}
+				};
 
-        } // namespace NSStringMatchers
-        } // namespace Impl
+			} // namespace NSStringMatchers
+		} // namespace Impl
 
-        inline Impl::NSStringMatchers::Equals
-            Equals( NSString* substr ){ return Impl::NSStringMatchers::Equals( substr ); }
+		inline Impl::NSStringMatchers::Equals
+			Equals( NSString* substr ){ return Impl::NSStringMatchers::Equals( substr ); }
 
-        inline Impl::NSStringMatchers::Contains
-            Contains( NSString* substr ){ return Impl::NSStringMatchers::Contains( substr ); }
+		inline Impl::NSStringMatchers::Contains
+			Contains( NSString* substr ){ return Impl::NSStringMatchers::Contains( substr ); }
 
-        inline Impl::NSStringMatchers::StartsWith
-            StartsWith( NSString* substr ){ return Impl::NSStringMatchers::StartsWith( substr ); }
+		inline Impl::NSStringMatchers::StartsWith
+			StartsWith( NSString* substr ){ return Impl::NSStringMatchers::StartsWith( substr ); }
 
-        inline Impl::NSStringMatchers::EndsWith
-            EndsWith( NSString* substr ){ return Impl::NSStringMatchers::EndsWith( substr ); }
+		inline Impl::NSStringMatchers::EndsWith
+			EndsWith( NSString* substr ){ return Impl::NSStringMatchers::EndsWith( substr ); }
 
-    } // namespace Matchers
+	} // namespace Matchers
 
-    using namespace Matchers;
+	using namespace Matchers;
 
 #endif // CATCH_CONFIG_DISABLE_MATCHERS
 
 } // namespace Catch
 
-///////////////////////////////////////////////////////////////////////////////
+  ///////////////////////////////////////////////////////////////////////////////
 #define OC_MAKE_UNIQUE_NAME( root, uniqueSuffix ) root##uniqueSuffix
 #define OC_TEST_CASE2( name, desc, uniqueSuffix ) \
 +(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Name_test_, uniqueSuffix ) \
@@ -2656,56 +3758,56 @@ return @ desc; \
 
 #define OC_TEST_CASE( name, desc ) OC_TEST_CASE2( name, desc, __LINE__ )
 
-// end catch_objc.hpp
+  // end catch_objc.hpp
 #endif
 
 #ifdef CATCH_CONFIG_EXTERNAL_INTERFACES
-// start catch_external_interfaces.h
+  // start catch_external_interfaces.h
 
-// start catch_reporter_bases.hpp
+  // start catch_reporter_bases.hpp
 
-// start catch_interfaces_reporter.h
+  // start catch_interfaces_reporter.h
 
-// start catch_config.hpp
+  // start catch_config.hpp
 
-// start catch_test_spec_parser.h
+  // start catch_test_spec_parser.h
 
 #ifdef __clang__
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wpadded"
 #endif
 
-// start catch_test_spec.h
+  // start catch_test_spec.h
 
 #ifdef __clang__
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wpadded"
 #endif
 
-// start catch_wildcard_pattern.h
+  // start catch_wildcard_pattern.h
 
 namespace Catch
 {
-    class WildcardPattern {
-        enum WildcardPosition {
-            NoWildcard = 0,
-            WildcardAtStart = 1,
-            WildcardAtEnd = 2,
-            WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
-        };
-
-    public:
-
-        WildcardPattern( std::string const& pattern, CaseSensitive::Choice caseSensitivity );
-        virtual ~WildcardPattern() = default;
-        virtual bool matches( std::string const& str ) const;
-
-    private:
-        std::string adjustCase( std::string const& str ) const;
-        CaseSensitive::Choice m_caseSensitivity;
-        WildcardPosition m_wildcard = NoWildcard;
-        std::string m_pattern;
-    };
+	class WildcardPattern {
+		enum WildcardPosition {
+			NoWildcard = 0,
+			WildcardAtStart = 1,
+			WildcardAtEnd = 2,
+			WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
+		};
+
+	public:
+
+		WildcardPattern( std::string const& pattern, CaseSensitive::Choice caseSensitivity );
+		virtual ~WildcardPattern() = default;
+		virtual bool matches( std::string const& str ) const;
+
+	private:
+		std::string adjustCase( std::string const& str ) const;
+		CaseSensitive::Choice m_caseSensitivity;
+		WildcardPosition m_wildcard = NoWildcard;
+		std::string m_pattern;
+	};
 }
 
 // end catch_wildcard_pattern.h
@@ -2715,55 +3817,55 @@ namespace Catch
 
 namespace Catch {
 
-    class TestSpec {
-        struct Pattern {
-            virtual ~Pattern();
-            virtual bool matches( TestCaseInfo const& testCase ) const = 0;
-        };
-        using PatternPtr = std::shared_ptr<Pattern>;
-
-        class NamePattern : public Pattern {
-        public:
-            NamePattern( std::string const& name );
-            virtual ~NamePattern();
-            virtual bool matches( TestCaseInfo const& testCase ) const override;
-        private:
-            WildcardPattern m_wildcardPattern;
-        };
-
-        class TagPattern : public Pattern {
-        public:
-            TagPattern( std::string const& tag );
-            virtual ~TagPattern();
-            virtual bool matches( TestCaseInfo const& testCase ) const override;
-        private:
-            std::string m_tag;
-        };
-
-        class ExcludedPattern : public Pattern {
-        public:
-            ExcludedPattern( PatternPtr const& underlyingPattern );
-            virtual ~ExcludedPattern();
-            virtual bool matches( TestCaseInfo const& testCase ) const override;
-        private:
-            PatternPtr m_underlyingPattern;
-        };
-
-        struct Filter {
-            std::vector<PatternPtr> m_patterns;
-
-            bool matches( TestCaseInfo const& testCase ) const;
-        };
-
-    public:
-        bool hasFilters() const;
-        bool matches( TestCaseInfo const& testCase ) const;
-
-    private:
-        std::vector<Filter> m_filters;
-
-        friend class TestSpecParser;
-    };
+	class TestSpec {
+		struct Pattern {
+			virtual ~Pattern();
+			virtual bool matches( TestCaseInfo const& testCase ) const = 0;
+		};
+		using PatternPtr = std::shared_ptr<Pattern>;
+
+		class NamePattern : public Pattern {
+		public:
+			NamePattern( std::string const& name );
+			virtual ~NamePattern();
+			virtual bool matches( TestCaseInfo const& testCase ) const override;
+		private:
+			WildcardPattern m_wildcardPattern;
+		};
+
+		class TagPattern : public Pattern {
+		public:
+			TagPattern( std::string const& tag );
+			virtual ~TagPattern();
+			virtual bool matches( TestCaseInfo const& testCase ) const override;
+		private:
+			std::string m_tag;
+		};
+
+		class ExcludedPattern : public Pattern {
+		public:
+			ExcludedPattern( PatternPtr const& underlyingPattern );
+			virtual ~ExcludedPattern();
+			virtual bool matches( TestCaseInfo const& testCase ) const override;
+		private:
+			PatternPtr m_underlyingPattern;
+		};
+
+		struct Filter {
+			std::vector<PatternPtr> m_patterns;
+
+			bool matches( TestCaseInfo const& testCase ) const;
+		};
+
+	public:
+		bool hasFilters() const;
+		bool matches( TestCaseInfo const& testCase ) const;
+
+	private:
+		std::vector<Filter> m_filters;
+
+		friend class TestSpecParser;
+	};
 }
 
 #ifdef __clang__
@@ -2777,68 +3879,68 @@ namespace Catch {
 
 namespace Catch {
 
-    struct TagAlias;
+	struct TagAlias;
 
-    struct ITagAliasRegistry {
-        virtual ~ITagAliasRegistry();
-        // Nullptr if not present
-        virtual TagAlias const* find( std::string const& alias ) const = 0;
-        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;
+	struct ITagAliasRegistry {
+		virtual ~ITagAliasRegistry();
+		// Nullptr if not present
+		virtual TagAlias const* find( std::string const& alias ) const = 0;
+		virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;
 
-        static ITagAliasRegistry const& get();
-    };
+		static ITagAliasRegistry const& get();
+	};
 
 } // end namespace Catch
 
-// end catch_interfaces_tag_alias_registry.h
-namespace Catch {
-
-    class TestSpecParser {
-        enum Mode{ None, Name, QuotedName, Tag, EscapedName };
-        Mode m_mode = None;
-        bool m_exclusion = false;
-        std::size_t m_start = std::string::npos, m_pos = 0;
-        std::string m_arg;
-        std::vector<std::size_t> m_escapeChars;
-        TestSpec::Filter m_currentFilter;
-        TestSpec m_testSpec;
-        ITagAliasRegistry const* m_tagAliases = nullptr;
-
-    public:
-        TestSpecParser( ITagAliasRegistry const& tagAliases );
-
-        TestSpecParser& parse( std::string const& arg );
-        TestSpec testSpec();
-
-    private:
-        void visitChar( char c );
-        void startNewMode( Mode mode, std::size_t start );
-        void escape();
-        std::string subString() const;
-
-        template<typename T>
-        void addPattern() {
-            std::string token = subString();
-            for( std::size_t i = 0; i < m_escapeChars.size(); ++i )
-                token = token.substr( 0, m_escapeChars[i]-m_start-i ) + token.substr( m_escapeChars[i]-m_start-i+1 );
-            m_escapeChars.clear();
-            if( startsWith( token, "exclude:" ) ) {
-                m_exclusion = true;
-                token = token.substr( 8 );
-            }
-            if( !token.empty() ) {
-                TestSpec::PatternPtr pattern = std::make_shared<T>( token );
-                if( m_exclusion )
-                    pattern = std::make_shared<TestSpec::ExcludedPattern>( pattern );
-                m_currentFilter.m_patterns.push_back( pattern );
-            }
-            m_exclusion = false;
-            m_mode = None;
-        }
-
-        void addFilter();
-    };
-    TestSpec parseTestSpec( std::string const& arg );
+  // end catch_interfaces_tag_alias_registry.h
+namespace Catch {
+
+	class TestSpecParser {
+		enum Mode{ None, Name, QuotedName, Tag, EscapedName };
+		Mode m_mode = None;
+		bool m_exclusion = false;
+		std::size_t m_start = std::string::npos, m_pos = 0;
+		std::string m_arg;
+		std::vector<std::size_t> m_escapeChars;
+		TestSpec::Filter m_currentFilter;
+		TestSpec m_testSpec;
+		ITagAliasRegistry const* m_tagAliases = nullptr;
+
+	public:
+		TestSpecParser( ITagAliasRegistry const& tagAliases );
+
+		TestSpecParser& parse( std::string const& arg );
+		TestSpec testSpec();
+
+	private:
+		void visitChar( char c );
+		void startNewMode( Mode mode, std::size_t start );
+		void escape();
+		std::string subString() const;
+
+		template<typename T>
+		void addPattern() {
+			std::string token = subString();
+			for( std::size_t i = 0; i < m_escapeChars.size(); ++i )
+				token = token.substr( 0, m_escapeChars[i]-m_start-i ) + token.substr( m_escapeChars[i]-m_start-i+1 );
+			m_escapeChars.clear();
+			if( startsWith( token, "exclude:" ) ) {
+				m_exclusion = true;
+				token = token.substr( 8 );
+			}
+			if( !token.empty() ) {
+				TestSpec::PatternPtr pattern = std::make_shared<T>( token );
+				if( m_exclusion )
+					pattern = std::make_shared<TestSpec::ExcludedPattern>( pattern );
+				m_currentFilter.m_patterns.push_back( pattern );
+			}
+			m_exclusion = false;
+			m_mode = None;
+		}
+
+		void addFilter();
+	};
+	TestSpec parseTestSpec( std::string const& arg );
 
 } // namespace Catch
 
@@ -2846,8 +3948,8 @@ namespace Catch {
 #pragma clang diagnostic pop
 #endif
 
-// end catch_test_spec_parser.h
-// start catch_interfaces_config.h
+  // end catch_test_spec_parser.h
+  // start catch_interfaces_config.h
 
 #include <iosfwd>
 #include <string>
@@ -2856,131 +3958,71 @@ namespace Catch {
 
 namespace Catch {
 
-    enum class Verbosity {
-        Quiet = 0,
-        Normal,
-        High
-    };
-
-    struct WarnAbout { enum What {
-        Nothing = 0x00,
-        NoAssertions = 0x01
-    }; };
-
-    struct ShowDurations { enum OrNot {
-        DefaultForReporter,
-        Always,
-        Never
-    }; };
-    struct RunTests { enum InWhatOrder {
-        InDeclarationOrder,
-        InLexicographicalOrder,
-        InRandomOrder
-    }; };
-    struct UseColour { enum YesOrNo {
-        Auto,
-        Yes,
-        No
-    }; };
-    struct WaitForKeypress { enum When {
-        Never,
-        BeforeStart = 1,
-        BeforeExit = 2,
-        BeforeStartAndExit = BeforeStart | BeforeExit
-    }; };
-
-    class TestSpec;
-
-    struct IConfig : NonCopyable {
-
-        virtual ~IConfig();
-
-        virtual bool allowThrows() const = 0;
-        virtual std::ostream& stream() const = 0;
-        virtual std::string name() const = 0;
-        virtual bool includeSuccessfulResults() const = 0;
-        virtual bool shouldDebugBreak() const = 0;
-        virtual bool warnAboutMissingAssertions() const = 0;
-        virtual int abortAfter() const = 0;
-        virtual bool showInvisibles() const = 0;
-        virtual ShowDurations::OrNot showDurations() const = 0;
-        virtual TestSpec const& testSpec() const = 0;
-        virtual RunTests::InWhatOrder runOrder() const = 0;
-        virtual unsigned int rngSeed() const = 0;
-        virtual int benchmarkResolutionMultiple() const = 0;
-        virtual UseColour::YesOrNo useColour() const = 0;
-        virtual std::vector<std::string> const& getSectionsToRun() const = 0;
-        virtual Verbosity verbosity() const = 0;
-    };
-
-    using IConfigPtr = std::shared_ptr<IConfig const>;
+	enum class Verbosity {
+		Quiet = 0,
+		Normal,
+		High
+	};
+
+	struct WarnAbout { enum What {
+		Nothing = 0x00,
+		NoAssertions = 0x01,
+		NoTests = 0x02
+	}; };
+
+	struct ShowDurations { enum OrNot {
+		DefaultForReporter,
+		Always,
+		Never
+	}; };
+	struct RunTests { enum InWhatOrder {
+		InDeclarationOrder,
+		InLexicographicalOrder,
+		InRandomOrder
+	}; };
+	struct UseColour { enum YesOrNo {
+		Auto,
+		Yes,
+		No
+	}; };
+	struct WaitForKeypress { enum When {
+		Never,
+		BeforeStart = 1,
+		BeforeExit = 2,
+		BeforeStartAndExit = BeforeStart | BeforeExit
+	}; };
+
+	class TestSpec;
+
+	struct IConfig : NonCopyable {
+
+		virtual ~IConfig();
+
+		virtual bool allowThrows() const = 0;
+		virtual std::ostream& stream() const = 0;
+		virtual std::string name() const = 0;
+		virtual bool includeSuccessfulResults() const = 0;
+		virtual bool shouldDebugBreak() const = 0;
+		virtual bool warnAboutMissingAssertions() const = 0;
+		virtual bool warnAboutNoTests() const = 0;
+		virtual int abortAfter() const = 0;
+		virtual bool showInvisibles() const = 0;
+		virtual ShowDurations::OrNot showDurations() const = 0;
+		virtual TestSpec const& testSpec() const = 0;
+		virtual bool hasTestFilters() const = 0;
+		virtual RunTests::InWhatOrder runOrder() const = 0;
+		virtual unsigned int rngSeed() const = 0;
+		virtual int benchmarkResolutionMultiple() const = 0;
+		virtual UseColour::YesOrNo useColour() const = 0;
+		virtual std::vector<std::string> const& getSectionsToRun() const = 0;
+		virtual Verbosity verbosity() const = 0;
+	};
+
+	using IConfigPtr = std::shared_ptr<IConfig const>;
 }
 
 // end catch_interfaces_config.h
 // Libstdc++ doesn't like incomplete classes for unique_ptr
-// start catch_stream.h
-
-// start catch_streambuf.h
-
-#include <streambuf>
-
-namespace Catch {
-
-    class StreamBufBase : public std::streambuf {
-    public:
-        virtual ~StreamBufBase();
-    };
-}
-
-// end catch_streambuf.h
-#include <streambuf>
-#include <ostream>
-#include <fstream>
-#include <memory>
-
-namespace Catch {
-
-    std::ostream& cout();
-    std::ostream& cerr();
-    std::ostream& clog();
-
-    struct IStream {
-        virtual ~IStream();
-        virtual std::ostream& stream() const = 0;
-    };
-
-    class FileStream : public IStream {
-        mutable std::ofstream m_ofs;
-    public:
-        FileStream( std::string const& filename );
-        ~FileStream() override = default;
-    public: // IStream
-        std::ostream& stream() const override;
-    };
-
-    class CoutStream : public IStream {
-        mutable std::ostream m_os;
-    public:
-        CoutStream();
-        ~CoutStream() override = default;
-
-    public: // IStream
-        std::ostream& stream() const override;
-    };
-
-    class DebugOutStream : public IStream {
-        std::unique_ptr<StreamBufBase> m_streamBuf;
-        mutable std::ostream m_os;
-    public:
-        DebugOutStream();
-        ~DebugOutStream() override = default;
-
-    public: // IStream
-        std::ostream& stream() const override;
-    };
-}
-
-// end catch_stream.h
 
 #include <memory>
 #include <vector>
@@ -2992,204 +4034,212 @@ namespace Catch {
 
 namespace Catch {
 
-    struct IStream;
+	struct IStream;
 
-    struct ConfigData {
-        bool listTests = false;
-        bool listTags = false;
-        bool listReporters = false;
-        bool listTestNamesOnly = false;
+	struct ConfigData {
+		bool listTests = false;
+		bool listTags = false;
+		bool listReporters = false;
+		bool listTestNamesOnly = false;
 
-        bool showSuccessfulTests = false;
-        bool shouldDebugBreak = false;
-        bool noThrow = false;
-        bool showHelp = false;
-        bool showInvisibles = false;
-        bool filenamesAsTags = false;
-        bool libIdentify = false;
+		bool showSuccessfulTests = false;
+		bool shouldDebugBreak = false;
+		bool noThrow = false;
+		bool showHelp = false;
+		bool showInvisibles = false;
+		bool filenamesAsTags = false;
+		bool libIdentify = false;
 
-        int abortAfter = -1;
-        unsigned int rngSeed = 0;
-        int benchmarkResolutionMultiple = 100;
+		int abortAfter = -1;
+		unsigned int rngSeed = 0;
+		int benchmarkResolutionMultiple = 100;
 
-        Verbosity verbosity = Verbosity::Normal;
-        WarnAbout::What warnings = WarnAbout::Nothing;
-        ShowDurations::OrNot showDurations = ShowDurations::DefaultForReporter;
-        RunTests::InWhatOrder runOrder = RunTests::InDeclarationOrder;
-        UseColour::YesOrNo useColour = UseColour::Auto;
-        WaitForKeypress::When waitForKeypress = WaitForKeypress::Never;
+		Verbosity verbosity = Verbosity::Normal;
+		WarnAbout::What warnings = WarnAbout::Nothing;
+		ShowDurations::OrNot showDurations = ShowDurations::DefaultForReporter;
+		RunTests::InWhatOrder runOrder = RunTests::InDeclarationOrder;
+		UseColour::YesOrNo useColour = UseColour::Auto;
+		WaitForKeypress::When waitForKeypress = WaitForKeypress::Never;
 
-        std::string outputFilename;
-        std::string name;
-        std::string processName;
+		std::string outputFilename;
+		std::string name;
+		std::string processName;
+#ifndef CATCH_CONFIG_DEFAULT_REPORTER
+#define CATCH_CONFIG_DEFAULT_REPORTER "console"
+#endif
+		std::string reporterName = CATCH_CONFIG_DEFAULT_REPORTER;
+#undef CATCH_CONFIG_DEFAULT_REPORTER
 
-        std::vector<std::string> reporterNames;
-        std::vector<std::string> testsOrTags;
-        std::vector<std::string> sectionsToRun;
-    };
+		std::vector<std::string> testsOrTags;
+		std::vector<std::string> sectionsToRun;
+	};
 
-    class Config : public IConfig {
-    public:
+	class Config : public IConfig {
+	public:
 
-        Config() = default;
-        Config( ConfigData const& data );
-        virtual ~Config() = default;
+		Config() = default;
+		Config( ConfigData const& data );
+		virtual ~Config() = default;
 
-        std::string const& getFilename() const;
+		std::string const& getFilename() const;
 
-        bool listTests() const;
-        bool listTestNamesOnly() const;
-        bool listTags() const;
-        bool listReporters() const;
+		bool listTests() const;
+		bool listTestNamesOnly() const;
+		bool listTags() const;
+		bool listReporters() const;
 
-        std::string getProcessName() const;
+		std::string getProcessName() const;
+		std::string const& getReporterName() const;
 
-        std::vector<std::string> const& getReporterNames() const;
-        std::vector<std::string> const& getSectionsToRun() const override;
+		std::vector<std::string> const& getTestsOrTags() const;
+		std::vector<std::string> const& getSectionsToRun() const override;
 
-        virtual TestSpec const& testSpec() const override;
+		virtual TestSpec const& testSpec() const override;
+		bool hasTestFilters() const override;
 
-        bool showHelp() const;
+		bool showHelp() const;
 
-        // IConfig interface
-        bool allowThrows() const override;
-        std::ostream& stream() const override;
-        std::string name() const override;
-        bool includeSuccessfulResults() const override;
-        bool warnAboutMissingAssertions() const override;
-        ShowDurations::OrNot showDurations() const override;
-        RunTests::InWhatOrder runOrder() const override;
-        unsigned int rngSeed() const override;
-        int benchmarkResolutionMultiple() const override;
-        UseColour::YesOrNo useColour() const override;
-        bool shouldDebugBreak() const override;
-        int abortAfter() const override;
-        bool showInvisibles() const override;
-        Verbosity verbosity() const override;
+		// IConfig interface
+		bool allowThrows() const override;
+		std::ostream& stream() const override;
+		std::string name() const override;
+		bool includeSuccessfulResults() const override;
+		bool warnAboutMissingAssertions() const override;
+		bool warnAboutNoTests() const override;
+		ShowDurations::OrNot showDurations() const override;
+		RunTests::InWhatOrder runOrder() const override;
+		unsigned int rngSeed() const override;
+		int benchmarkResolutionMultiple() const override;
+		UseColour::YesOrNo useColour() const override;
+		bool shouldDebugBreak() const override;
+		int abortAfter() const override;
+		bool showInvisibles() const override;
+		Verbosity verbosity() const override;
 
-    private:
+	private:
 
-        IStream const* openStream();
-        ConfigData m_data;
+		IStream const* openStream();
+		ConfigData m_data;
 
-        std::unique_ptr<IStream const> m_stream;
-        TestSpec m_testSpec;
-    };
+		std::unique_ptr<IStream const> m_stream;
+		TestSpec m_testSpec;
+		bool m_hasTestFilters = false;
+	};
 
 } // end namespace Catch
 
-// end catch_config.hpp
-// start catch_assertionresult.h
+  // end catch_config.hpp
+  // start catch_assertionresult.h
 
 #include <string>
 
 namespace Catch {
 
-    struct AssertionResultData
-    {
-        AssertionResultData() = delete;
+	struct AssertionResultData
+	{
+		AssertionResultData() = delete;
 
-        AssertionResultData( ResultWas::OfType _resultType, LazyExpression const& _lazyExpression );
+		AssertionResultData( ResultWas::OfType _resultType, LazyExpression const& _lazyExpression );
 
-        std::string message;
-        mutable std::string reconstructedExpression;
-        LazyExpression lazyExpression;
-        ResultWas::OfType resultType;
+		std::string message;
+		mutable std::string reconstructedExpression;
+		LazyExpression lazyExpression;
+		ResultWas::OfType resultType;
 
-        std::string reconstructExpression() const;
-    };
+		std::string reconstructExpression() const;
+	};
 
-    class AssertionResult {
-    public:
-        AssertionResult() = delete;
-        AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
+	class AssertionResult {
+	public:
+		AssertionResult() = delete;
+		AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
 
-        bool isOk() const;
-        bool succeeded() const;
-        ResultWas::OfType getResultType() const;
-        bool hasExpression() const;
-        bool hasMessage() const;
-        std::string getExpression() const;
-        std::string getExpressionInMacro() const;
-        bool hasExpandedExpression() const;
-        std::string getExpandedExpression() const;
-        std::string getMessage() const;
-        SourceLineInfo getSourceInfo() const;
-        std::string getTestMacroName() const;
+		bool isOk() const;
+		bool succeeded() const;
+		ResultWas::OfType getResultType() const;
+		bool hasExpression() const;
+		bool hasMessage() const;
+		std::string getExpression() const;
+		std::string getExpressionInMacro() const;
+		bool hasExpandedExpression() const;
+		std::string getExpandedExpression() const;
+		std::string getMessage() const;
+		SourceLineInfo getSourceInfo() const;
+		StringRef getTestMacroName() const;
 
-    //protected:
-        AssertionInfo m_info;
-        AssertionResultData m_resultData;
-    };
+		//protected:
+		AssertionInfo m_info;
+		AssertionResultData m_resultData;
+	};
 
 } // end namespace Catch
 
-// end catch_assertionresult.h
-// start catch_option.hpp
-
-namespace Catch {
-
-    // An optional type
-    template<typename T>
-    class Option {
-    public:
-        Option() : nullableValue( nullptr ) {}
-        Option( T const& _value )
-        : nullableValue( new( storage ) T( _value ) )
-        {}
-        Option( Option const& _other )
-        : nullableValue( _other ? new( storage ) T( *_other ) : nullptr )
-        {}
-
-        ~Option() {
-            reset();
-        }
-
-        Option& operator= ( Option const& _other ) {
-            if( &_other != this ) {
-                reset();
-                if( _other )
-                    nullableValue = new( storage ) T( *_other );
-            }
-            return *this;
-        }
-        Option& operator = ( T const& _value ) {
-            reset();
-            nullableValue = new( storage ) T( _value );
-            return *this;
-        }
-
-        void reset() {
-            if( nullableValue )
-                nullableValue->~T();
-            nullableValue = nullptr;
-        }
-
-        T& operator*() { return *nullableValue; }
-        T const& operator*() const { return *nullableValue; }
-        T* operator->() { return nullableValue; }
-        const T* operator->() const { return nullableValue; }
-
-        T valueOr( T const& defaultValue ) const {
-            return nullableValue ? *nullableValue : defaultValue;
-        }
-
-        bool some() const { return nullableValue != nullptr; }
-        bool none() const { return nullableValue == nullptr; }
-
-        bool operator !() const { return nullableValue == nullptr; }
-        explicit operator bool() const {
-            return some();
-        }
-
-    private:
-        T *nullableValue;
-        alignas(alignof(T)) char storage[sizeof(T)];
-    };
+  // end catch_assertionresult.h
+  // start catch_option.hpp
+
+namespace Catch {
+
+	// An optional type
+	template<typename T>
+	class Option {
+	public:
+		Option() : nullableValue( nullptr ) {}
+		Option( T const& _value )
+			: nullableValue( new( storage ) T( _value ) )
+		{}
+		Option( Option const& _other )
+			: nullableValue( _other ? new( storage ) T( *_other ) : nullptr )
+		{}
+
+		~Option() {
+			reset();
+		}
+
+		Option& operator= ( Option const& _other ) {
+			if( &_other != this ) {
+				reset();
+				if( _other )
+					nullableValue = new( storage ) T( *_other );
+			}
+			return *this;
+		}
+		Option& operator = ( T const& _value ) {
+			reset();
+			nullableValue = new( storage ) T( _value );
+			return *this;
+		}
+
+		void reset() {
+			if( nullableValue )
+				nullableValue->~T();
+			nullableValue = nullptr;
+		}
+
+		T& operator*() { return *nullableValue; }
+		T const& operator*() const { return *nullableValue; }
+		T* operator->() { return nullableValue; }
+		const T* operator->() const { return nullableValue; }
+
+		T valueOr( T const& defaultValue ) const {
+			return nullableValue ? *nullableValue : defaultValue;
+		}
+
+		bool some() const { return nullableValue != nullptr; }
+		bool none() const { return nullableValue == nullptr; }
+
+		bool operator !() const { return nullableValue == nullptr; }
+		explicit operator bool() const {
+			return some();
+		}
+
+	private:
+		T *nullableValue;
+		alignas(alignof(T)) char storage[sizeof(T)];
+	};
 
 } // end namespace Catch
 
-// end catch_option.hpp
+  // end catch_option.hpp
 #include <string>
 #include <iosfwd>
 #include <map>
@@ -3198,570 +4248,575 @@ namespace Catch {
 
 namespace Catch {
 
-    struct ReporterConfig {
-        explicit ReporterConfig( IConfigPtr const& _fullConfig );
-
-        ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream );
-
-        std::ostream& stream() const;
-        IConfigPtr fullConfig() const;
-
-    private:
-        std::ostream* m_stream;
-        IConfigPtr m_fullConfig;
-    };
-
-    struct ReporterPreferences {
-        bool shouldRedirectStdOut = false;
-    };
-
-    template<typename T>
-    struct LazyStat : Option<T> {
-        LazyStat& operator=( T const& _value ) {
-            Option<T>::operator=( _value );
-            used = false;
-            return *this;
-        }
-        void reset() {
-            Option<T>::reset();
-            used = false;
-        }
-        bool used = false;
-    };
-
-    struct TestRunInfo {
-        TestRunInfo( std::string const& _name );
-        std::string name;
-    };
-    struct GroupInfo {
-        GroupInfo(  std::string const& _name,
-                    std::size_t _groupIndex,
-                    std::size_t _groupsCount );
-
-        std::string name;
-        std::size_t groupIndex;
-        std::size_t groupsCounts;
-    };
-
-    struct AssertionStats {
-        AssertionStats( AssertionResult const& _assertionResult,
-                        std::vector<MessageInfo> const& _infoMessages,
-                        Totals const& _totals );
-
-        AssertionStats( AssertionStats const& )              = default;
-        AssertionStats( AssertionStats && )                  = default;
-        AssertionStats& operator = ( AssertionStats const& ) = default;
-        AssertionStats& operator = ( AssertionStats && )     = default;
-        virtual ~AssertionStats();
-
-        AssertionResult assertionResult;
-        std::vector<MessageInfo> infoMessages;
-        Totals totals;
-    };
-
-    struct SectionStats {
-        SectionStats(   SectionInfo const& _sectionInfo,
-                        Counts const& _assertions,
-                        double _durationInSeconds,
-                        bool _missingAssertions );
-        SectionStats( SectionStats const& )              = default;
-        SectionStats( SectionStats && )                  = default;
-        SectionStats& operator = ( SectionStats const& ) = default;
-        SectionStats& operator = ( SectionStats && )     = default;
-        virtual ~SectionStats();
-
-        SectionInfo sectionInfo;
-        Counts assertions;
-        double durationInSeconds;
-        bool missingAssertions;
-    };
-
-    struct TestCaseStats {
-        TestCaseStats(  TestCaseInfo const& _testInfo,
-                        Totals const& _totals,
-                        std::string const& _stdOut,
-                        std::string const& _stdErr,
-                        bool _aborting );
-
-        TestCaseStats( TestCaseStats const& )              = default;
-        TestCaseStats( TestCaseStats && )                  = default;
-        TestCaseStats& operator = ( TestCaseStats const& ) = default;
-        TestCaseStats& operator = ( TestCaseStats && )     = default;
-        virtual ~TestCaseStats();
-
-        TestCaseInfo testInfo;
-        Totals totals;
-        std::string stdOut;
-        std::string stdErr;
-        bool aborting;
-    };
-
-    struct TestGroupStats {
-        TestGroupStats( GroupInfo const& _groupInfo,
-                        Totals const& _totals,
-                        bool _aborting );
-        TestGroupStats( GroupInfo const& _groupInfo );
-
-        TestGroupStats( TestGroupStats const& )              = default;
-        TestGroupStats( TestGroupStats && )                  = default;
-        TestGroupStats& operator = ( TestGroupStats const& ) = default;
-        TestGroupStats& operator = ( TestGroupStats && )     = default;
-        virtual ~TestGroupStats();
-
-        GroupInfo groupInfo;
-        Totals totals;
-        bool aborting;
-    };
-
-    struct TestRunStats {
-        TestRunStats(   TestRunInfo const& _runInfo,
-                        Totals const& _totals,
-                        bool _aborting );
-
-        TestRunStats( TestRunStats const& )              = default;
-        TestRunStats( TestRunStats && )                  = default;
-        TestRunStats& operator = ( TestRunStats const& ) = default;
-        TestRunStats& operator = ( TestRunStats && )     = default;
-        virtual ~TestRunStats();
-
-        TestRunInfo runInfo;
-        Totals totals;
-        bool aborting;
-    };
-
-    struct BenchmarkInfo {
-        std::string name;
-    };
-    struct BenchmarkStats {
-        BenchmarkInfo info;
-        std::size_t iterations;
-        uint64_t elapsedTimeInNanoseconds;
-    };
-
-    struct IStreamingReporter {
-        virtual ~IStreamingReporter() = default;
-
-        // Implementing class must also provide the following static methods:
-        // static std::string getDescription();
-        // static std::set<Verbosity> getSupportedVerbosities()
-
-        virtual ReporterPreferences getPreferences() const = 0;
-
-        virtual void noMatchingTestCases( std::string const& spec ) = 0;
-
-        virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
-        virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0;
-
-        virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
-        virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;
-
-        // *** experimental ***
-        virtual void benchmarkStarting( BenchmarkInfo const& ) {}
-
-        virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
-
-        // The return value indicates if the messages buffer should be cleared:
-        virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0;
-
-        // *** experimental ***
-        virtual void benchmarkEnded( BenchmarkStats const& ) {}
-
-        virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
-        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
-        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0;
-        virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
-
-        virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
-
-        // Default empty implementation provided
-        virtual void fatalErrorEncountered( StringRef name );
-
-        virtual bool isMulti() const;
-    };
-    using IStreamingReporterPtr = std::unique_ptr<IStreamingReporter>;
-
-    struct IReporterFactory {
-        virtual ~IReporterFactory();
-        virtual IStreamingReporterPtr create( ReporterConfig const& config ) const = 0;
-        virtual std::string getDescription() const = 0;
-    };
-    using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
-
-    struct IReporterRegistry {
-        using FactoryMap = std::map<std::string, IReporterFactoryPtr>;
-        using Listeners = std::vector<IReporterFactoryPtr>;
-
-        virtual ~IReporterRegistry();
-        virtual IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const = 0;
-        virtual FactoryMap const& getFactories() const = 0;
-        virtual Listeners const& getListeners() const = 0;
-    };
-
-    void addReporter( IStreamingReporterPtr& existingReporter, IStreamingReporterPtr&& additionalReporter );
+	struct ReporterConfig {
+		explicit ReporterConfig( IConfigPtr const& _fullConfig );
+
+		ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream );
+
+		std::ostream& stream() const;
+		IConfigPtr fullConfig() const;
+
+	private:
+		std::ostream* m_stream;
+		IConfigPtr m_fullConfig;
+	};
+
+	struct ReporterPreferences {
+		bool shouldRedirectStdOut = false;
+		bool shouldReportAllAssertions = false;
+	};
+
+	template<typename T>
+	struct LazyStat : Option<T> {
+		LazyStat& operator=( T const& _value ) {
+			Option<T>::operator=( _value );
+			used = false;
+			return *this;
+		}
+		void reset() {
+			Option<T>::reset();
+			used = false;
+		}
+		bool used = false;
+	};
+
+	struct TestRunInfo {
+		TestRunInfo( std::string const& _name );
+		std::string name;
+	};
+	struct GroupInfo {
+		GroupInfo(  std::string const& _name,
+			std::size_t _groupIndex,
+			std::size_t _groupsCount );
+
+		std::string name;
+		std::size_t groupIndex;
+		std::size_t groupsCounts;
+	};
+
+	struct AssertionStats {
+		AssertionStats( AssertionResult const& _assertionResult,
+			std::vector<MessageInfo> const& _infoMessages,
+			Totals const& _totals );
+
+		AssertionStats( AssertionStats const& )              = default;
+		AssertionStats( AssertionStats && )                  = default;
+		AssertionStats& operator = ( AssertionStats const& ) = default;
+		AssertionStats& operator = ( AssertionStats && )     = default;
+		virtual ~AssertionStats();
+
+		AssertionResult assertionResult;
+		std::vector<MessageInfo> infoMessages;
+		Totals totals;
+	};
+
+	struct SectionStats {
+		SectionStats(   SectionInfo const& _sectionInfo,
+			Counts const& _assertions,
+			double _durationInSeconds,
+			bool _missingAssertions );
+		SectionStats( SectionStats const& )              = default;
+		SectionStats( SectionStats && )                  = default;
+		SectionStats& operator = ( SectionStats const& ) = default;
+		SectionStats& operator = ( SectionStats && )     = default;
+		virtual ~SectionStats();
+
+		SectionInfo sectionInfo;
+		Counts assertions;
+		double durationInSeconds;
+		bool missingAssertions;
+	};
+
+	struct TestCaseStats {
+		TestCaseStats(  TestCaseInfo const& _testInfo,
+			Totals const& _totals,
+			std::string const& _stdOut,
+			std::string const& _stdErr,
+			bool _aborting );
+
+		TestCaseStats( TestCaseStats const& )              = default;
+		TestCaseStats( TestCaseStats && )                  = default;
+		TestCaseStats& operator = ( TestCaseStats const& ) = default;
+		TestCaseStats& operator = ( TestCaseStats && )     = default;
+		virtual ~TestCaseStats();
+
+		TestCaseInfo testInfo;
+		Totals totals;
+		std::string stdOut;
+		std::string stdErr;
+		bool aborting;
+	};
+
+	struct TestGroupStats {
+		TestGroupStats( GroupInfo const& _groupInfo,
+			Totals const& _totals,
+			bool _aborting );
+		TestGroupStats( GroupInfo const& _groupInfo );
+
+		TestGroupStats( TestGroupStats const& )              = default;
+		TestGroupStats( TestGroupStats && )                  = default;
+		TestGroupStats& operator = ( TestGroupStats const& ) = default;
+		TestGroupStats& operator = ( TestGroupStats && )     = default;
+		virtual ~TestGroupStats();
+
+		GroupInfo groupInfo;
+		Totals totals;
+		bool aborting;
+	};
+
+	struct TestRunStats {
+		TestRunStats(   TestRunInfo const& _runInfo,
+			Totals const& _totals,
+			bool _aborting );
+
+		TestRunStats( TestRunStats const& )              = default;
+		TestRunStats( TestRunStats && )                  = default;
+		TestRunStats& operator = ( TestRunStats const& ) = default;
+		TestRunStats& operator = ( TestRunStats && )     = default;
+		virtual ~TestRunStats();
+
+		TestRunInfo runInfo;
+		Totals totals;
+		bool aborting;
+	};
+
+	struct BenchmarkInfo {
+		std::string name;
+	};
+	struct BenchmarkStats {
+		BenchmarkInfo info;
+		std::size_t iterations;
+		uint64_t elapsedTimeInNanoseconds;
+	};
+
+	struct IStreamingReporter {
+		virtual ~IStreamingReporter() = default;
+
+		// Implementing class must also provide the following static methods:
+		// static std::string getDescription();
+		// static std::set<Verbosity> getSupportedVerbosities()
+
+		virtual ReporterPreferences getPreferences() const = 0;
+
+		virtual void noMatchingTestCases( std::string const& spec ) = 0;
+
+		virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
+		virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0;
+
+		virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
+		virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;
+
+		// *** experimental ***
+		virtual void benchmarkStarting( BenchmarkInfo const& ) {}
+
+		virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
+
+		// The return value indicates if the messages buffer should be cleared:
+		virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0;
+
+		// *** experimental ***
+		virtual void benchmarkEnded( BenchmarkStats const& ) {}
+
+		virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
+		virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
+		virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0;
+		virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
+
+		virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
+
+		// Default empty implementation provided
+		virtual void fatalErrorEncountered( StringRef name );
+
+		virtual bool isMulti() const;
+	};
+	using IStreamingReporterPtr = std::unique_ptr<IStreamingReporter>;
+
+	struct IReporterFactory {
+		virtual ~IReporterFactory();
+		virtual IStreamingReporterPtr create( ReporterConfig const& config ) const = 0;
+		virtual std::string getDescription() const = 0;
+	};
+	using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
+
+	struct IReporterRegistry {
+		using FactoryMap = std::map<std::string, IReporterFactoryPtr>;
+		using Listeners = std::vector<IReporterFactoryPtr>;
+
+		virtual ~IReporterRegistry();
+		virtual IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const = 0;
+		virtual FactoryMap const& getFactories() const = 0;
+		virtual Listeners const& getListeners() const = 0;
+	};
 
 } // end namespace Catch
 
-// end catch_interfaces_reporter.h
+  // end catch_interfaces_reporter.h
 #include <algorithm>
 #include <cstring>
 #include <cfloat>
 #include <cstdio>
-#include <assert.h>
+#include <cassert>
 #include <memory>
+#include <ostream>
 
 namespace Catch {
-    void prepareExpandedExpression(AssertionResult& result);
-
-    // Returns double formatted as %.3f (format expected on output)
-    std::string getFormattedDuration( double duration );
-
-    template<typename DerivedT>
-    struct StreamingReporterBase : IStreamingReporter {
-
-        StreamingReporterBase( ReporterConfig const& _config )
-        :   m_config( _config.fullConfig() ),
-            stream( _config.stream() )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = false;
-            CATCH_ENFORCE( DerivedT::getSupportedVerbosities().count( m_config->verbosity() ), "Verbosity level not supported by this reporter" );
-        }
-
-        ReporterPreferences getPreferences() const override {
-            return m_reporterPrefs;
-        }
-
-        static std::set<Verbosity> getSupportedVerbosities() {
-            return { Verbosity::Normal };
-        }
-
-        ~StreamingReporterBase() override = default;
-
-        void noMatchingTestCases(std::string const&) override {}
-
-        void testRunStarting(TestRunInfo const& _testRunInfo) override {
-            currentTestRunInfo = _testRunInfo;
-        }
-        void testGroupStarting(GroupInfo const& _groupInfo) override {
-            currentGroupInfo = _groupInfo;
-        }
-
-        void testCaseStarting(TestCaseInfo const& _testInfo) override  {
-            currentTestCaseInfo = _testInfo;
-        }
-        void sectionStarting(SectionInfo const& _sectionInfo) override {
-            m_sectionStack.push_back(_sectionInfo);
-        }
-
-        void sectionEnded(SectionStats const& /* _sectionStats */) override {
-            m_sectionStack.pop_back();
-        }
-        void testCaseEnded(TestCaseStats const& /* _testCaseStats */) override {
-            currentTestCaseInfo.reset();
-        }
-        void testGroupEnded(TestGroupStats const& /* _testGroupStats */) override {
-            currentGroupInfo.reset();
-        }
-        void testRunEnded(TestRunStats const& /* _testRunStats */) override {
-            currentTestCaseInfo.reset();
-            currentGroupInfo.reset();
-            currentTestRunInfo.reset();
-        }
-
-        void skipTest(TestCaseInfo const&) override {
-            // Don't do anything with this by default.
-            // It can optionally be overridden in the derived class.
-        }
-
-        IConfigPtr m_config;
-        std::ostream& stream;
-
-        LazyStat<TestRunInfo> currentTestRunInfo;
-        LazyStat<GroupInfo> currentGroupInfo;
-        LazyStat<TestCaseInfo> currentTestCaseInfo;
-
-        std::vector<SectionInfo> m_sectionStack;
-        ReporterPreferences m_reporterPrefs;
-    };
-
-    template<typename DerivedT>
-    struct CumulativeReporterBase : IStreamingReporter {
-        template<typename T, typename ChildNodeT>
-        struct Node {
-            explicit Node( T const& _value ) : value( _value ) {}
-            virtual ~Node() {}
-
-            using ChildNodes = std::vector<std::shared_ptr<ChildNodeT>>;
-            T value;
-            ChildNodes children;
-        };
-        struct SectionNode {
-            explicit SectionNode(SectionStats const& _stats) : stats(_stats) {}
-            virtual ~SectionNode() = default;
-
-            bool operator == (SectionNode const& other) const {
-                return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
-            }
-            bool operator == (std::shared_ptr<SectionNode> const& other) const {
-                return operator==(*other);
-            }
-
-            SectionStats stats;
-            using ChildSections = std::vector<std::shared_ptr<SectionNode>>;
-            using Assertions = std::vector<AssertionStats>;
-            ChildSections childSections;
-            Assertions assertions;
-            std::string stdOut;
-            std::string stdErr;
-        };
-
-        struct BySectionInfo {
-            BySectionInfo( SectionInfo const& other ) : m_other( other ) {}
-            BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {}
-            bool operator() (std::shared_ptr<SectionNode> const& node) const {
-                return ((node->stats.sectionInfo.name == m_other.name) &&
-                        (node->stats.sectionInfo.lineInfo == m_other.lineInfo));
-            }
-            void operator=(BySectionInfo const&) = delete;
-
-        private:
-            SectionInfo const& m_other;
-        };
-
-        using TestCaseNode = Node<TestCaseStats, SectionNode>;
-        using TestGroupNode = Node<TestGroupStats, TestCaseNode>;
-        using TestRunNode = Node<TestRunStats, TestGroupNode>;
-
-        CumulativeReporterBase( ReporterConfig const& _config )
-        :   m_config( _config.fullConfig() ),
-            stream( _config.stream() )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = false;
-            CATCH_ENFORCE( DerivedT::getSupportedVerbosities().count( m_config->verbosity() ), "Verbosity level not supported by this reporter" );
-        }
-        ~CumulativeReporterBase() override = default;
-
-        ReporterPreferences getPreferences() const override {
-            return m_reporterPrefs;
-        }
-
-        static std::set<Verbosity> getSupportedVerbosities() {
-            return { Verbosity::Normal };
-        }
-
-        void testRunStarting( TestRunInfo const& ) override {}
-        void testGroupStarting( GroupInfo const& ) override {}
-
-        void testCaseStarting( TestCaseInfo const& ) override {}
-
-        void sectionStarting( SectionInfo const& sectionInfo ) override {
-            SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
-            std::shared_ptr<SectionNode> node;
-            if( m_sectionStack.empty() ) {
-                if( !m_rootSection )
-                    m_rootSection = std::make_shared<SectionNode>( incompleteStats );
-                node = m_rootSection;
-            }
-            else {
-                SectionNode& parentNode = *m_sectionStack.back();
-                auto it =
-                    std::find_if(   parentNode.childSections.begin(),
-                                    parentNode.childSections.end(),
-                                    BySectionInfo( sectionInfo ) );
-                if( it == parentNode.childSections.end() ) {
-                    node = std::make_shared<SectionNode>( incompleteStats );
-                    parentNode.childSections.push_back( node );
-                }
-                else
-                    node = *it;
-            }
-            m_sectionStack.push_back( node );
-            m_deepestSection = std::move(node);
-        }
-
-        void assertionStarting(AssertionInfo const&) override {}
-
-        bool assertionEnded(AssertionStats const& assertionStats) override {
-            assert(!m_sectionStack.empty());
-            // AssertionResult holds a pointer to a temporary DecomposedExpression,
-            // which getExpandedExpression() calls to build the expression string.
-            // Our section stack copy of the assertionResult will likely outlive the
-            // temporary, so it must be expanded or discarded now to avoid calling
-            // a destroyed object later.
-            prepareExpandedExpression(const_cast<AssertionResult&>( assertionStats.assertionResult ) );
-            SectionNode& sectionNode = *m_sectionStack.back();
-            sectionNode.assertions.push_back(assertionStats);
-            return true;
-        }
-        void sectionEnded(SectionStats const& sectionStats) override {
-            assert(!m_sectionStack.empty());
-            SectionNode& node = *m_sectionStack.back();
-            node.stats = sectionStats;
-            m_sectionStack.pop_back();
-        }
-        void testCaseEnded(TestCaseStats const& testCaseStats) override {
-            auto node = std::make_shared<TestCaseNode>(testCaseStats);
-            assert(m_sectionStack.size() == 0);
-            node->children.push_back(m_rootSection);
-            m_testCases.push_back(node);
-            m_rootSection.reset();
-
-            assert(m_deepestSection);
-            m_deepestSection->stdOut = testCaseStats.stdOut;
-            m_deepestSection->stdErr = testCaseStats.stdErr;
-        }
-        void testGroupEnded(TestGroupStats const& testGroupStats) override {
-            auto node = std::make_shared<TestGroupNode>(testGroupStats);
-            node->children.swap(m_testCases);
-            m_testGroups.push_back(node);
-        }
-        void testRunEnded(TestRunStats const& testRunStats) override {
-            auto node = std::make_shared<TestRunNode>(testRunStats);
-            node->children.swap(m_testGroups);
-            m_testRuns.push_back(node);
-            testRunEndedCumulative();
-        }
-        virtual void testRunEndedCumulative() = 0;
-
-        void skipTest(TestCaseInfo const&) override {}
-
-        IConfigPtr m_config;
-        std::ostream& stream;
-        std::vector<AssertionStats> m_assertions;
-        std::vector<std::vector<std::shared_ptr<SectionNode>>> m_sections;
-        std::vector<std::shared_ptr<TestCaseNode>> m_testCases;
-        std::vector<std::shared_ptr<TestGroupNode>> m_testGroups;
-
-        std::vector<std::shared_ptr<TestRunNode>> m_testRuns;
-
-        std::shared_ptr<SectionNode> m_rootSection;
-        std::shared_ptr<SectionNode> m_deepestSection;
-        std::vector<std::shared_ptr<SectionNode>> m_sectionStack;
-        ReporterPreferences m_reporterPrefs;
-    };
-
-    template<char C>
-    char const* getLineOfChars() {
-        static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
-        if( !*line ) {
-            std::memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 );
-            line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0;
-        }
-        return line;
-    }
-
-    struct TestEventListenerBase : StreamingReporterBase<TestEventListenerBase> {
-        TestEventListenerBase( ReporterConfig const& _config );
-
-        void assertionStarting(AssertionInfo const&) override;
-        bool assertionEnded(AssertionStats const&) override;
-    };
+	void prepareExpandedExpression(AssertionResult& result);
+
+	// Returns double formatted as %.3f (format expected on output)
+	std::string getFormattedDuration( double duration );
+
+	template<typename DerivedT>
+	struct StreamingReporterBase : IStreamingReporter {
+
+		StreamingReporterBase( ReporterConfig const& _config )
+			:   m_config( _config.fullConfig() ),
+			stream( _config.stream() )
+		{
+			m_reporterPrefs.shouldRedirectStdOut = false;
+			if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
+				CATCH_ERROR( "Verbosity level not supported by this reporter" );
+		}
+
+		ReporterPreferences getPreferences() const override {
+			return m_reporterPrefs;
+		}
+
+		static std::set<Verbosity> getSupportedVerbosities() {
+			return { Verbosity::Normal };
+		}
+
+		~StreamingReporterBase() override = default;
+
+		void noMatchingTestCases(std::string const&) override {}
+
+		void testRunStarting(TestRunInfo const& _testRunInfo) override {
+			currentTestRunInfo = _testRunInfo;
+		}
+		void testGroupStarting(GroupInfo const& _groupInfo) override {
+			currentGroupInfo = _groupInfo;
+		}
+
+		void testCaseStarting(TestCaseInfo const& _testInfo) override  {
+			currentTestCaseInfo = _testInfo;
+		}
+		void sectionStarting(SectionInfo const& _sectionInfo) override {
+			m_sectionStack.push_back(_sectionInfo);
+		}
+
+		void sectionEnded(SectionStats const& /* _sectionStats */) override {
+			m_sectionStack.pop_back();
+		}
+		void testCaseEnded(TestCaseStats const& /* _testCaseStats */) override {
+			currentTestCaseInfo.reset();
+		}
+		void testGroupEnded(TestGroupStats const& /* _testGroupStats */) override {
+			currentGroupInfo.reset();
+		}
+		void testRunEnded(TestRunStats const& /* _testRunStats */) override {
+			currentTestCaseInfo.reset();
+			currentGroupInfo.reset();
+			currentTestRunInfo.reset();
+		}
+
+		void skipTest(TestCaseInfo const&) override {
+			// Don't do anything with this by default.
+			// It can optionally be overridden in the derived class.
+		}
+
+		IConfigPtr m_config;
+		std::ostream& stream;
+
+		LazyStat<TestRunInfo> currentTestRunInfo;
+		LazyStat<GroupInfo> currentGroupInfo;
+		LazyStat<TestCaseInfo> currentTestCaseInfo;
+
+		std::vector<SectionInfo> m_sectionStack;
+		ReporterPreferences m_reporterPrefs;
+	};
+
+	template<typename DerivedT>
+	struct CumulativeReporterBase : IStreamingReporter {
+		template<typename T, typename ChildNodeT>
+		struct Node {
+			explicit Node( T const& _value ) : value( _value ) {}
+			virtual ~Node() {}
+
+			using ChildNodes = std::vector<std::shared_ptr<ChildNodeT>>;
+			T value;
+			ChildNodes children;
+		};
+		struct SectionNode {
+			explicit SectionNode(SectionStats const& _stats) : stats(_stats) {}
+			virtual ~SectionNode() = default;
+
+			bool operator == (SectionNode const& other) const {
+				return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
+			}
+			bool operator == (std::shared_ptr<SectionNode> const& other) const {
+				return operator==(*other);
+			}
+
+			SectionStats stats;
+			using ChildSections = std::vector<std::shared_ptr<SectionNode>>;
+			using Assertions = std::vector<AssertionStats>;
+			ChildSections childSections;
+			Assertions assertions;
+			std::string stdOut;
+			std::string stdErr;
+		};
+
+		struct BySectionInfo {
+			BySectionInfo( SectionInfo const& other ) : m_other( other ) {}
+			BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {}
+			bool operator() (std::shared_ptr<SectionNode> const& node) const {
+				return ((node->stats.sectionInfo.name == m_other.name) &&
+					(node->stats.sectionInfo.lineInfo == m_other.lineInfo));
+			}
+			void operator=(BySectionInfo const&) = delete;
+
+		private:
+			SectionInfo const& m_other;
+		};
+
+		using TestCaseNode = Node<TestCaseStats, SectionNode>;
+		using TestGroupNode = Node<TestGroupStats, TestCaseNode>;
+		using TestRunNode = Node<TestRunStats, TestGroupNode>;
+
+		CumulativeReporterBase( ReporterConfig const& _config )
+			:   m_config( _config.fullConfig() ),
+			stream( _config.stream() )
+		{
+			m_reporterPrefs.shouldRedirectStdOut = false;
+			if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
+				CATCH_ERROR( "Verbosity level not supported by this reporter" );
+		}
+		~CumulativeReporterBase() override = default;
+
+		ReporterPreferences getPreferences() const override {
+			return m_reporterPrefs;
+		}
+
+		static std::set<Verbosity> getSupportedVerbosities() {
+			return { Verbosity::Normal };
+		}
+
+		void testRunStarting( TestRunInfo const& ) override {}
+		void testGroupStarting( GroupInfo const& ) override {}
+
+		void testCaseStarting( TestCaseInfo const& ) override {}
+
+		void sectionStarting( SectionInfo const& sectionInfo ) override {
+			SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
+			std::shared_ptr<SectionNode> node;
+			if( m_sectionStack.empty() ) {
+				if( !m_rootSection )
+					m_rootSection = std::make_shared<SectionNode>( incompleteStats );
+				node = m_rootSection;
+			}
+			else {
+				SectionNode& parentNode = *m_sectionStack.back();
+				auto it =
+					std::find_if(   parentNode.childSections.begin(),
+						parentNode.childSections.end(),
+						BySectionInfo( sectionInfo ) );
+				if( it == parentNode.childSections.end() ) {
+					node = std::make_shared<SectionNode>( incompleteStats );
+					parentNode.childSections.push_back( node );
+				}
+				else
+					node = *it;
+			}
+			m_sectionStack.push_back( node );
+			m_deepestSection = std::move(node);
+		}
+
+		void assertionStarting(AssertionInfo const&) override {}
+
+		bool assertionEnded(AssertionStats const& assertionStats) override {
+			assert(!m_sectionStack.empty());
+			// AssertionResult holds a pointer to a temporary DecomposedExpression,
+			// which getExpandedExpression() calls to build the expression string.
+			// Our section stack copy of the assertionResult will likely outlive the
+			// temporary, so it must be expanded or discarded now to avoid calling
+			// a destroyed object later.
+			prepareExpandedExpression(const_cast<AssertionResult&>( assertionStats.assertionResult ) );
+			SectionNode& sectionNode = *m_sectionStack.back();
+			sectionNode.assertions.push_back(assertionStats);
+			return true;
+		}
+		void sectionEnded(SectionStats const& sectionStats) override {
+			assert(!m_sectionStack.empty());
+			SectionNode& node = *m_sectionStack.back();
+			node.stats = sectionStats;
+			m_sectionStack.pop_back();
+		}
+		void testCaseEnded(TestCaseStats const& testCaseStats) override {
+			auto node = std::make_shared<TestCaseNode>(testCaseStats);
+			assert(m_sectionStack.size() == 0);
+			node->children.push_back(m_rootSection);
+			m_testCases.push_back(node);
+			m_rootSection.reset();
+
+			assert(m_deepestSection);
+			m_deepestSection->stdOut = testCaseStats.stdOut;
+			m_deepestSection->stdErr = testCaseStats.stdErr;
+		}
+		void testGroupEnded(TestGroupStats const& testGroupStats) override {
+			auto node = std::make_shared<TestGroupNode>(testGroupStats);
+			node->children.swap(m_testCases);
+			m_testGroups.push_back(node);
+		}
+		void testRunEnded(TestRunStats const& testRunStats) override {
+			auto node = std::make_shared<TestRunNode>(testRunStats);
+			node->children.swap(m_testGroups);
+			m_testRuns.push_back(node);
+			testRunEndedCumulative();
+		}
+		virtual void testRunEndedCumulative() = 0;
+
+		void skipTest(TestCaseInfo const&) override {}
+
+		IConfigPtr m_config;
+		std::ostream& stream;
+		std::vector<AssertionStats> m_assertions;
+		std::vector<std::vector<std::shared_ptr<SectionNode>>> m_sections;
+		std::vector<std::shared_ptr<TestCaseNode>> m_testCases;
+		std::vector<std::shared_ptr<TestGroupNode>> m_testGroups;
+
+		std::vector<std::shared_ptr<TestRunNode>> m_testRuns;
+
+		std::shared_ptr<SectionNode> m_rootSection;
+		std::shared_ptr<SectionNode> m_deepestSection;
+		std::vector<std::shared_ptr<SectionNode>> m_sectionStack;
+		ReporterPreferences m_reporterPrefs;
+	};
+
+	template<char C>
+	char const* getLineOfChars() {
+		static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
+		if( !*line ) {
+			std::memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 );
+			line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0;
+		}
+		return line;
+	}
+
+	struct TestEventListenerBase : StreamingReporterBase<TestEventListenerBase> {
+		TestEventListenerBase( ReporterConfig const& _config );
+
+		static std::set<Verbosity> getSupportedVerbosities();
+
+		void assertionStarting(AssertionInfo const&) override;
+		bool assertionEnded(AssertionStats const&) override;
+	};
 
 } // end namespace Catch
 
-// end catch_reporter_bases.hpp
-// start catch_console_colour.h
+  // end catch_reporter_bases.hpp
+  // start catch_console_colour.h
 
 namespace Catch {
 
-    struct Colour {
-        enum Code {
-            None = 0,
+	struct Colour {
+		enum Code {
+			None = 0,
 
-            White,
-            Red,
-            Green,
-            Blue,
-            Cyan,
-            Yellow,
-            Grey,
+			White,
+			Red,
+			Green,
+			Blue,
+			Cyan,
+			Yellow,
+			Grey,
 
-            Bright = 0x10,
+			Bright = 0x10,
 
-            BrightRed = Bright | Red,
-            BrightGreen = Bright | Green,
-            LightGrey = Bright | Grey,
-            BrightWhite = Bright | White,
+			BrightRed = Bright | Red,
+			BrightGreen = Bright | Green,
+			LightGrey = Bright | Grey,
+			BrightWhite = Bright | White,
+			BrightYellow = Bright | Yellow,
 
-            // By intention
-            FileName = LightGrey,
-            Warning = Yellow,
-            ResultError = BrightRed,
-            ResultSuccess = BrightGreen,
-            ResultExpectedFailure = Warning,
+			// By intention
+			FileName = LightGrey,
+			Warning = BrightYellow,
+			ResultError = BrightRed,
+			ResultSuccess = BrightGreen,
+			ResultExpectedFailure = Warning,
 
-            Error = BrightRed,
-            Success = Green,
+			Error = BrightRed,
+			Success = Green,
 
-            OriginalExpression = Cyan,
-            ReconstructedExpression = Yellow,
+			OriginalExpression = Cyan,
+			ReconstructedExpression = BrightYellow,
 
-            SecondaryText = LightGrey,
-            Headers = White
-        };
+			SecondaryText = LightGrey,
+			Headers = White
+		};
 
-        // Use constructed object for RAII guard
-        Colour( Code _colourCode );
-        Colour( Colour&& other ) noexcept;
-        Colour& operator=( Colour&& other ) noexcept;
-        ~Colour();
+		// Use constructed object for RAII guard
+		Colour( Code _colourCode );
+		Colour( Colour&& other ) noexcept;
+		Colour& operator=( Colour&& other ) noexcept;
+		~Colour();
 
-        // Use static method for one-shot changes
-        static void use( Code _colourCode );
+		// Use static method for one-shot changes
+		static void use( Code _colourCode );
 
-    private:
-        bool m_moved = false;
-    };
+	private:
+		bool m_moved = false;
+	};
 
-    std::ostream& operator << ( std::ostream& os, Colour const& );
+	std::ostream& operator << ( std::ostream& os, Colour const& );
 
 } // end namespace Catch
 
-// end catch_console_colour.h
-// start catch_reporter_registrars.hpp
+  // end catch_console_colour.h
+  // start catch_reporter_registrars.hpp
 
 
 namespace Catch {
 
-    template<typename T>
-    class ReporterRegistrar {
+	template<typename T>
+	class ReporterRegistrar {
 
-        class ReporterFactory : public IReporterFactory {
+		class ReporterFactory : public IReporterFactory {
 
-            virtual IStreamingReporterPtr create( ReporterConfig const& config ) const override {
-                return std::unique_ptr<T>( new T( config ) );
-            }
+			virtual IStreamingReporterPtr create( ReporterConfig const& config ) const override {
+				return std::unique_ptr<T>( new T( config ) );
+			}
 
-            virtual std::string getDescription() const override {
-                return T::getDescription();
-            }
-        };
+			virtual std::string getDescription() const override {
+				return T::getDescription();
+			}
+		};
 
-    public:
+	public:
 
-        ReporterRegistrar( std::string const& name ) {
-            getMutableRegistryHub().registerReporter( name, std::make_shared<ReporterFactory>() );
-        }
-    };
+		explicit ReporterRegistrar( std::string const& name ) {
+			getMutableRegistryHub().registerReporter( name, std::make_shared<ReporterFactory>() );
+		}
+	};
 
-    template<typename T>
-    class ListenerRegistrar {
+	template<typename T>
+	class ListenerRegistrar {
 
-        class ListenerFactory : public IReporterFactory {
+		class ListenerFactory : public IReporterFactory {
 
-            virtual IStreamingReporterPtr create( ReporterConfig const& config ) const override {
-                return std::unique_ptr<T>( new T( config ) );
-            }
-            virtual std::string getDescription() const override {
-                return std::string();
-            }
-        };
+			virtual IStreamingReporterPtr create( ReporterConfig const& config ) const override {
+				return std::unique_ptr<T>( new T( config ) );
+			}
+			virtual std::string getDescription() const override {
+				return std::string();
+			}
+		};
 
-    public:
+	public:
 
-        ListenerRegistrar() {
-            getMutableRegistryHub().registerListener( std::make_shared<ListenerFactory>() );
-        }
-    };
+		ListenerRegistrar() {
+			getMutableRegistryHub().registerListener( std::make_shared<ListenerFactory>() );
+		}
+	};
 }
 
 #if !defined(CATCH_CONFIG_DISABLE)
@@ -3783,2112 +4838,663 @@ namespace Catch {
 #endif // CATCH_CONFIG_DISABLE
 
 // end catch_reporter_registrars.hpp
-// end catch_external_interfaces.h
-#endif
+// Allow users to base their work off existing reporters
+// start catch_reporter_compact.h
 
-#ifdef CATCH_IMPL
-// start catch_impl.hpp
+namespace Catch {
 
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wweak-vtables"
-#endif
+	struct CompactReporter : StreamingReporterBase<CompactReporter> {
 
-// Keep these here for external reporters
-// start catch_test_case_tracker.h
+		using StreamingReporterBase::StreamingReporterBase;
 
-#include <string>
-#include <vector>
-#include <memory>
+		~CompactReporter() override;
 
-namespace Catch {
-namespace TestCaseTracking {
+		static std::string getDescription();
 
-    struct NameAndLocation {
-        std::string name;
-        SourceLineInfo location;
+		ReporterPreferences getPreferences() const override;
 
-        NameAndLocation( std::string const& _name, SourceLineInfo const& _location );
-    };
+		void noMatchingTestCases(std::string const& spec) override;
 
-    struct ITracker;
+		void assertionStarting(AssertionInfo const&) override;
 
-    using ITrackerPtr = std::shared_ptr<ITracker>;
+		bool assertionEnded(AssertionStats const& _assertionStats) override;
 
-    struct ITracker {
-        virtual ~ITracker();
+		void sectionEnded(SectionStats const& _sectionStats) override;
 
-        // static queries
-        virtual NameAndLocation const& nameAndLocation() const = 0;
+		void testRunEnded(TestRunStats const& _testRunStats) override;
 
-        // dynamic queries
-        virtual bool isComplete() const = 0; // Successfully completed or failed
-        virtual bool isSuccessfullyCompleted() const = 0;
-        virtual bool isOpen() const = 0; // Started but not complete
-        virtual bool hasChildren() const = 0;
+	};
 
-        virtual ITracker& parent() = 0;
+} // end namespace Catch
 
-        // actions
-        virtual void close() = 0; // Successfully complete
-        virtual void fail() = 0;
-        virtual void markAsNeedingAnotherRun() = 0;
+  // end catch_reporter_compact.h
+  // start catch_reporter_console.h
 
-        virtual void addChild( ITrackerPtr const& child ) = 0;
-        virtual ITrackerPtr findChild( NameAndLocation const& nameAndLocation ) = 0;
-        virtual void openChild() = 0;
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
+  // Note that 4062 (not all labels are handled
+  // and default is missing) is enabled
+#endif
 
-        // Debug/ checking
-        virtual bool isSectionTracker() const = 0;
-        virtual bool isIndexTracker() const = 0;
-    };
+namespace Catch {
+	// Fwd decls
+	struct SummaryColumn;
+	class TablePrinter;
 
-    class TrackerContext {
+	struct ConsoleReporter : StreamingReporterBase<ConsoleReporter> {
+		std::unique_ptr<TablePrinter> m_tablePrinter;
 
-        enum RunState {
-            NotStarted,
-            Executing,
-            CompletedCycle
-        };
+		ConsoleReporter(ReporterConfig const& config);
+		~ConsoleReporter() override;
+		static std::string getDescription();
 
-        ITrackerPtr m_rootTracker;
-        ITracker* m_currentTracker = nullptr;
-        RunState m_runState = NotStarted;
+		void noMatchingTestCases(std::string const& spec) override;
 
-    public:
+		void assertionStarting(AssertionInfo const&) override;
 
-        static TrackerContext& instance();
+		bool assertionEnded(AssertionStats const& _assertionStats) override;
 
-        ITracker& startRun();
-        void endRun();
+		void sectionStarting(SectionInfo const& _sectionInfo) override;
+		void sectionEnded(SectionStats const& _sectionStats) override;
 
-        void startCycle();
-        void completeCycle();
+		void benchmarkStarting(BenchmarkInfo const& info) override;
+		void benchmarkEnded(BenchmarkStats const& stats) override;
 
-        bool completedCycle() const;
-        ITracker& currentTracker();
-        void setCurrentTracker( ITracker* tracker );
-    };
+		void testCaseEnded(TestCaseStats const& _testCaseStats) override;
+		void testGroupEnded(TestGroupStats const& _testGroupStats) override;
+		void testRunEnded(TestRunStats const& _testRunStats) override;
 
-    class TrackerBase : public ITracker {
-    protected:
-        enum CycleState {
-            NotStarted,
-            Executing,
-            ExecutingChildren,
-            NeedsAnotherRun,
-            CompletedSuccessfully,
-            Failed
-        };
+	private:
 
-        class TrackerHasName {
-            NameAndLocation m_nameAndLocation;
-        public:
-            TrackerHasName( NameAndLocation const& nameAndLocation );
-            bool operator ()( ITrackerPtr const& tracker ) const;
-        };
+		void lazyPrint();
 
-        using Children = std::vector<ITrackerPtr>;
-        NameAndLocation m_nameAndLocation;
-        TrackerContext& m_ctx;
-        ITracker* m_parent;
-        Children m_children;
-        CycleState m_runState = NotStarted;
+		void lazyPrintWithoutClosingBenchmarkTable();
+		void lazyPrintRunInfo();
+		void lazyPrintGroupInfo();
+		void printTestCaseAndSectionHeader();
 
-    public:
-        TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
+		void printClosedHeader(std::string const& _name);
+		void printOpenHeader(std::string const& _name);
 
-        NameAndLocation const& nameAndLocation() const override;
-        bool isComplete() const override;
-        bool isSuccessfullyCompleted() const override;
-        bool isOpen() const override;
-        bool hasChildren() const override;
+		// if string has a : in first line will set indent to follow it on
+		// subsequent lines
+		void printHeaderString(std::string const& _string, std::size_t indent = 0);
 
-        void addChild( ITrackerPtr const& child ) override;
+		void printTotals(Totals const& totals);
+		void printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row);
 
-        ITrackerPtr findChild( NameAndLocation const& nameAndLocation ) override;
-        ITracker& parent() override;
+		void printTotalsDivider(Totals const& totals);
+		void printSummaryDivider();
 
-        void openChild() override;
+	private:
+		bool m_headerPrinted = false;
+	};
 
-        bool isSectionTracker() const override;
-        bool isIndexTracker() const override;
+} // end namespace Catch
 
-        void open();
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
 
-        void close() override;
-        void fail() override;
-        void markAsNeedingAnotherRun() override;
+  // end catch_reporter_console.h
+  // start catch_reporter_junit.h
 
-    private:
-        void moveToParent();
-        void moveToThis();
-    };
+  // start catch_xmlwriter.h
 
-    class SectionTracker : public TrackerBase {
-        std::vector<std::string> m_filters;
-    public:
-        SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
+#include <vector>
 
-        bool isSectionTracker() const override;
+namespace Catch {
 
-        static SectionTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation );
+	class XmlEncode {
+	public:
+		enum ForWhat { ForTextNodes, ForAttributes };
 
-        void tryOpen();
+		XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes );
 
-        void addInitialFilters( std::vector<std::string> const& filters );
-        void addNextFilters( std::vector<std::string> const& filters );
-    };
+		void encodeTo( std::ostream& os ) const;
 
-    class IndexTracker : public TrackerBase {
-        int m_size;
-        int m_index = -1;
-    public:
-        IndexTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent, int size );
+		friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode );
 
-        bool isIndexTracker() const override;
-        void close() override;
+	private:
+		std::string m_str;
+		ForWhat m_forWhat;
+	};
 
-        static IndexTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation, int size );
+	class XmlWriter {
+	public:
 
-        int index() const;
+		class ScopedElement {
+		public:
+			ScopedElement( XmlWriter* writer );
 
-        void moveNext();
-    };
+			ScopedElement( ScopedElement&& other ) noexcept;
+			ScopedElement& operator=( ScopedElement&& other ) noexcept;
 
-} // namespace TestCaseTracking
+			~ScopedElement();
 
-using TestCaseTracking::ITracker;
-using TestCaseTracking::TrackerContext;
-using TestCaseTracking::SectionTracker;
-using TestCaseTracking::IndexTracker;
+			ScopedElement& writeText( std::string const& text, bool indent = true );
 
-} // namespace Catch
+			template<typename T>
+			ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
+				m_writer->writeAttribute( name, attribute );
+				return *this;
+			}
 
-// end catch_test_case_tracker.h
+		private:
+			mutable XmlWriter* m_writer = nullptr;
+		};
 
-// start catch_leak_detector.h
+		XmlWriter( std::ostream& os = Catch::cout() );
+		~XmlWriter();
 
-namespace Catch {
+		XmlWriter( XmlWriter const& ) = delete;
+		XmlWriter& operator=( XmlWriter const& ) = delete;
 
-    struct LeakDetector {
-        LeakDetector();
-    };
+		XmlWriter& startElement( std::string const& name );
 
-}
-// end catch_leak_detector.h
-// Cpp files will be included in the single-header file here
-// start catch_approx.cpp
+		ScopedElement scopedElement( std::string const& name );
 
-#include <cmath>
-#include <limits>
+		XmlWriter& endElement();
 
-namespace {
+		XmlWriter& writeAttribute( std::string const& name, std::string const& attribute );
 
-// Performs equivalent check of std::fabs(lhs - rhs) <= margin
-// But without the subtraction to allow for INFINITY in comparison
-bool marginComparison(double lhs, double rhs, double margin) {
-    return (lhs + margin >= rhs) && (rhs + margin >= lhs);
-}
+		XmlWriter& writeAttribute( std::string const& name, bool attribute );
 
-}
+		template<typename T>
+		XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
+			ReusableStringStream rss;
+			rss << attribute;
+			return writeAttribute( name, rss.str() );
+		}
 
-namespace Catch {
-namespace Detail {
+		XmlWriter& writeText( std::string const& text, bool indent = true );
 
-    Approx::Approx ( double value )
-    :   m_epsilon( std::numeric_limits<float>::epsilon()*100 ),
-        m_margin( 0.0 ),
-        m_scale( 0.0 ),
-        m_value( value )
-    {}
+		XmlWriter& writeComment( std::string const& text );
 
-    Approx Approx::custom() {
-        return Approx( 0 );
-    }
+		void writeStylesheetRef( std::string const& url );
 
-    std::string Approx::toString() const {
-        std::ostringstream oss;
-        oss << "Approx( " << ::Catch::Detail::stringify( m_value ) << " )";
-        return oss.str();
-    }
+		XmlWriter& writeBlankLine();
 
-    bool Approx::equalityComparisonImpl(const double other) const {
-        // First try with fixed margin, then compute margin based on epsilon, scale and Approx's value
-        // Thanks to Richard Harris for his help refining the scaled margin value
-        return marginComparison(m_value, other, m_margin) || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(m_value)));
-    }
+		void ensureTagClosed();
 
-} // end namespace Detail
+	private:
 
-std::string StringMaker<Catch::Detail::Approx>::convert(Catch::Detail::Approx const& value) {
-    return value.toString();
-}
+		void writeDeclaration();
 
-} // end namespace Catch
-// end catch_approx.cpp
-// start catch_assertionhandler.cpp
+		void newlineIfNecessary();
 
-// start catch_context.h
+		bool m_tagIsOpen = false;
+		bool m_needsNewline = false;
+		std::vector<std::string> m_tags;
+		std::string m_indent;
+		std::ostream& m_os;
+	};
 
-#include <memory>
+}
 
+// end catch_xmlwriter.h
 namespace Catch {
 
-    struct IResultCapture;
-    struct IRunner;
-    struct IConfig;
+	class JunitReporter : public CumulativeReporterBase<JunitReporter> {
+	public:
+		JunitReporter(ReporterConfig const& _config);
 
-    using IConfigPtr = std::shared_ptr<IConfig const>;
+		~JunitReporter() override;
 
-    struct IContext
-    {
-        virtual ~IContext();
+		static std::string getDescription();
 
-        virtual IResultCapture* getResultCapture() = 0;
-        virtual IRunner* getRunner() = 0;
-        virtual IConfigPtr getConfig() const = 0;
-    };
+		void noMatchingTestCases(std::string const& /*spec*/) override;
 
-    struct IMutableContext : IContext
-    {
-        virtual ~IMutableContext();
-        virtual void setResultCapture( IResultCapture* resultCapture ) = 0;
-        virtual void setRunner( IRunner* runner ) = 0;
-        virtual void setConfig( IConfigPtr const& config ) = 0;
-    };
+		void testRunStarting(TestRunInfo const& runInfo) override;
 
-    IContext& getCurrentContext();
-    IMutableContext& getCurrentMutableContext();
-    void cleanUpContext();
-}
+		void testGroupStarting(GroupInfo const& groupInfo) override;
 
-// end catch_context.h
-#include <cassert>
+		void testCaseStarting(TestCaseInfo const& testCaseInfo) override;
+		bool assertionEnded(AssertionStats const& assertionStats) override;
 
-namespace Catch {
+		void testCaseEnded(TestCaseStats const& testCaseStats) override;
 
-    auto operator <<( std::ostream& os, ITransientExpression const& expr ) -> std::ostream& {
-        expr.streamReconstructedExpression( os );
-        return os;
-    }
-
-    LazyExpression::LazyExpression( bool isNegated )
-    :   m_isNegated( isNegated )
-    {}
-
-    LazyExpression::LazyExpression( LazyExpression const& other ) : m_isNegated( other.m_isNegated ) {}
-
-    LazyExpression::operator bool() const {
-        return m_transientExpression != nullptr;
-    }
-
-    auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream& {
-        if( lazyExpr.m_isNegated )
-            os << "!";
-
-        if( lazyExpr ) {
-            if( lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression() )
-                os << "(" << *lazyExpr.m_transientExpression << ")";
-            else
-                os << *lazyExpr.m_transientExpression;
-        }
-        else {
-            os << "{** error - unchecked empty expression requested **}";
-        }
-        return os;
-    }
-
-    AssertionHandler::AssertionHandler
-        (   StringRef macroName,
-            SourceLineInfo const& lineInfo,
-            StringRef capturedExpression,
-            ResultDisposition::Flags resultDisposition )
-    :   m_assertionInfo{ macroName, lineInfo, capturedExpression, resultDisposition }
-    {
-        getCurrentContext().getResultCapture()->assertionStarting( m_assertionInfo );
-    }
-    AssertionHandler::~AssertionHandler() {
-        if ( m_inExceptionGuard ) {
-            handle( ResultWas::ThrewException, "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE" );
-            getCurrentContext().getResultCapture()->exceptionEarlyReported();
-        }
-    }
-
-    void AssertionHandler::handle( ITransientExpression const& expr ) {
-
-        bool negated = isFalseTest( m_assertionInfo.resultDisposition );
-        bool result = expr.getResult() != negated;
-
-        handle( result ? ResultWas::Ok : ResultWas::ExpressionFailed, &expr, negated );
-    }
-    void AssertionHandler::handle( ResultWas::OfType resultType ) {
-        handle( resultType, nullptr, false );
-    }
-    void AssertionHandler::handle( ResultWas::OfType resultType, StringRef const& message ) {
-        AssertionResultData data( resultType, LazyExpression( false ) );
-        data.message = message;
-        handle( data, nullptr );
-    }
-    void AssertionHandler::handle( ResultWas::OfType resultType, ITransientExpression const* expr, bool negated ) {
-        AssertionResultData data( resultType, LazyExpression( negated ) );
-        handle( data, expr );
-    }
-    void AssertionHandler::handle( AssertionResultData const& resultData, ITransientExpression const* expr ) {
-
-        getResultCapture().assertionRun();
-
-        AssertionResult assertionResult{ m_assertionInfo, resultData };
-        assertionResult.m_resultData.lazyExpression.m_transientExpression = expr;
-
-        getResultCapture().assertionEnded( assertionResult );
-
-        if( !assertionResult.isOk() ) {
-            m_shouldDebugBreak = getCurrentContext().getConfig()->shouldDebugBreak();
-            m_shouldThrow =
-                    getCurrentContext().getRunner()->aborting() ||
-                    (m_assertionInfo.resultDisposition & ResultDisposition::Normal);
-        }
-    }
-
-    auto AssertionHandler::allowThrows() const -> bool {
-        return getCurrentContext().getConfig()->allowThrows();
-    }
-
-    auto AssertionHandler::shouldDebugBreak() const -> bool {
-        return m_shouldDebugBreak;
-    }
-    void AssertionHandler::reactWithDebugBreak() const {
-        if (m_shouldDebugBreak) {
-            ///////////////////////////////////////////////////////////////////
-            // To inspect the state during test, you need to go one level up the callstack
-            // To go back to the test and change execution, jump over the reactWithoutDebugBreak() call
-            ///////////////////////////////////////////////////////////////////
-            CATCH_BREAK_INTO_DEBUGGER();
-        }
-        reactWithoutDebugBreak();
-    }
-    void AssertionHandler::reactWithoutDebugBreak() const {
-        if( m_shouldThrow )
-            throw Catch::TestFailureException();
-    }
-
-    void AssertionHandler::useActiveException() {
-        handle( ResultWas::ThrewException, Catch::translateActiveException() );
-    }
-
-    void AssertionHandler::setExceptionGuard() {
-        assert( m_inExceptionGuard == false );
-        m_inExceptionGuard = true;
-    }
-    void AssertionHandler::unsetExceptionGuard() {
-        assert( m_inExceptionGuard == true );
-        m_inExceptionGuard = false;
-    }
-
-    // This is the overload that takes a string and infers the Equals matcher from it
-    // The more general overload, that takes any string matcher, is in catch_capture_matchers.cpp
-    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef matcherString  ) {
-        handleExceptionMatchExpr( handler, Matchers::Equals( str ), matcherString );
-    }
+		void testGroupEnded(TestGroupStats const& testGroupStats) override;
 
-} // namespace Catch
-// end catch_assertionhandler.cpp
-// start catch_assertionresult.cpp
-
-namespace Catch {
-    AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const & _lazyExpression):
-        lazyExpression(_lazyExpression),
-        resultType(_resultType) {}
-
-    std::string AssertionResultData::reconstructExpression() const {
-
-        if( reconstructedExpression.empty() ) {
-            if( lazyExpression ) {
-                // !TBD Use stringstream for now, but rework above to pass stream in
-                std::ostringstream oss;
-                oss << lazyExpression;
-                reconstructedExpression = oss.str();
-            }
-        }
-        return reconstructedExpression;
-    }
-
-    AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
-    :   m_info( info ),
-        m_resultData( data )
-    {}
-
-    // Result was a success
-    bool AssertionResult::succeeded() const {
-        return Catch::isOk( m_resultData.resultType );
-    }
-
-    // Result was a success, or failure is suppressed
-    bool AssertionResult::isOk() const {
-        return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
-    }
-
-    ResultWas::OfType AssertionResult::getResultType() const {
-        return m_resultData.resultType;
-    }
-
-    bool AssertionResult::hasExpression() const {
-        return m_info.capturedExpression[0] != 0;
-    }
-
-    bool AssertionResult::hasMessage() const {
-        return !m_resultData.message.empty();
-    }
-
-    std::string AssertionResult::getExpression() const {
-        if( isFalseTest( m_info.resultDisposition ) )
-            return "!(" + std::string(m_info.capturedExpression) + ")";
-        else
-            return m_info.capturedExpression;
-    }
-
-    std::string AssertionResult::getExpressionInMacro() const {
-        std::string expr;
-        if( m_info.macroName[0] == 0 )
-            expr = m_info.capturedExpression;
-        else {
-            expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
-            expr += m_info.macroName;
-            expr += "( ";
-            expr += m_info.capturedExpression;
-            expr += " )";
-        }
-        return expr;
-    }
-
-    bool AssertionResult::hasExpandedExpression() const {
-        return hasExpression() && getExpandedExpression() != getExpression();
-    }
-
-    std::string AssertionResult::getExpandedExpression() const {
-        std::string expr = m_resultData.reconstructExpression();
-        return expr.empty()
-                ? getExpression()
-                : expr;
-    }
-
-    std::string AssertionResult::getMessage() const {
-        return m_resultData.message;
-    }
-    SourceLineInfo AssertionResult::getSourceInfo() const {
-        return m_info.lineInfo;
-    }
-
-    std::string AssertionResult::getTestMacroName() const {
-        return m_info.macroName;
-    }
+		void testRunEndedCumulative() override;
+
+		void writeGroup(TestGroupNode const& groupNode, double suiteTime);
+
+		void writeTestCase(TestCaseNode const& testCaseNode);
+
+		void writeSection(std::string const& className,
+			std::string const& rootName,
+			SectionNode const& sectionNode);
+
+		void writeAssertions(SectionNode const& sectionNode);
+		void writeAssertion(AssertionStats const& stats);
+
+		XmlWriter xml;
+		Timer suiteTimer;
+		std::string stdOutForSuite;
+		std::string stdErrForSuite;
+		unsigned int unexpectedExceptions = 0;
+		bool m_okToFail = false;
+	};
 
 } // end namespace Catch
-// end catch_assertionresult.cpp
-// start catch_benchmark.cpp
+
+  // end catch_reporter_junit.h
+  // start catch_reporter_xml.h
 
 namespace Catch {
+	class XmlReporter : public StreamingReporterBase<XmlReporter> {
+	public:
+		XmlReporter(ReporterConfig const& _config);
 
-    auto BenchmarkLooper::getResolution() -> uint64_t {
-        return getEstimatedClockResolution() * getCurrentContext().getConfig()->benchmarkResolutionMultiple();
-    }
+		~XmlReporter() override;
 
-    void BenchmarkLooper::reportStart() {
-        getResultCapture().benchmarkStarting( { m_name } );
-    }
-    auto BenchmarkLooper::needsMoreIterations() -> bool {
-        auto elapsed = m_timer.getElapsedNanoseconds();
+		static std::string getDescription();
 
-        // Exponentially increasing iterations until we're confident in our timer resolution
-        if( elapsed < m_resolution ) {
-            m_iterationsToRun *= 10;
-            return true;
-        }
+		virtual std::string getStylesheetRef() const;
 
-        getResultCapture().benchmarkEnded( { { m_name }, m_count, elapsed } );
-        return false;
-    }
+		void writeSourceInfo(SourceLineInfo const& sourceInfo);
 
-} // end namespace Catch
-// end catch_benchmark.cpp
-// start catch_capture_matchers.cpp
+	public: // StreamingReporterBase
 
-namespace Catch {
+		void noMatchingTestCases(std::string const& s) override;
 
-    using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
+		void testRunStarting(TestRunInfo const& testInfo) override;
 
-    // This is the general overload that takes a any string matcher
-    // There is another overload, in catch_assertinhandler.h/.cpp, that only takes a string and infers
-    // the Equals matcher (so the header does not mention matchers)
-    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef matcherString  ) {
-        std::string exceptionMessage = Catch::translateActiveException();
-        MatchExpr<std::string, StringMatcher const&> expr( exceptionMessage, matcher, matcherString );
-        handler.handle( expr );
-    }
+		void testGroupStarting(GroupInfo const& groupInfo) override;
 
-} // namespace Catch
-// end catch_capture_matchers.cpp
-// start catch_commandline.cpp
+		void testCaseStarting(TestCaseInfo const& testInfo) override;
 
-// start catch_commandline.h
+		void sectionStarting(SectionInfo const& sectionInfo) override;
 
-// start catch_clara.h
+		void assertionStarting(AssertionInfo const&) override;
 
-// Use Catch's value for console width (store Clara's off to the side, if present)
-#ifdef CLARA_CONFIG_CONSOLE_WIDTH
-#define CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
-#undef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
+		bool assertionEnded(AssertionStats const& assertionStats) override;
+
+		void sectionEnded(SectionStats const& sectionStats) override;
+
+		void testCaseEnded(TestCaseStats const& testCaseStats) override;
+
+		void testGroupEnded(TestGroupStats const& testGroupStats) override;
+
+		void testRunEnded(TestRunStats const& testRunStats) override;
+
+	private:
+		Timer m_testCaseTimer;
+		XmlWriter m_xml;
+		int m_sectionDepth = 0;
+	};
+
+} // end namespace Catch
+
+  // end catch_reporter_xml.h
+
+  // end catch_external_interfaces.h
 #endif
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH-1
+
+#endif // ! CATCH_CONFIG_IMPL_ONLY
+
+#ifdef CATCH_IMPL
+  // start catch_impl.hpp
 
 #ifdef __clang__
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wweak-vtables"
-#pragma clang diagnostic ignored "-Wexit-time-destructors"
-#pragma clang diagnostic ignored "-Wshadow"
 #endif
 
-// start clara.hpp
-// v1.0-develop.2
-// See https://github.com/philsquared/Clara
+  // Keep these here for external reporters
+  // start catch_test_case_tracker.h
 
+#include <string>
+#include <vector>
+#include <memory>
 
-#ifndef CATCH_CLARA_CONFIG_CONSOLE_WIDTH
-#define CATCH_CLARA_CONFIG_CONSOLE_WIDTH 80
-#endif
+namespace Catch {
+	namespace TestCaseTracking {
 
-#ifndef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CLARA_CONFIG_CONSOLE_WIDTH
-#endif
+		struct NameAndLocation {
+			std::string name;
+			SourceLineInfo location;
 
-// ----------- #included from clara_textflow.hpp -----------
+			NameAndLocation( std::string const& _name, SourceLineInfo const& _location );
+		};
 
-// TextFlowCpp
-//
-// A single-header library for wrapping and laying out basic text, by Phil Nash
-//
-// This work is licensed under the BSD 2-Clause license.
-// See the accompanying LICENSE file, or the one at https://opensource.org/licenses/BSD-2-Clause
-//
-// This project is hosted at https://github.com/philsquared/textflowcpp
+		struct ITracker;
 
+		using ITrackerPtr = std::shared_ptr<ITracker>;
 
-#include <cassert>
-#include <ostream>
-#include <sstream>
-#include <vector>
+		struct ITracker {
+			virtual ~ITracker();
 
-#ifndef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH 80
-#endif
+			// static queries
+			virtual NameAndLocation const& nameAndLocation() const = 0;
 
-namespace Catch { namespace clara { namespace TextFlow {
-
-    inline auto isWhitespace( char c ) -> bool {
-        static std::string chars = " \t\n\r";
-        return chars.find( c ) != std::string::npos;
-    }
-    inline auto isBreakableBefore( char c ) -> bool {
-        static std::string chars = "[({<|";
-        return chars.find( c ) != std::string::npos;
-    }
-    inline auto isBreakableAfter( char c ) -> bool {
-        static std::string chars = "])}>.,:;*+-=&/\\";
-        return chars.find( c ) != std::string::npos;
-    }
-
-    class Columns;
-
-    class Column {
-        std::vector<std::string> m_strings;
-        size_t m_width = CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH;
-        size_t m_indent = 0;
-        size_t m_initialIndent = std::string::npos;
-
-    public:
-        class iterator {
-            friend Column;
-
-            Column const& m_column;
-            size_t m_stringIndex = 0;
-            size_t m_pos = 0;
-
-            size_t m_len = 0;
-            size_t m_end = 0;
-            bool m_suffix = false;
-
-            iterator( Column const& column, size_t stringIndex )
-            :   m_column( column ),
-                m_stringIndex( stringIndex )
-            {}
-
-            auto line() const -> std::string const& { return m_column.m_strings[m_stringIndex]; }
-
-            auto isBoundary( size_t at ) const -> bool {
-                assert( at > 0 );
-                assert( at <= line().size() );
-
-                return at == line().size() ||
-                       ( isWhitespace( line()[at] ) && !isWhitespace( line()[at-1] ) ) ||
-                       isBreakableBefore( line()[at] ) ||
-                       isBreakableAfter( line()[at-1] );
-            }
-
-            void calcLength() {
-                assert( m_stringIndex < m_column.m_strings.size() );
-
-                m_suffix = false;
-                auto width = m_column.m_width-indent();
-                m_end = m_pos;
-                while( m_end < line().size() && line()[m_end] != '\n' )
-                    ++m_end;
-
-                if( m_end < m_pos + width ) {
-                    m_len = m_end - m_pos;
-                }
-                else {
-                    size_t len = width;
-                    while (len > 0 && !isBoundary(m_pos + len))
-                        --len;
-                    while (len > 0 && isWhitespace( line()[m_pos + len - 1] ))
-                        --len;
-
-                    if (len > 0) {
-                        m_len = len;
-                    } else {
-                        m_suffix = true;
-                        m_len = width - 1;
-                    }
-                }
-            }
-
-            auto indent() const -> size_t {
-                auto initial = m_pos == 0 && m_stringIndex == 0 ? m_column.m_initialIndent : std::string::npos;
-                return initial == std::string::npos ? m_column.m_indent : initial;
-            }
-
-            auto addIndentAndSuffix(std::string const &plain) const -> std::string {
-                return std::string( indent(), ' ' ) + (m_suffix ? plain + "-" : plain);
-            }
-
-        public:
-            explicit iterator( Column const& column ) : m_column( column ) {
-                assert( m_column.m_width > m_column.m_indent );
-                assert( m_column.m_initialIndent == std::string::npos || m_column.m_width > m_column.m_initialIndent );
-                calcLength();
-                if( m_len == 0 )
-                    m_stringIndex++; // Empty string
-            }
-
-            auto operator *() const -> std::string {
-                assert( m_stringIndex < m_column.m_strings.size() );
-                assert( m_pos <= m_end );
-                if( m_pos + m_column.m_width < m_end )
-                    return addIndentAndSuffix(line().substr(m_pos, m_len));
-                else
-                    return addIndentAndSuffix(line().substr(m_pos, m_end - m_pos));
-            }
-
-            auto operator ++() -> iterator& {
-                m_pos += m_len;
-                if( m_pos < line().size() && line()[m_pos] == '\n' )
-                    m_pos += 1;
-                else
-                    while( m_pos < line().size() && isWhitespace( line()[m_pos] ) )
-                        ++m_pos;
-
-                if( m_pos == line().size() ) {
-                    m_pos = 0;
-                    ++m_stringIndex;
-                }
-                if( m_stringIndex < m_column.m_strings.size() )
-                    calcLength();
-                return *this;
-            }
-            auto operator ++(int) -> iterator {
-                iterator prev( *this );
-                operator++();
-                return prev;
-            }
-
-            auto operator ==( iterator const& other ) const -> bool {
-                return
-                    m_pos == other.m_pos &&
-                    m_stringIndex == other.m_stringIndex &&
-                    &m_column == &other.m_column;
-            }
-            auto operator !=( iterator const& other ) const -> bool {
-                return !operator==( other );
-            }
-        };
-        using const_iterator = iterator;
-
-        explicit Column( std::string const& text ) { m_strings.push_back( text ); }
-
-        auto width( size_t newWidth ) -> Column& {
-            assert( newWidth > 0 );
-            m_width = newWidth;
-            return *this;
-        }
-        auto indent( size_t newIndent ) -> Column& {
-            m_indent = newIndent;
-            return *this;
-        }
-        auto initialIndent( size_t newIndent ) -> Column& {
-            m_initialIndent = newIndent;
-            return *this;
-        }
-
-        auto width() const -> size_t { return m_width; }
-        auto begin() const -> iterator { return iterator( *this ); }
-        auto end() const -> iterator { return { *this, m_strings.size() }; }
-
-        inline friend std::ostream& operator << ( std::ostream& os, Column const& col ) {
-            bool first = true;
-            for( auto line : col ) {
-                if( first )
-                    first = false;
-                else
-                    os << "\n";
-                os <<  line;
-            }
-            return os;
-        }
-
-        auto operator + ( Column const& other ) -> Columns;
-
-        auto toString() const -> std::string {
-            std::ostringstream oss;
-            oss << *this;
-            return oss.str();
-        }
-    };
-
-    class Spacer : public Column {
-
-    public:
-        explicit Spacer( size_t spaceWidth ) : Column( "" ) {
-            width( spaceWidth );
-        }
-    };
-
-    class Columns {
-        std::vector<Column> m_columns;
-
-    public:
-
-        class iterator {
-            friend Columns;
-            struct EndTag {};
-
-            std::vector<Column> const& m_columns;
-            std::vector<Column::iterator> m_iterators;
-            size_t m_activeIterators;
-
-            iterator( Columns const& columns, EndTag )
-            :   m_columns( columns.m_columns ),
-                m_activeIterators( 0 )
-            {
-                m_iterators.reserve( m_columns.size() );
-
-                for( auto const& col : m_columns )
-                    m_iterators.push_back( col.end() );
-            }
-
-        public:
-            explicit iterator( Columns const& columns )
-            :   m_columns( columns.m_columns ),
-                m_activeIterators( m_columns.size() )
-            {
-                m_iterators.reserve( m_columns.size() );
-
-                for( auto const& col : m_columns )
-                    m_iterators.push_back( col.begin() );
-            }
-
-            auto operator ==( iterator const& other ) const -> bool {
-                return m_iterators == other.m_iterators;
-            }
-            auto operator !=( iterator const& other ) const -> bool {
-                return m_iterators != other.m_iterators;
-            }
-            auto operator *() const -> std::string {
-                std::string row, padding;
-
-                for( size_t i = 0; i < m_columns.size(); ++i ) {
-                    auto width = m_columns[i].width();
-                    if( m_iterators[i] != m_columns[i].end() ) {
-                        std::string col = *m_iterators[i];
-                        row += padding + col;
-                        if( col.size() < width )
-                            padding = std::string( width - col.size(), ' ' );
-                        else
-                            padding = "";
-                    }
-                    else {
-                        padding += std::string( width, ' ' );
-                    }
-                }
-                return row;
-            }
-            auto operator ++() -> iterator& {
-                for( size_t i = 0; i < m_columns.size(); ++i ) {
-                    if (m_iterators[i] != m_columns[i].end())
-                        ++m_iterators[i];
-                }
-                return *this;
-            }
-            auto operator ++(int) -> iterator {
-                iterator prev( *this );
-                operator++();
-                return prev;
-            }
-        };
-        using const_iterator = iterator;
-
-        auto begin() const -> iterator { return iterator( *this ); }
-        auto end() const -> iterator { return { *this, iterator::EndTag() }; }
-
-        auto operator += ( Column const& col ) -> Columns& {
-            m_columns.push_back( col );
-            return *this;
-        }
-        auto operator + ( Column const& col ) -> Columns {
-            Columns combined = *this;
-            combined += col;
-            return combined;
-        }
-
-        inline friend std::ostream& operator << ( std::ostream& os, Columns const& cols ) {
-
-            bool first = true;
-            for( auto line : cols ) {
-                if( first )
-                    first = false;
-                else
-                    os << "\n";
-                os << line;
-            }
-            return os;
-        }
-
-        auto toString() const -> std::string {
-            std::ostringstream oss;
-            oss << *this;
-            return oss.str();
-        }
-    };
-
-    inline auto Column::operator + ( Column const& other ) -> Columns {
-        Columns cols;
-        cols += *this;
-        cols += other;
-        return cols;
-    }
-}}} // namespace Catch::clara::TextFlow
+			// dynamic queries
+			virtual bool isComplete() const = 0; // Successfully completed or failed
+			virtual bool isSuccessfullyCompleted() const = 0;
+			virtual bool isOpen() const = 0; // Started but not complete
+			virtual bool hasChildren() const = 0;
 
-// ----------- end of #include from clara_textflow.hpp -----------
-// ........... back in clara.hpp
+			virtual ITracker& parent() = 0;
 
-#include <memory>
-#include <set>
-#include <algorithm>
+			// actions
+			virtual void close() = 0; // Successfully complete
+			virtual void fail() = 0;
+			virtual void markAsNeedingAnotherRun() = 0;
 
-#if !defined(CATCH_PLATFORM_WINDOWS) && ( defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) )
-#define CATCH_PLATFORM_WINDOWS
-#endif
+			virtual void addChild( ITrackerPtr const& child ) = 0;
+			virtual ITrackerPtr findChild( NameAndLocation const& nameAndLocation ) = 0;
+			virtual void openChild() = 0;
 
-namespace Catch { namespace clara {
-namespace detail {
-
-    // Traits for extracting arg and return type of lambdas (for single argument lambdas)
-    template<typename L>
-    struct UnaryLambdaTraits : UnaryLambdaTraits<decltype( &L::operator() )> {};
-
-    template<typename ClassT, typename ReturnT, typename... Args>
-    struct UnaryLambdaTraits<ReturnT( ClassT::* )( Args... ) const> {
-        static const bool isValid = false;
-    };
-
-    template<typename ClassT, typename ReturnT, typename ArgT>
-    struct UnaryLambdaTraits<ReturnT( ClassT::* )( ArgT ) const> {
-        static const bool isValid = true;
-        using ArgType = typename std::remove_const<typename std::remove_reference<ArgT>::type>::type;;
-        using ReturnType = ReturnT;
-    };
-
-    class TokenStream;
-
-    // Transport for raw args (copied from main args, or supplied via init list for testing)
-    class Args {
-        friend TokenStream;
-        std::string m_exeName;
-        std::vector<std::string> m_args;
-
-    public:
-        Args( int argc, char *argv[] ) {
-            m_exeName = argv[0];
-            for( int i = 1; i < argc; ++i )
-                m_args.push_back( argv[i] );
-        }
-
-        Args( std::initializer_list<std::string> args )
-        :   m_exeName( *args.begin() ),
-            m_args( args.begin()+1, args.end() )
-        {}
-
-        auto exeName() const -> std::string {
-            return m_exeName;
-        }
-    };
-
-    // Wraps a token coming from a token stream. These may not directly correspond to strings as a single string
-    // may encode an option + its argument if the : or = form is used
-    enum class TokenType {
-        Option, Argument
-    };
-    struct Token {
-        TokenType type;
-        std::string token;
-    };
-
-    inline auto isOptPrefix( char c ) -> bool {
-        return c == '-'
-#ifdef CATCH_PLATFORM_WINDOWS
-            || c == '/'
-#endif
-        ;
-    }
-
-    // Abstracts iterators into args as a stream of tokens, with option arguments uniformly handled
-    class TokenStream {
-        using Iterator = std::vector<std::string>::const_iterator;
-        Iterator it;
-        Iterator itEnd;
-        std::vector<Token> m_tokenBuffer;
-
-        void loadBuffer() {
-            m_tokenBuffer.resize( 0 );
-
-            // Skip any empty strings
-            while( it != itEnd && it->empty() )
-                ++it;
-
-            if( it != itEnd ) {
-                auto const &next = *it;
-                if( isOptPrefix( next[0] ) ) {
-                    auto delimiterPos = next.find_first_of( " :=" );
-                    if( delimiterPos != std::string::npos ) {
-                        m_tokenBuffer.push_back( { TokenType::Option, next.substr( 0, delimiterPos ) } );
-                        m_tokenBuffer.push_back( { TokenType::Argument, next.substr( delimiterPos + 1 ) } );
-                    } else {
-                        if( next[1] != '-' && next.size() > 2 ) {
-                            std::string opt = "- ";
-                            for( size_t i = 1; i < next.size(); ++i ) {
-                                opt[1] = next[i];
-                                m_tokenBuffer.push_back( { TokenType::Option, opt } );
-                            }
-                        } else {
-                            m_tokenBuffer.push_back( { TokenType::Option, next } );
-                        }
-                    }
-                } else {
-                    m_tokenBuffer.push_back( { TokenType::Argument, next } );
-                }
-            }
-        }
-
-    public:
-        explicit TokenStream( Args const &args ) : TokenStream( args.m_args.begin(), args.m_args.end() ) {}
-
-        TokenStream( Iterator it, Iterator itEnd ) : it( it ), itEnd( itEnd ) {
-            loadBuffer();
-        }
-
-        explicit operator bool() const {
-            return !m_tokenBuffer.empty() || it != itEnd;
-        }
-
-        auto count() const -> size_t { return m_tokenBuffer.size() + (itEnd - it); }
-
-        auto operator*() const -> Token {
-            assert( !m_tokenBuffer.empty() );
-            return m_tokenBuffer.front();
-        }
-
-        auto operator->() const -> Token const * {
-            assert( !m_tokenBuffer.empty() );
-            return &m_tokenBuffer.front();
-        }
-
-        auto operator++() -> TokenStream & {
-            if( m_tokenBuffer.size() >= 2 ) {
-                m_tokenBuffer.erase( m_tokenBuffer.begin() );
-            } else {
-                if( it != itEnd )
-                    ++it;
-                loadBuffer();
-            }
-            return *this;
-        }
-    };
-
-    class ResultBase {
-    public:
-        enum Type {
-            Ok, LogicError, RuntimeError
-        };
-
-    protected:
-        ResultBase( Type type ) : m_type( type ) {}
-        virtual ~ResultBase() = default;
-
-        virtual void enforceOk() const = 0;
-
-        Type m_type;
-    };
-
-    template<typename T>
-    class ResultValueBase : public ResultBase {
-    public:
-        auto value() const -> T const & {
-            enforceOk();
-            return m_value;
-        }
-
-    protected:
-        ResultValueBase( Type type ) : ResultBase( type ) {}
-
-        ResultValueBase( ResultValueBase const &other ) : ResultBase( other ) {
-            if( m_type == ResultBase::Ok )
-                new( &m_value ) T( other.m_value );
-        }
-
-        ResultValueBase( Type, T const &value ) : ResultBase( Ok ) {
-            new( &m_value ) T( value );
-        }
-
-        auto operator=( ResultValueBase const &other ) -> ResultValueBase & {
-            if( m_type == ResultBase::Ok )
-                m_value.~T();
-            ResultBase::operator=(other);
-            if( m_type == ResultBase::Ok )
-                new( &m_value ) T( other.m_value );
-            return *this;
-        }
-
-        ~ResultValueBase() {
-            if( m_type == Ok )
-                m_value.~T();
-        }
-
-        union {
-            T m_value;
-        };
-    };
-
-    template<>
-    class ResultValueBase<void> : public ResultBase {
-    protected:
-        using ResultBase::ResultBase;
-    };
-
-    template<typename T = void>
-    class BasicResult : public ResultValueBase<T> {
-    public:
-        template<typename U>
-        explicit BasicResult( BasicResult<U> const &other )
-        :   ResultValueBase<T>( other.type() ),
-            m_errorMessage( other.errorMessage() )
-        {
-            assert( type() != ResultBase::Ok );
-        }
-
-        template<typename U>
-        static auto ok( U const &value ) -> BasicResult { return { ResultBase::Ok, value }; }
-        static auto ok() -> BasicResult { return { ResultBase::Ok }; }
-        static auto logicError( std::string const &message ) -> BasicResult { return { ResultBase::LogicError, message }; }
-        static auto runtimeError( std::string const &message ) -> BasicResult { return { ResultBase::RuntimeError, message }; }
-
-        explicit operator bool() const { return m_type == ResultBase::Ok; }
-        auto type() const -> ResultBase::Type { return m_type; }
-        auto errorMessage() const -> std::string { return m_errorMessage; }
-
-    protected:
-        virtual void enforceOk() const {
-            // !TBD: If no exceptions, std::terminate here or something
-            switch( m_type ) {
-                case ResultBase::LogicError:
-                    throw std::logic_error( m_errorMessage );
-                case ResultBase::RuntimeError:
-                    throw std::runtime_error( m_errorMessage );
-                case ResultBase::Ok:
-                    break;
-            }
-        }
-
-        std::string m_errorMessage; // Only populated if resultType is an error
-
-        BasicResult( ResultBase::Type type, std::string const &message )
-        :   ResultValueBase<T>(type),
-            m_errorMessage(message)
-        {
-            assert( m_type != ResultBase::Ok );
-        }
-
-        using ResultValueBase<T>::ResultValueBase;
-        using ResultBase::m_type;
-    };
-
-    enum class ParseResultType {
-        Matched, NoMatch, ShortCircuitAll, ShortCircuitSame
-    };
-
-    class ParseState {
-    public:
-
-        ParseState( ParseResultType type, TokenStream const &remainingTokens )
-        : m_type(type),
-          m_remainingTokens( remainingTokens )
-        {}
-
-        auto type() const -> ParseResultType { return m_type; }
-        auto remainingTokens() const -> TokenStream { return m_remainingTokens; }
-
-    private:
-        ParseResultType m_type;
-        TokenStream m_remainingTokens;
-    };
-
-    using Result = BasicResult<void>;
-    using ParserResult = BasicResult<ParseResultType>;
-    using InternalParseResult = BasicResult<ParseState>;
-
-    struct HelpColumns {
-        std::string left;
-        std::string right;
-    };
-
-    template<typename T>
-    inline auto convertInto( std::string const &source, T& target ) -> ParserResult {
-        std::stringstream ss;
-        ss << source;
-        ss >> target;
-        if( ss.fail() )
-            return ParserResult::runtimeError( "Unable to convert '" + source + "' to destination type" );
-        else
-            return ParserResult::ok( ParseResultType::Matched );
-    }
-    inline auto convertInto( std::string const &source, std::string& target ) -> ParserResult {
-        target = source;
-        return ParserResult::ok( ParseResultType::Matched );
-    }
-    inline auto convertInto( std::string const &source, bool &target ) -> ParserResult {
-        std::string srcLC = source;
-        std::transform( srcLC.begin(), srcLC.end(), srcLC.begin(), []( char c ) { return static_cast<char>( ::tolower(c) ); } );
-        if (srcLC == "y" || srcLC == "1" || srcLC == "true" || srcLC == "yes" || srcLC == "on")
-            target = true;
-        else if (srcLC == "n" || srcLC == "0" || srcLC == "false" || srcLC == "no" || srcLC == "off")
-            target = false;
-        else
-            return ParserResult::runtimeError( "Expected a boolean value but did not recognise: '" + source + "'" );
-        return ParserResult::ok( ParseResultType::Matched );
-    }
-
-    struct BoundRefBase {
-        BoundRefBase() = default;
-        BoundRefBase( BoundRefBase const & ) = delete;
-        BoundRefBase( BoundRefBase && ) = delete;
-        BoundRefBase &operator=( BoundRefBase const & ) = delete;
-        BoundRefBase &operator=( BoundRefBase && ) = delete;
-
-        virtual ~BoundRefBase() = default;
-
-        virtual auto isFlag() const -> bool = 0;
-        virtual auto isContainer() const -> bool { return false; }
-        virtual auto setValue( std::string const &arg ) -> ParserResult = 0;
-        virtual auto setFlag( bool flag ) -> ParserResult = 0;
-    };
-
-    struct BoundValueRefBase : BoundRefBase {
-        auto isFlag() const -> bool override { return false; }
-
-        auto setFlag( bool ) -> ParserResult override {
-            return ParserResult::logicError( "Flags can only be set on boolean fields" );
-        }
-    };
-
-    struct BoundFlagRefBase : BoundRefBase {
-        auto isFlag() const -> bool override { return true; }
-
-        auto setValue( std::string const &arg ) -> ParserResult override {
-            bool flag;
-            auto result = convertInto( arg, flag );
-            if( result )
-                setFlag( flag );
-            return result;
-        }
-    };
-
-    template<typename T>
-    struct BoundRef : BoundValueRefBase {
-        T &m_ref;
-
-        explicit BoundRef( T &ref ) : m_ref( ref ) {}
-
-        auto setValue( std::string const &arg ) -> ParserResult override {
-            return convertInto( arg, m_ref );
-        }
-    };
-
-    template<typename T>
-    struct BoundRef<std::vector<T>> : BoundValueRefBase {
-        std::vector<T> &m_ref;
-
-        explicit BoundRef( std::vector<T> &ref ) : m_ref( ref ) {}
-
-        auto isContainer() const -> bool override { return true; }
-
-        auto setValue( std::string const &arg ) -> ParserResult override {
-            T temp;
-            auto result = convertInto( arg, temp );
-            if( result )
-                m_ref.push_back( temp );
-            return result;
-        }
-    };
-
-    struct BoundFlagRef : BoundFlagRefBase {
-        bool &m_ref;
-
-        explicit BoundFlagRef( bool &ref ) : m_ref( ref ) {}
-
-        auto setFlag( bool flag ) -> ParserResult override {
-            m_ref = flag;
-            return ParserResult::ok( ParseResultType::Matched );
-        }
-    };
-
-    template<typename ReturnType>
-    struct LambdaInvoker {
-        static_assert( std::is_same<ReturnType, ParserResult>::value, "Lambda must return void or clara::ParserResult" );
-
-        template<typename L, typename ArgType>
-        static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
-            return lambda( arg );
-        }
-    };
-
-    template<>
-    struct LambdaInvoker<void> {
-        template<typename L, typename ArgType>
-        static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
-            lambda( arg );
-            return ParserResult::ok( ParseResultType::Matched );
-        }
-    };
-
-    template<typename ArgType, typename L>
-    inline auto invokeLambda( L const &lambda, std::string const &arg ) -> ParserResult {
-        ArgType temp;
-        auto result = convertInto( arg, temp );
-        return !result
-           ? result
-           : LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( lambda, temp );
-    };
-
-    template<typename L>
-    struct BoundLambda : BoundValueRefBase {
-        L m_lambda;
-
-        static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
-        explicit BoundLambda( L const &lambda ) : m_lambda( lambda ) {}
-
-        auto setValue( std::string const &arg ) -> ParserResult override {
-            return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>( m_lambda, arg );
-        }
-    };
-
-    template<typename L>
-    struct BoundFlagLambda : BoundFlagRefBase {
-        L m_lambda;
-
-        static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
-        static_assert( std::is_same<typename UnaryLambdaTraits<L>::ArgType, bool>::value, "flags must be boolean" );
-
-        explicit BoundFlagLambda( L const &lambda ) : m_lambda( lambda ) {}
-
-        auto setFlag( bool flag ) -> ParserResult override {
-            return LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( m_lambda, flag );
-        }
-    };
-
-    enum class Optionality { Optional, Required };
-
-    struct Parser;
-
-    class ParserBase {
-    public:
-        virtual ~ParserBase() = default;
-        virtual auto validate() const -> Result { return Result::ok(); }
-        virtual auto parse( std::string const& exeName, TokenStream const &tokens) const -> InternalParseResult  = 0;
-        virtual auto cardinality() const -> size_t { return 1; }
-
-        auto parse( Args const &args ) const -> InternalParseResult {
-            return parse( args.exeName(), TokenStream( args ) );
-        }
-    };
-
-    template<typename DerivedT>
-    class ComposableParserImpl : public ParserBase {
-    public:
-        template<typename T>
-        auto operator|( T const &other ) const -> Parser;
-    };
-
-    // Common code and state for Args and Opts
-    template<typename DerivedT>
-    class ParserRefImpl : public ComposableParserImpl<DerivedT> {
-    protected:
-        Optionality m_optionality = Optionality::Optional;
-        std::shared_ptr<BoundRefBase> m_ref;
-        std::string m_hint;
-        std::string m_description;
-
-        explicit ParserRefImpl( std::shared_ptr<BoundRefBase> const &ref ) : m_ref( ref ) {}
-
-    public:
-        template<typename T>
-        ParserRefImpl( T &ref, std::string const &hint )
-        :   m_ref( std::make_shared<BoundRef<T>>( ref ) ),
-            m_hint( hint )
-        {}
-
-        template<typename LambdaT>
-        ParserRefImpl( LambdaT const &ref, std::string const &hint )
-        :   m_ref( std::make_shared<BoundLambda<LambdaT>>( ref ) ),
-            m_hint(hint)
-        {}
-
-        auto operator()( std::string const &description ) -> DerivedT & {
-            m_description = description;
-            return static_cast<DerivedT &>( *this );
-        }
-
-        auto optional() -> DerivedT & {
-            m_optionality = Optionality::Optional;
-            return static_cast<DerivedT &>( *this );
-        };
-
-        auto required() -> DerivedT & {
-            m_optionality = Optionality::Required;
-            return static_cast<DerivedT &>( *this );
-        };
-
-        auto isOptional() const -> bool {
-            return m_optionality == Optionality::Optional;
-        }
-
-        auto cardinality() const -> size_t override {
-            if( m_ref->isContainer() )
-                return 0;
-            else
-                return 1;
-        }
-
-        auto hint() const -> std::string { return m_hint; }
-    };
-
-    class ExeName : public ComposableParserImpl<ExeName> {
-        std::shared_ptr<std::string> m_name;
-        std::shared_ptr<BoundRefBase> m_ref;
-
-        template<typename LambdaT>
-        static auto makeRef(LambdaT const &lambda) -> std::shared_ptr<BoundRefBase> {
-            return std::make_shared<BoundLambda<LambdaT>>( lambda) ;
-        }
-
-    public:
-        ExeName() : m_name( std::make_shared<std::string>( "<executable>" ) ) {}
-
-        explicit ExeName( std::string &ref ) : ExeName() {
-            m_ref = std::make_shared<BoundRef<std::string>>( ref );
-        }
-
-        template<typename LambdaT>
-        explicit ExeName( LambdaT const& lambda ) : ExeName() {
-            m_ref = std::make_shared<BoundLambda<LambdaT>>( lambda );
-        }
-
-        // The exe name is not parsed out of the normal tokens, but is handled specially
-        auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
-            return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
-        }
-
-        auto name() const -> std::string { return *m_name; }
-        auto set( std::string const& newName ) -> ParserResult {
-
-            auto lastSlash = newName.find_last_of( "\\/" );
-            auto filename = ( lastSlash == std::string::npos )
-                    ? newName
-                    : newName.substr( lastSlash+1 );
-
-            *m_name = filename;
-            if( m_ref )
-                return m_ref->setValue( filename );
-            else
-                return ParserResult::ok( ParseResultType::Matched );
-        }
-    };
-
-    class Arg : public ParserRefImpl<Arg> {
-    public:
-        using ParserRefImpl::ParserRefImpl;
-
-        auto parse( std::string const &, TokenStream const &tokens ) const -> InternalParseResult override {
-            auto validationResult = validate();
-            if( !validationResult )
-                return InternalParseResult( validationResult );
-
-            auto remainingTokens = tokens;
-            auto const &token = *remainingTokens;
-            if( token.type != TokenType::Argument )
-                return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
-
-            auto result = m_ref->setValue( remainingTokens->token );
-            if( !result )
-                return InternalParseResult( result );
-            else
-                return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
-        }
-    };
-
-    inline auto normaliseOpt( std::string const &optName ) -> std::string {
-#ifdef CATCH_PLATFORM_WINDOWS
-        if( optName[0] == '/' )
-            return "-" + optName.substr( 1 );
-        else
-#endif
-            return optName;
-    }
-
-    class Opt : public ParserRefImpl<Opt> {
-    protected:
-        std::vector<std::string> m_optNames;
-
-    public:
-        template<typename LambdaT>
-        explicit Opt( LambdaT const &ref ) : ParserRefImpl( std::make_shared<BoundFlagLambda<LambdaT>>( ref ) ) {}
-
-        explicit Opt( bool &ref ) : ParserRefImpl( std::make_shared<BoundFlagRef>( ref ) ) {}
-
-        template<typename LambdaT>
-        Opt( LambdaT const &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}
-
-        template<typename T>
-        Opt( T &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}
-
-        auto operator[]( std::string const &optName ) -> Opt & {
-            m_optNames.push_back( optName );
-            return *this;
-        }
-
-        auto getHelpColumns() const -> std::vector<HelpColumns> {
-            std::ostringstream oss;
-            bool first = true;
-            for( auto const &opt : m_optNames ) {
-                if (first)
-                    first = false;
-                else
-                    oss << ", ";
-                oss << opt;
-            }
-            if( !m_hint.empty() )
-                oss << " <" << m_hint << ">";
-            return { { oss.str(), m_description } };
-        }
-
-        auto isMatch( std::string const &optToken ) const -> bool {
-            auto normalisedToken = normaliseOpt( optToken );
-            for( auto const &name : m_optNames ) {
-                if( normaliseOpt( name ) == normalisedToken )
-                    return true;
-            }
-            return false;
-        }
-
-        using ParserBase::parse;
-
-        auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
-            auto validationResult = validate();
-            if( !validationResult )
-                return InternalParseResult( validationResult );
-
-            auto remainingTokens = tokens;
-            if( remainingTokens && remainingTokens->type == TokenType::Option ) {
-                auto const &token = *remainingTokens;
-                if( isMatch(token.token ) ) {
-                    if( m_ref->isFlag() ) {
-                        auto result = m_ref->setFlag( true );
-                        if( !result )
-                            return InternalParseResult( result );
-                        if( result.value() == ParseResultType::ShortCircuitAll )
-                            return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
-                    } else {
-                        ++remainingTokens;
-                        if( !remainingTokens )
-                            return InternalParseResult::runtimeError( "Expected argument following " + token.token );
-                        auto const &argToken = *remainingTokens;
-                        if( argToken.type != TokenType::Argument )
-                            return InternalParseResult::runtimeError( "Expected argument following " + token.token );
-                        auto result = m_ref->setValue( argToken.token );
-                        if( !result )
-                            return InternalParseResult( result );
-                        if( result.value() == ParseResultType::ShortCircuitAll )
-                            return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
-                    }
-                    return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
-                }
-            }
-            return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
-        }
-
-        auto validate() const -> Result override {
-            if( m_optNames.empty() )
-                return Result::logicError( "No options supplied to Opt" );
-            for( auto const &name : m_optNames ) {
-                if( name.empty() )
-                    return Result::logicError( "Option name cannot be empty" );
-#ifdef CATCH_PLATFORM_WINDOWS
-                if( name[0] != '-' && name[0] != '/' )
-                    return Result::logicError( "Option name must begin with '-' or '/'" );
-#else
-                if( name[0] != '-' )
-                    return Result::logicError( "Option name must begin with '-'" );
-#endif
-            }
-            return ParserRefImpl::validate();
-        }
-    };
-
-    struct Help : Opt {
-        Help( bool &showHelpFlag )
-        :   Opt([&]( bool flag ) {
-                showHelpFlag = flag;
-                return ParserResult::ok( ParseResultType::ShortCircuitAll );
-            })
-        {
-            static_cast<Opt &>( *this )
-                    ("display usage information")
-                    ["-?"]["-h"]["--help"]
-                    .optional();
-        }
-    };
-
-    struct Parser : ParserBase {
-
-        mutable ExeName m_exeName;
-        std::vector<Opt> m_options;
-        std::vector<Arg> m_args;
-
-        auto operator|=( ExeName const &exeName ) -> Parser & {
-            m_exeName = exeName;
-            return *this;
-        }
-
-        auto operator|=( Arg const &arg ) -> Parser & {
-            m_args.push_back(arg);
-            return *this;
-        }
-
-        auto operator|=( Opt const &opt ) -> Parser & {
-            m_options.push_back(opt);
-            return *this;
-        }
-
-        auto operator|=( Parser const &other ) -> Parser & {
-            m_options.insert(m_options.end(), other.m_options.begin(), other.m_options.end());
-            m_args.insert(m_args.end(), other.m_args.begin(), other.m_args.end());
-            return *this;
-        }
-
-        template<typename T>
-        auto operator|( T const &other ) const -> Parser {
-            return Parser( *this ) |= other;
-        }
-
-        auto getHelpColumns() const -> std::vector<HelpColumns> {
-            std::vector<HelpColumns> cols;
-            for (auto const &o : m_options) {
-                auto childCols = o.getHelpColumns();
-                cols.insert( cols.end(), childCols.begin(), childCols.end() );
-            }
-            return cols;
-        }
-
-        void writeToStream( std::ostream &os ) const {
-            if (!m_exeName.name().empty()) {
-                os << "usage:\n" << "  " << m_exeName.name() << " ";
-                bool required = true, first = true;
-                for( auto const &arg : m_args ) {
-                    if (first)
-                        first = false;
-                    else
-                        os << " ";
-                    if( arg.isOptional() && required ) {
-                        os << "[";
-                        required = false;
-                    }
-                    os << "<" << arg.hint() << ">";
-                    if( arg.cardinality() == 0 )
-                        os << " ... ";
-                }
-                if( !required )
-                    os << "]";
-                if( !m_options.empty() )
-                    os << " options";
-                os << "\n\nwhere options are:" << std::endl;
-            }
-
-            auto rows = getHelpColumns();
-            size_t consoleWidth = CATCH_CLARA_CONFIG_CONSOLE_WIDTH;
-            size_t optWidth = 0;
-            for( auto const &cols : rows )
-                optWidth = (std::max)(optWidth, cols.left.size() + 2);
-
-            for( auto const &cols : rows ) {
-                auto row =
-                        TextFlow::Column( cols.left ).width( optWidth ).indent( 2 ) +
-                        TextFlow::Spacer(4) +
-                        TextFlow::Column( cols.right ).width( consoleWidth - 7 - optWidth );
-                os << row << std::endl;
-            }
-        }
-
-        friend auto operator<<( std::ostream &os, Parser const &parser ) -> std::ostream& {
-            parser.writeToStream( os );
-            return os;
-        }
-
-        auto validate() const -> Result override {
-            for( auto const &opt : m_options ) {
-                auto result = opt.validate();
-                if( !result )
-                    return result;
-            }
-            for( auto const &arg : m_args ) {
-                auto result = arg.validate();
-                if( !result )
-                    return result;
-            }
-            return Result::ok();
-        }
-
-        using ParserBase::parse;
-
-        auto parse( std::string const& exeName, TokenStream const &tokens ) const -> InternalParseResult override {
-
-            struct ParserInfo {
-                ParserBase const* parser = nullptr;
-                size_t count = 0;
-            };
-            const size_t totalParsers = m_options.size() + m_args.size();
-            assert( totalParsers < 512 );
-            // ParserInfo parseInfos[totalParsers]; // <-- this is what we really want to do
-            ParserInfo parseInfos[512];
-
-            {
-                size_t i = 0;
-                for (auto const &opt : m_options) parseInfos[i++].parser = &opt;
-                for (auto const &arg : m_args) parseInfos[i++].parser = &arg;
-            }
-
-            m_exeName.set( exeName );
-
-            auto result = InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
-            while( result.value().remainingTokens() ) {
-                bool tokenParsed = false;
-
-                for( size_t i = 0; i < totalParsers; ++i ) {
-                    auto&  parseInfo = parseInfos[i];
-                    if( parseInfo.parser->cardinality() == 0 || parseInfo.count < parseInfo.parser->cardinality() ) {
-                        result = parseInfo.parser->parse(exeName, result.value().remainingTokens());
-                        if (!result)
-                            return result;
-                        if (result.value().type() != ParseResultType::NoMatch) {
-                            tokenParsed = true;
-                            ++parseInfo.count;
-                            break;
-                        }
-                    }
-                }
-
-                if( result.value().type() == ParseResultType::ShortCircuitAll )
-                    return result;
-                if( !tokenParsed )
-                    return InternalParseResult::runtimeError( "Unrecognised token: " + result.value().remainingTokens()->token );
-            }
-            // !TBD Check missing required options
-            return result;
-        }
-    };
-
-    template<typename DerivedT>
-    template<typename T>
-    auto ComposableParserImpl<DerivedT>::operator|( T const &other ) const -> Parser {
-        return Parser() | static_cast<DerivedT const &>( *this ) | other;
-    }
-} // namespace detail
-
-// A Combined parser
-using detail::Parser;
-
-// A parser for options
-using detail::Opt;
-
-// A parser for arguments
-using detail::Arg;
-
-// Wrapper for argc, argv from main()
-using detail::Args;
-
-// Specifies the name of the executable
-using detail::ExeName;
-
-// Convenience wrapper for option parser that specifies the help option
-using detail::Help;
-
-// enum of result types from a parse
-using detail::ParseResultType;
-
-// Result type for parser operation
-using detail::ParserResult;
+			// Debug/ checking
+			virtual bool isSectionTracker() const = 0;
+			virtual bool isIndexTracker() const = 0;
+		};
 
-}} // namespace Catch::clara
+		class TrackerContext {
 
-// end clara.hpp
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
+			enum RunState {
+				NotStarted,
+				Executing,
+				CompletedCycle
+			};
 
-// Restore Clara's value for console width, if present
-#ifdef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
-#undef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
-#endif
+			ITrackerPtr m_rootTracker;
+			ITracker* m_currentTracker = nullptr;
+			RunState m_runState = NotStarted;
 
-// end catch_clara.h
-namespace Catch {
+		public:
 
-    clara::Parser makeCommandLineParser( ConfigData& config );
+			static TrackerContext& instance();
 
-} // end namespace Catch
+			ITracker& startRun();
+			void endRun();
 
-// end catch_commandline.h
-#include <fstream>
-#include <ctime>
+			void startCycle();
+			void completeCycle();
+
+			bool completedCycle() const;
+			ITracker& currentTracker();
+			void setCurrentTracker( ITracker* tracker );
+		};
+
+		class TrackerBase : public ITracker {
+		protected:
+			enum CycleState {
+				NotStarted,
+				Executing,
+				ExecutingChildren,
+				NeedsAnotherRun,
+				CompletedSuccessfully,
+				Failed
+			};
+
+			using Children = std::vector<ITrackerPtr>;
+			NameAndLocation m_nameAndLocation;
+			TrackerContext& m_ctx;
+			ITracker* m_parent;
+			Children m_children;
+			CycleState m_runState = NotStarted;
+
+		public:
+			TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
+
+			NameAndLocation const& nameAndLocation() const override;
+			bool isComplete() const override;
+			bool isSuccessfullyCompleted() const override;
+			bool isOpen() const override;
+			bool hasChildren() const override;
+
+			void addChild( ITrackerPtr const& child ) override;
+
+			ITrackerPtr findChild( NameAndLocation const& nameAndLocation ) override;
+			ITracker& parent() override;
+
+			void openChild() override;
+
+			bool isSectionTracker() const override;
+			bool isIndexTracker() const override;
+
+			void open();
+
+			void close() override;
+			void fail() override;
+			void markAsNeedingAnotherRun() override;
+
+		private:
+			void moveToParent();
+			void moveToThis();
+		};
+
+		class SectionTracker : public TrackerBase {
+			std::vector<std::string> m_filters;
+		public:
+			SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
+
+			bool isSectionTracker() const override;
+
+			static SectionTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation );
+
+			void tryOpen();
+
+			void addInitialFilters( std::vector<std::string> const& filters );
+			void addNextFilters( std::vector<std::string> const& filters );
+		};
+
+		class IndexTracker : public TrackerBase {
+			int m_size;
+			int m_index = -1;
+		public:
+			IndexTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent, int size );
+
+			bool isIndexTracker() const override;
+			void close() override;
+
+			static IndexTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation, int size );
+
+			int index() const;
+
+			void moveNext();
+		};
+
+	} // namespace TestCaseTracking
+
+	using TestCaseTracking::ITracker;
+	using TestCaseTracking::TrackerContext;
+	using TestCaseTracking::SectionTracker;
+	using TestCaseTracking::IndexTracker;
+
+} // namespace Catch
+
+  // end catch_test_case_tracker.h
+
+  // start catch_leak_detector.h
 
 namespace Catch {
 
-    clara::Parser makeCommandLineParser( ConfigData& config ) {
-
-        using namespace clara;
-
-        auto const setWarning = [&]( std::string const& warning ) {
-                if( warning != "NoAssertions" )
-                    return ParserResult::runtimeError( "Unrecognised warning: '" + warning + "'" );
-                config.warnings = static_cast<WarnAbout::What>( config.warnings | WarnAbout::NoAssertions );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const loadTestNamesFromFile = [&]( std::string const& filename ) {
-                std::ifstream f( filename.c_str() );
-                if( !f.is_open() )
-                    return ParserResult::runtimeError( "Unable to load input file: '" + filename + "'" );
-
-                std::string line;
-                while( std::getline( f, line ) ) {
-                    line = trim(line);
-                    if( !line.empty() && !startsWith( line, '#' ) ) {
-                        if( !startsWith( line, '"' ) )
-                            line = '"' + line + '"';
-                        config.testsOrTags.push_back( line + ',' );
-                    }
-                }
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setTestOrder = [&]( std::string const& order ) {
-                if( startsWith( "declared", order ) )
-                    config.runOrder = RunTests::InDeclarationOrder;
-                else if( startsWith( "lexical", order ) )
-                    config.runOrder = RunTests::InLexicographicalOrder;
-                else if( startsWith( "random", order ) )
-                    config.runOrder = RunTests::InRandomOrder;
-                else
-                    return clara::ParserResult::runtimeError( "Unrecognised ordering: '" + order + "'" );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setRngSeed = [&]( std::string const& seed ) {
-                if( seed != "time" )
-                    return clara::detail::convertInto( seed, config.rngSeed );
-                config.rngSeed = static_cast<unsigned int>( std::time(nullptr) );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setColourUsage = [&]( std::string const& useColour ) {
-                    auto mode = toLower( useColour );
-
-                    if( mode == "yes" )
-                        config.useColour = UseColour::Yes;
-                    else if( mode == "no" )
-                        config.useColour = UseColour::No;
-                    else if( mode == "auto" )
-                        config.useColour = UseColour::Auto;
-                    else
-                        return ParserResult::runtimeError( "colour mode must be one of: auto, yes or no. '" + useColour + "' not recognised" );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setWaitForKeypress = [&]( std::string const& keypress ) {
-                auto keypressLc = toLower( keypress );
-                if( keypressLc == "start" )
-                    config.waitForKeypress = WaitForKeypress::BeforeStart;
-                else if( keypressLc == "exit" )
-                    config.waitForKeypress = WaitForKeypress::BeforeExit;
-                else if( keypressLc == "both" )
-                    config.waitForKeypress = WaitForKeypress::BeforeStartAndExit;
-                else
-                    return ParserResult::runtimeError( "keypress argument must be one of: start, exit or both. '" + keypress + "' not recognised" );
-            return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setVerbosity = [&]( std::string const& verbosity ) {
-            auto lcVerbosity = toLower( verbosity );
-            if( lcVerbosity == "quiet" )
-                config.verbosity = Verbosity::Quiet;
-            else if( lcVerbosity == "normal" )
-                config.verbosity = Verbosity::Normal;
-            else if( lcVerbosity == "high" )
-                config.verbosity = Verbosity::High;
-            else
-                return ParserResult::runtimeError( "Unrecognised verbosity, '" + verbosity + "'" );
-            return ParserResult::ok( ParseResultType::Matched );
-        };
-
-        auto cli
-            = ExeName( config.processName )
-            | Help( config.showHelp )
-            | Opt( config.listTests )
-                ["-l"]["--list-tests"]
-                ( "list all/matching test cases" )
-            | Opt( config.listTags )
-                ["-t"]["--list-tags"]
-                ( "list all/matching tags" )
-            | Opt( config.showSuccessfulTests )
-                ["-s"]["--success"]
-                ( "include successful tests in output" )
-            | Opt( config.shouldDebugBreak )
-                ["-b"]["--break"]
-                ( "break into debugger on failure" )
-            | Opt( config.noThrow )
-                ["-e"]["--nothrow"]
-                ( "skip exception tests" )
-            | Opt( config.showInvisibles )
-                ["-i"]["--invisibles"]
-                ( "show invisibles (tabs, newlines)" )
-            | Opt( config.outputFilename, "filename" )
-                ["-o"]["--out"]
-                ( "output filename" )
-            | Opt( config.reporterNames, "name" )
-                ["-r"]["--reporter"]
-                ( "reporter to use (defaults to console)" )
-            | Opt( config.name, "name" )
-                ["-n"]["--name"]
-                ( "suite name" )
-            | Opt( [&]( bool ){ config.abortAfter = 1; } )
-                ["-a"]["--abort"]
-                ( "abort at first failure" )
-            | Opt( [&]( int x ){ config.abortAfter = x; }, "no. failures" )
-                ["-x"]["--abortx"]
-                ( "abort after x failures" )
-            | Opt( setWarning, "warning name" )
-                ["-w"]["--warn"]
-                ( "enable warnings" )
-            | Opt( [&]( bool flag ) { config.showDurations = flag ? ShowDurations::Always : ShowDurations::Never; }, "yes|no" )
-                ["-d"]["--durations"]
-                ( "show test durations" )
-            | Opt( loadTestNamesFromFile, "filename" )
-                ["-f"]["--input-file"]
-                ( "load test names to run from a file" )
-            | Opt( config.filenamesAsTags )
-                ["-#"]["--filenames-as-tags"]
-                ( "adds a tag for the filename" )
-            | Opt( config.sectionsToRun, "section name" )
-                ["-c"]["--section"]
-                ( "specify section to run" )
-            | Opt( setVerbosity, "quiet|normal|high" )
-                ["-v"]["--verbosity"]
-                ( "set output verbosity" )
-            | Opt( config.listTestNamesOnly )
-                ["--list-test-names-only"]
-                ( "list all/matching test cases names only" )
-            | Opt( config.listReporters )
-                ["--list-reporters"]
-                ( "list all reporters" )
-            | Opt( setTestOrder, "decl|lex|rand" )
-                ["--order"]
-                ( "test case order (defaults to decl)" )
-            | Opt( setRngSeed, "'time'|number" )
-                ["--rng-seed"]
-                ( "set a specific seed for random numbers" )
-            | Opt( setColourUsage, "yes|no" )
-                ["--use-colour"]
-                ( "should output be colourised" )
-            | Opt( config.libIdentify )
-                ["--libidentify"]
-                ( "report name and version according to libidentify standard" )
-            | Opt( setWaitForKeypress, "start|exit|both" )
-                ["--wait-for-keypress"]
-                ( "waits for a keypress before exiting" )
-            | Opt( config.benchmarkResolutionMultiple, "multiplier" )
-                ["--benchmark-resolution-multiple"]
-                ( "multiple of clock resolution to run benchmarks" )
-
-            | Arg( config.testsOrTags, "test name|pattern|tags" )
-                ( "which test or tests to use" );
-
-        return cli;
-    }
+	struct LeakDetector {
+		LeakDetector();
+		~LeakDetector();
+	};
+
+}
+// end catch_leak_detector.h
+// Cpp files will be included in the single-header file here
+// start catch_approx.cpp
+
+#include <cmath>
+#include <limits>
+
+namespace {
+
+	// Performs equivalent check of std::fabs(lhs - rhs) <= margin
+	// But without the subtraction to allow for INFINITY in comparison
+	bool marginComparison(double lhs, double rhs, double margin) {
+		return (lhs + margin >= rhs) && (rhs + margin >= lhs);
+	}
+
+}
+
+namespace Catch {
+	namespace Detail {
+
+		Approx::Approx ( double value )
+			:   m_epsilon( std::numeric_limits<float>::epsilon()*100 ),
+			m_margin( 0.0 ),
+			m_scale( 0.0 ),
+			m_value( value )
+		{}
+
+		Approx Approx::custom() {
+			return Approx( 0 );
+		}
+
+		Approx Approx::operator-() const {
+			auto temp(*this);
+			temp.m_value = -temp.m_value;
+			return temp;
+		}
+
+		std::string Approx::toString() const {
+			ReusableStringStream rss;
+			rss << "Approx( " << ::Catch::Detail::stringify( m_value ) << " )";
+			return rss.str();
+		}
+
+		bool Approx::equalityComparisonImpl(const double other) const {
+			// First try with fixed margin, then compute margin based on epsilon, scale and Approx's value
+			// Thanks to Richard Harris for his help refining the scaled margin value
+			return marginComparison(m_value, other, m_margin) || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(m_value)));
+		}
+
+		void Approx::setMargin(double margin) {
+			CATCH_ENFORCE(margin >= 0,
+				"Invalid Approx::margin: " << margin << '.'
+				<< " Approx::Margin has to be non-negative.");
+			m_margin = margin;
+		}
+
+		void Approx::setEpsilon(double epsilon) {
+			CATCH_ENFORCE(epsilon >= 0 && epsilon <= 1.0,
+				"Invalid Approx::epsilon: " << epsilon << '.'
+				<< " Approx::epsilon has to be in [0, 1]");
+			m_epsilon = epsilon;
+		}
+
+	} // end namespace Detail
+
+	namespace literals {
+		Detail::Approx operator "" _a(long double val) {
+			return Detail::Approx(val);
+		}
+		Detail::Approx operator "" _a(unsigned long long val) {
+			return Detail::Approx(val);
+		}
+	} // end namespace literals
+
+	std::string StringMaker<Catch::Detail::Approx>::convert(Catch::Detail::Approx const& value) {
+		return value.toString();
+	}
 
 } // end namespace Catch
-// end catch_commandline.cpp
-// start catch_common.cpp
+  // end catch_approx.cpp
+  // start catch_assertionhandler.cpp
 
-#include <cstring>
-#include <ostream>
+  // start catch_context.h
+
+#include <memory>
 
 namespace Catch {
 
-    SourceLineInfo::SourceLineInfo( char const* _file, std::size_t _line ) noexcept
-    :   file( _file ),
-        line( _line )
-    {}
-    bool SourceLineInfo::empty() const noexcept {
-        return file[0] == '\0';
-    }
-    bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const noexcept {
-        return line == other.line && (file == other.file || std::strcmp(file, other.file) == 0);
-    }
-    bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const noexcept {
-        return line < other.line || ( line == other.line && (std::strcmp(file, other.file) < 0));
-    }
+	struct IResultCapture;
+	struct IRunner;
+	struct IConfig;
+	struct IMutableContext;
 
-    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
-#ifndef __GNUG__
-        os << info.file << '(' << info.line << ')';
-#else
-        os << info.file << ':' << info.line;
-#endif
-        return os;
-    }
+	using IConfigPtr = std::shared_ptr<IConfig const>;
 
-    bool isTrue( bool value ){ return value; }
-    bool alwaysTrue() { return true; }
-    bool alwaysFalse() { return false; }
+	struct IContext
+	{
+		virtual ~IContext();
 
-    std::string StreamEndStop::operator+() const {
-        return std::string();
-    }
+		virtual IResultCapture* getResultCapture() = 0;
+		virtual IRunner* getRunner() = 0;
+		virtual IConfigPtr const& getConfig() const = 0;
+	};
 
-    NonCopyable::NonCopyable() = default;
-    NonCopyable::~NonCopyable() = default;
+	struct IMutableContext : IContext
+	{
+		virtual ~IMutableContext();
+		virtual void setResultCapture( IResultCapture* resultCapture ) = 0;
+		virtual void setRunner( IRunner* runner ) = 0;
+		virtual void setConfig( IConfigPtr const& config ) = 0;
 
+	private:
+		static IMutableContext *currentContext;
+		friend IMutableContext& getCurrentMutableContext();
+		friend void cleanUpContext();
+		static void createContext();
+	};
+
+	inline IMutableContext& getCurrentMutableContext()
+	{
+		if( !IMutableContext::currentContext )
+			IMutableContext::createContext();
+		return *IMutableContext::currentContext;
+	}
+
+	inline IContext& getCurrentContext()
+	{
+		return getCurrentMutableContext();
+	}
+
+	void cleanUpContext();
 }
-// end catch_common.cpp
-// start catch_config.cpp
+
+// end catch_context.h
+// start catch_debugger.h
 
 namespace Catch {
+	bool isDebuggerActive();
+}
 
-    Config::Config( ConfigData const& data )
-    :   m_data( data ),
-        m_stream( openStream() )
-    {
-        if( !data.testsOrTags.empty() ) {
-            TestSpecParser parser( ITagAliasRegistry::get() );
-            for( auto const& testOrTags : data.testsOrTags )
-                parser.parse( testOrTags );
-            m_testSpec = parser.testSpec();
-        }
-    }
-
-    std::string const& Config::getFilename() const {
-        return m_data.outputFilename ;
-    }
-
-    bool Config::listTests() const          { return m_data.listTests; }
-    bool Config::listTestNamesOnly() const  { return m_data.listTestNamesOnly; }
-    bool Config::listTags() const           { return m_data.listTags; }
-    bool Config::listReporters() const      { return m_data.listReporters; }
-
-    std::string Config::getProcessName() const { return m_data.processName; }
-
-    std::vector<std::string> const& Config::getReporterNames() const { return m_data.reporterNames; }
-    std::vector<std::string> const& Config::getSectionsToRun() const { return m_data.sectionsToRun; }
-
-    TestSpec const& Config::testSpec() const { return m_testSpec; }
-
-    bool Config::showHelp() const { return m_data.showHelp; }
-
-    // IConfig interface
-    bool Config::allowThrows() const                   { return !m_data.noThrow; }
-    std::ostream& Config::stream() const               { return m_stream->stream(); }
-    std::string Config::name() const                   { return m_data.name.empty() ? m_data.processName : m_data.name; }
-    bool Config::includeSuccessfulResults() const      { return m_data.showSuccessfulTests; }
-    bool Config::warnAboutMissingAssertions() const    { return m_data.warnings & WarnAbout::NoAssertions; }
-    ShowDurations::OrNot Config::showDurations() const { return m_data.showDurations; }
-    RunTests::InWhatOrder Config::runOrder() const     { return m_data.runOrder; }
-    unsigned int Config::rngSeed() const               { return m_data.rngSeed; }
-    int Config::benchmarkResolutionMultiple() const    { return m_data.benchmarkResolutionMultiple; }
-    UseColour::YesOrNo Config::useColour() const       { return m_data.useColour; }
-    bool Config::shouldDebugBreak() const              { return m_data.shouldDebugBreak; }
-    int Config::abortAfter() const                     { return m_data.abortAfter; }
-    bool Config::showInvisibles() const                { return m_data.showInvisibles; }
-    Verbosity Config::verbosity() const                { return m_data.verbosity; }
-
-    IStream const* Config::openStream() {
-        if( m_data.outputFilename.empty() )
-            return new CoutStream();
-        else if( m_data.outputFilename[0] == '%' ) {
-            if( m_data.outputFilename == "%debug" )
-                return new DebugOutStream();
-            else
-                CATCH_ERROR( "Unrecognised stream: '" << m_data.outputFilename << "'" );
-        }
-        else
-            return new FileStream( m_data.outputFilename );
-    }
+#ifdef CATCH_PLATFORM_MAC
 
-} // end namespace Catch
-// end catch_config.cpp
-// start catch_console_colour.cpp
+#define CATCH_TRAP() __asm__("int $3\n" : : ) /* NOLINT */
 
-#if defined(__clang__)
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wexit-time-destructors"
-#endif
+#elif defined(CATCH_PLATFORM_LINUX)
+// If we can use inline assembler, do it because this allows us to break
+// directly at the location of the failing check instead of breaking inside
+// raise() called from it, i.e. one stack frame below.
+#if defined(__GNUC__) && (defined(__i386) || defined(__x86_64))
+#define CATCH_TRAP() asm volatile ("int $3") /* NOLINT */
+#else // Fall back to the generic way.
+#include <signal.h>
 
-// start catch_errno_guard.h
+#define CATCH_TRAP() raise(SIGTRAP)
+#endif
+#elif defined(_MSC_VER)
+#define CATCH_TRAP() __debugbreak()
+#elif defined(__MINGW32__)
+extern "C" __declspec(dllimport) void __stdcall DebugBreak();
+#define CATCH_TRAP() DebugBreak()
+#endif
 
+#ifdef CATCH_TRAP
+#define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) { CATCH_TRAP(); }
+#else
 namespace Catch {
+	inline void doNothing() {}
+}
+#define CATCH_BREAK_INTO_DEBUGGER() Catch::doNothing()
+#endif
 
-    class ErrnoGuard {
-    public:
-        ErrnoGuard();
-        ~ErrnoGuard();
-    private:
-        int m_oldErrno;
-    };
+// end catch_debugger.h
+// start catch_run_context.h
 
-}
+// start catch_fatal_condition.h
 
-// end catch_errno_guard.h
 // start catch_windows_h_proxy.h
 
 
@@ -5919,5778 +5525,8455 @@ namespace Catch {
 #endif // defined(CATCH_PLATFORM_WINDOWS)
 
 // end catch_windows_h_proxy.h
+#if defined( CATCH_CONFIG_WINDOWS_SEH )
+
 namespace Catch {
-    namespace {
 
-        struct IColourImpl {
-            virtual ~IColourImpl() = default;
-            virtual void use( Colour::Code _colourCode ) = 0;
-        };
+	struct FatalConditionHandler {
 
-        struct NoColourImpl : IColourImpl {
-            void use( Colour::Code ) {}
+		static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo);
+		FatalConditionHandler();
+		static void reset();
+		~FatalConditionHandler();
 
-            static IColourImpl* instance() {
-                static NoColourImpl s_instance;
-                return &s_instance;
-            }
-        };
+	private:
+		static bool isSet;
+		static ULONG guaranteeSize;
+		static PVOID exceptionHandlerHandle;
+	};
 
-    } // anon namespace
 } // namespace Catch
 
-#if !defined( CATCH_CONFIG_COLOUR_NONE ) && !defined( CATCH_CONFIG_COLOUR_WINDOWS ) && !defined( CATCH_CONFIG_COLOUR_ANSI )
-#   ifdef CATCH_PLATFORM_WINDOWS
-#       define CATCH_CONFIG_COLOUR_WINDOWS
-#   else
-#       define CATCH_CONFIG_COLOUR_ANSI
-#   endif
-#endif
+#elif defined ( CATCH_CONFIG_POSIX_SIGNALS )
 
-#if defined ( CATCH_CONFIG_COLOUR_WINDOWS ) /////////////////////////////////////////
+#include <signal.h>
 
 namespace Catch {
-namespace {
 
-    class Win32ColourImpl : public IColourImpl {
-    public:
-        Win32ColourImpl() : stdoutHandle( GetStdHandle(STD_OUTPUT_HANDLE) )
-        {
-            CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
-            GetConsoleScreenBufferInfo( stdoutHandle, &csbiInfo );
-            originalForegroundAttributes = csbiInfo.wAttributes & ~( BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_INTENSITY );
-            originalBackgroundAttributes = csbiInfo.wAttributes & ~( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY );
-        }
-
-        virtual void use( Colour::Code _colourCode ) override {
-            switch( _colourCode ) {
-                case Colour::None:      return setTextAttribute( originalForegroundAttributes );
-                case Colour::White:     return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
-                case Colour::Red:       return setTextAttribute( FOREGROUND_RED );
-                case Colour::Green:     return setTextAttribute( FOREGROUND_GREEN );
-                case Colour::Blue:      return setTextAttribute( FOREGROUND_BLUE );
-                case Colour::Cyan:      return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN );
-                case Colour::Yellow:    return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN );
-                case Colour::Grey:      return setTextAttribute( 0 );
-
-                case Colour::LightGrey:     return setTextAttribute( FOREGROUND_INTENSITY );
-                case Colour::BrightRed:     return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED );
-                case Colour::BrightGreen:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN );
-                case Colour::BrightWhite:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
-
-                case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
-            }
-        }
-
-    private:
-        void setTextAttribute( WORD _textAttribute ) {
-            SetConsoleTextAttribute( stdoutHandle, _textAttribute | originalBackgroundAttributes );
-        }
-        HANDLE stdoutHandle;
-        WORD originalForegroundAttributes;
-        WORD originalBackgroundAttributes;
-    };
-
-    IColourImpl* platformColourInstance() {
-        static Win32ColourImpl s_instance;
-
-        IConfigPtr config = getCurrentContext().getConfig();
-        UseColour::YesOrNo colourMode = config
-            ? config->useColour()
-            : UseColour::Auto;
-        if( colourMode == UseColour::Auto )
-            colourMode = UseColour::Yes;
-        return colourMode == UseColour::Yes
-            ? &s_instance
-            : NoColourImpl::instance();
-    }
-
-} // end anon namespace
-} // end namespace Catch
+	struct FatalConditionHandler {
 
-#elif defined( CATCH_CONFIG_COLOUR_ANSI ) //////////////////////////////////////
+		static bool isSet;
+		static struct sigaction oldSigActions[];
+		static stack_t oldSigStack;
+		static char altStackMem[];
 
-#include <unistd.h>
+		static void handleSignal( int sig );
 
-namespace Catch {
-namespace {
+		FatalConditionHandler();
+		~FatalConditionHandler();
+		static void reset();
+	};
 
-    // use POSIX/ ANSI console terminal codes
-    // Thanks to Adam Strzelecki for original contribution
-    // (http://github.com/nanoant)
-    // https://github.com/philsquared/Catch/pull/131
-    class PosixColourImpl : public IColourImpl {
-    public:
-        virtual void use( Colour::Code _colourCode ) override {
-            switch( _colourCode ) {
-                case Colour::None:
-                case Colour::White:     return setColour( "[0m" );
-                case Colour::Red:       return setColour( "[0;31m" );
-                case Colour::Green:     return setColour( "[0;32m" );
-                case Colour::Blue:      return setColour( "[0;34m" );
-                case Colour::Cyan:      return setColour( "[0;36m" );
-                case Colour::Yellow:    return setColour( "[0;33m" );
-                case Colour::Grey:      return setColour( "[1;30m" );
-
-                case Colour::LightGrey:     return setColour( "[0;37m" );
-                case Colour::BrightRed:     return setColour( "[1;31m" );
-                case Colour::BrightGreen:   return setColour( "[1;32m" );
-                case Colour::BrightWhite:   return setColour( "[1;37m" );
-
-                case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
-            }
-        }
-        static IColourImpl* instance() {
-            static PosixColourImpl s_instance;
-            return &s_instance;
-        }
-
-    private:
-        void setColour( const char* _escapeCode ) {
-            Catch::cout() << '\033' << _escapeCode;
-        }
-    };
-
-    bool useColourOnPlatform() {
-        return
-#ifdef CATCH_PLATFORM_MAC
-            !isDebuggerActive() &&
-#endif
-            isatty(STDOUT_FILENO);
-    }
-    IColourImpl* platformColourInstance() {
-        ErrnoGuard guard;
-        IConfigPtr config = getCurrentContext().getConfig();
-        UseColour::YesOrNo colourMode = config
-            ? config->useColour()
-            : UseColour::Auto;
-        if( colourMode == UseColour::Auto )
-            colourMode = useColourOnPlatform()
-                ? UseColour::Yes
-                : UseColour::No;
-        return colourMode == UseColour::Yes
-            ? PosixColourImpl::instance()
-            : NoColourImpl::instance();
-    }
-
-} // end anon namespace
-} // end namespace Catch
+} // namespace Catch
 
-#else  // not Windows or ANSI ///////////////////////////////////////////////
+#else
 
 namespace Catch {
+	struct FatalConditionHandler {
+		void reset();
+	};
+}
 
-    static IColourImpl* platformColourInstance() { return NoColourImpl::instance(); }
-
-} // end namespace Catch
+#endif
 
-#endif // Windows/ ANSI/ None
+// end catch_fatal_condition.h
+#include <string>
 
 namespace Catch {
 
-    Colour::Colour( Code _colourCode ) { use( _colourCode ); }
-    Colour::Colour( Colour&& rhs ) noexcept {
-        m_moved = rhs.m_moved;
-        rhs.m_moved = true;
-    }
-    Colour& Colour::operator=( Colour&& rhs ) noexcept {
-        m_moved = rhs.m_moved;
-        rhs.m_moved  = true;
-        return *this;
-    }
+	struct IMutableContext;
 
-    Colour::~Colour(){ if( !m_moved ) use( None ); }
+	///////////////////////////////////////////////////////////////////////////
 
-    void Colour::use( Code _colourCode ) {
-        static IColourImpl* impl = platformColourInstance();
-        impl->use( _colourCode );
-    }
+	class RunContext : public IResultCapture, public IRunner {
 
-    std::ostream& operator << ( std::ostream& os, Colour const& ) {
-        return os;
-    }
+	public:
+		RunContext( RunContext const& ) = delete;
+		RunContext& operator =( RunContext const& ) = delete;
 
-} // end namespace Catch
-
-#if defined(__clang__)
-#    pragma clang diagnostic pop
-#endif
+		explicit RunContext( IConfigPtr const& _config, IStreamingReporterPtr&& reporter );
 
-// end catch_console_colour.cpp
-// start catch_context.cpp
-
-namespace Catch {
-
-    class Context : public IMutableContext, NonCopyable {
-
-    public: // IContext
-        virtual IResultCapture* getResultCapture() override {
-            return m_resultCapture;
-        }
-        virtual IRunner* getRunner() override {
-            return m_runner;
-        }
-
-        virtual IConfigPtr getConfig() const override {
-            return m_config;
-        }
-
-        virtual ~Context() override;
-
-    public: // IMutableContext
-        virtual void setResultCapture( IResultCapture* resultCapture ) override {
-            m_resultCapture = resultCapture;
-        }
-        virtual void setRunner( IRunner* runner ) override {
-            m_runner = runner;
-        }
-        virtual void setConfig( IConfigPtr const& config ) override {
-            m_config = config;
-        }
-
-        friend IMutableContext& getCurrentMutableContext();
-
-    private:
-        IConfigPtr m_config;
-        IRunner* m_runner = nullptr;
-        IResultCapture* m_resultCapture = nullptr;
-    };
-
-    namespace {
-        Context* currentContext = nullptr;
-    }
-    IMutableContext& getCurrentMutableContext() {
-        if( !currentContext )
-            currentContext = new Context();
-        return *currentContext;
-    }
-    IContext& getCurrentContext() {
-        return getCurrentMutableContext();
-    }
-
-    void cleanUpContext() {
-        delete currentContext;
-        currentContext = nullptr;
-    }
-    IContext::~IContext() = default;
-    IMutableContext::~IMutableContext() = default;
-    Context::~Context() = default;
-}
-// end catch_context.cpp
-// start catch_debug_console.cpp
+		~RunContext() override;
 
-// start catch_debug_console.h
+		void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount );
+		void testGroupEnded( std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount );
 
-#include <string>
+		Totals runTest(TestCase const& testCase);
 
-namespace Catch {
-    void writeToDebugConsole( std::string const& text );
-}
+		IConfigPtr config() const;
+		IStreamingReporter& reporter() const;
 
-// end catch_debug_console.h
-#ifdef CATCH_PLATFORM_WINDOWS
+	public: // IResultCapture
 
-    namespace Catch {
-        void writeToDebugConsole( std::string const& text ) {
-            ::OutputDebugStringA( text.c_str() );
-        }
-    }
-#else
-    namespace Catch {
-        void writeToDebugConsole( std::string const& text ) {
-            // !TBD: Need a version for Mac/ XCode and other IDEs
-            Catch::cout() << text;
-        }
-    }
-#endif // Platform
-// end catch_debug_console.cpp
-// start catch_debugger.cpp
+			// Assertion handlers
+		void handleExpr
+		(   AssertionInfo const& info,
+			ITransientExpression const& expr,
+			AssertionReaction& reaction ) override;
+		void handleMessage
+		(   AssertionInfo const& info,
+			ResultWas::OfType resultType,
+			StringRef const& message,
+			AssertionReaction& reaction ) override;
+		void handleUnexpectedExceptionNotThrown
+		(   AssertionInfo const& info,
+			AssertionReaction& reaction ) override;
+		void handleUnexpectedInflightException
+		(   AssertionInfo const& info,
+			std::string const& message,
+			AssertionReaction& reaction ) override;
+		void handleIncomplete
+		(   AssertionInfo const& info ) override;
+		void handleNonExpr
+		(   AssertionInfo const &info,
+			ResultWas::OfType resultType,
+			AssertionReaction &reaction ) override;
 
-#ifdef CATCH_PLATFORM_MAC
+		bool sectionStarted( SectionInfo const& sectionInfo, Counts& assertions ) override;
 
-    #include <assert.h>
-    #include <stdbool.h>
-    #include <sys/types.h>
-    #include <unistd.h>
-    #include <sys/sysctl.h>
+		void sectionEnded( SectionEndInfo const& endInfo ) override;
+		void sectionEndedEarly( SectionEndInfo const& endInfo ) override;
 
-    namespace Catch {
+		auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& override;
 
-        // The following function is taken directly from the following technical note:
-        // http://developer.apple.com/library/mac/#qa/qa2004/qa1361.html
+		void benchmarkStarting( BenchmarkInfo const& info ) override;
+		void benchmarkEnded( BenchmarkStats const& stats ) override;
 
-        // Returns true if the current process is being debugged (either
-        // running under the debugger or has a debugger attached post facto).
-        bool isDebuggerActive(){
+		void pushScopedMessage( MessageInfo const& message ) override;
+		void popScopedMessage( MessageInfo const& message ) override;
 
-            int                 mib[4];
-            struct kinfo_proc   info;
-            std::size_t         size;
+		std::string getCurrentTestName() const override;
 
-            // Initialize the flags so that, if sysctl fails for some bizarre
-            // reason, we get a predictable result.
+		const AssertionResult* getLastResult() const override;
 
-            info.kp_proc.p_flag = 0;
+		void exceptionEarlyReported() override;
 
-            // Initialize mib, which tells sysctl the info we want, in this case
-            // we're looking for information about a specific process ID.
+		void handleFatalErrorCondition( StringRef message ) override;
 
-            mib[0] = CTL_KERN;
-            mib[1] = KERN_PROC;
-            mib[2] = KERN_PROC_PID;
-            mib[3] = getpid();
+		bool lastAssertionPassed() override;
 
-            // Call sysctl.
+		void assertionPassed() override;
 
-            size = sizeof(info);
-            if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, nullptr, 0) != 0 ) {
-                Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n" << std::endl;
-                return false;
-            }
+	public:
+		// !TBD We need to do this another way!
+		bool aborting() const final;
 
-            // We're being debugged if the P_TRACED flag is set.
+	private:
 
-            return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
-        }
-    } // namespace Catch
+		void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr );
+		void invokeActiveTestCase();
 
-#elif defined(CATCH_PLATFORM_LINUX)
-    #include <fstream>
-    #include <string>
-
-    namespace Catch{
-        // The standard POSIX way of detecting a debugger is to attempt to
-        // ptrace() the process, but this needs to be done from a child and not
-        // this process itself to still allow attaching to this process later
-        // if wanted, so is rather heavy. Under Linux we have the PID of the
-        // "debugger" (which doesn't need to be gdb, of course, it could also
-        // be strace, for example) in /proc/$PID/status, so just get it from
-        // there instead.
-        bool isDebuggerActive(){
-            // Libstdc++ has a bug, where std::ifstream sets errno to 0
-            // This way our users can properly assert over errno values
-            ErrnoGuard guard;
-            std::ifstream in("/proc/self/status");
-            for( std::string line; std::getline(in, line); ) {
-                static const int PREFIX_LEN = 11;
-                if( line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0 ) {
-                    // We're traced if the PID is not 0 and no other PID starts
-                    // with 0 digit, so it's enough to check for just a single
-                    // character.
-                    return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0';
-                }
-            }
-
-            return false;
-        }
-    } // namespace Catch
-#elif defined(_MSC_VER)
-    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
-    namespace Catch {
-        bool isDebuggerActive() {
-            return IsDebuggerPresent() != 0;
-        }
-    }
-#elif defined(__MINGW32__)
-    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
-    namespace Catch {
-        bool isDebuggerActive() {
-            return IsDebuggerPresent() != 0;
-        }
-    }
-#else
-    namespace Catch {
-       bool isDebuggerActive() { return false; }
-    }
-#endif // Platform
-// end catch_debugger.cpp
-// start catch_decomposer.cpp
+		void resetAssertionInfo();
+		bool testForMissingAssertions( Counts& assertions );
 
-namespace Catch {
+		void assertionEnded( AssertionResult const& result );
+		void reportExpr
+		(   AssertionInfo const &info,
+			ResultWas::OfType resultType,
+			ITransientExpression const *expr,
+			bool negated );
 
-    ITransientExpression::~ITransientExpression() = default;
+		void populateReaction( AssertionReaction& reaction );
 
-    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs ) {
-        if( lhs.size() + rhs.size() < 40 &&
-                lhs.find('\n') == std::string::npos &&
-                rhs.find('\n') == std::string::npos )
-            os << lhs << " " << op << " " << rhs;
-        else
-            os << lhs << "\n" << op << "\n" << rhs;
-    }
-}
-// end catch_decomposer.cpp
-// start catch_errno_guard.cpp
+	private:
 
-#include <cerrno>
+		void handleUnfinishedSections();
 
-namespace Catch {
-        ErrnoGuard::ErrnoGuard():m_oldErrno(errno){}
-        ErrnoGuard::~ErrnoGuard() { errno = m_oldErrno; }
-}
-// end catch_errno_guard.cpp
-// start catch_exception_translator_registry.cpp
+		TestRunInfo m_runInfo;
+		IMutableContext& m_context;
+		TestCase const* m_activeTestCase = nullptr;
+		ITracker* m_testCaseTracker;
+		Option<AssertionResult> m_lastResult;
 
-// start catch_exception_translator_registry.h
+		IConfigPtr m_config;
+		Totals m_totals;
+		IStreamingReporterPtr m_reporter;
+		std::vector<MessageInfo> m_messages;
+		AssertionInfo m_lastAssertionInfo;
+		std::vector<SectionEndInfo> m_unfinishedSections;
+		std::vector<ITracker*> m_activeSections;
+		TrackerContext m_trackerContext;
+		bool m_lastAssertionPassed = false;
+		bool m_shouldReportUnexpected = true;
+		bool m_includeSuccessfulResults;
+	};
 
-#include <vector>
-#include <string>
-#include <memory>
+} // end namespace Catch
 
+  // end catch_run_context.h
 namespace Catch {
 
-    class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry {
-    public:
-        ~ExceptionTranslatorRegistry();
-        virtual void registerTranslator( const IExceptionTranslator* translator );
-        virtual std::string translateActiveException() const override;
-        std::string tryTranslators() const;
+	namespace {
+		auto operator <<( std::ostream& os, ITransientExpression const& expr ) -> std::ostream& {
+			expr.streamReconstructedExpression( os );
+			return os;
+		}
+	}
 
-    private:
-        std::vector<std::unique_ptr<IExceptionTranslator const>> m_translators;
-    };
-}
+	LazyExpression::LazyExpression( bool isNegated )
+		:   m_isNegated( isNegated )
+	{}
 
-// end catch_exception_translator_registry.h
-#ifdef __OBJC__
-#import "Foundation/Foundation.h"
-#endif
+	LazyExpression::LazyExpression( LazyExpression const& other ) : m_isNegated( other.m_isNegated ) {}
 
-namespace Catch {
+	LazyExpression::operator bool() const {
+		return m_transientExpression != nullptr;
+	}
 
-    ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry() {
-    }
+	auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream& {
+		if( lazyExpr.m_isNegated )
+			os << "!";
+
+		if( lazyExpr ) {
+			if( lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression() )
+				os << "(" << *lazyExpr.m_transientExpression << ")";
+			else
+				os << *lazyExpr.m_transientExpression;
+		}
+		else {
+			os << "{** error - unchecked empty expression requested **}";
+		}
+		return os;
+	}
 
-    void ExceptionTranslatorRegistry::registerTranslator( const IExceptionTranslator* translator ) {
-        m_translators.push_back( std::unique_ptr<const IExceptionTranslator>( translator ) );
-    }
+	AssertionHandler::AssertionHandler
+	(   StringRef const& macroName,
+		SourceLineInfo const& lineInfo,
+		StringRef capturedExpression,
+		ResultDisposition::Flags resultDisposition )
+		:   m_assertionInfo{ macroName, lineInfo, capturedExpression, resultDisposition },
+		m_resultCapture( getResultCapture() )
+	{}
+
+	void AssertionHandler::handleExpr( ITransientExpression const& expr ) {
+		m_resultCapture.handleExpr( m_assertionInfo, expr, m_reaction );
+	}
+	void AssertionHandler::handleMessage(ResultWas::OfType resultType, StringRef const& message) {
+		m_resultCapture.handleMessage( m_assertionInfo, resultType, message, m_reaction );
+	}
 
-    std::string ExceptionTranslatorRegistry::translateActiveException() const {
-        try {
-#ifdef __OBJC__
-            // In Objective-C try objective-c exceptions first
-            @try {
-                return tryTranslators();
-            }
-            @catch (NSException *exception) {
-                return Catch::Detail::stringify( [exception description] );
-            }
-#else
-            return tryTranslators();
-#endif
-        }
-        catch( TestFailureException& ) {
-            std::rethrow_exception(std::current_exception());
-        }
-        catch( std::exception& ex ) {
-            return ex.what();
-        }
-        catch( std::string& msg ) {
-            return msg;
-        }
-        catch( const char* msg ) {
-            return msg;
-        }
-        catch(...) {
-            return "Unknown exception";
-        }
-    }
-
-    std::string ExceptionTranslatorRegistry::tryTranslators() const {
-        if( m_translators.empty() )
-            std::rethrow_exception(std::current_exception());
-        else
-            return m_translators[0]->translate( m_translators.begin()+1, m_translators.end() );
-    }
-}
-// end catch_exception_translator_registry.cpp
-// start catch_fatal_condition.cpp
+	auto AssertionHandler::allowThrows() const -> bool {
+		return getCurrentContext().getConfig()->allowThrows();
+	}
 
-// start catch_fatal_condition.h
+	void AssertionHandler::complete() {
+		setCompleted();
+		if( m_reaction.shouldDebugBreak ) {
 
-#include <string>
+			// If you find your debugger stopping you here then go one level up on the
+			// call-stack for the code that caused it (typically a failed assertion)
 
-#if defined ( CATCH_PLATFORM_WINDOWS ) /////////////////////////////////////////
+			// (To go back to the test and change execution, jump over the throw, next)
+			CATCH_BREAK_INTO_DEBUGGER();
+		}
+		if (m_reaction.shouldThrow) {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+			throw Catch::TestFailureException();
+#else
+			CATCH_ERROR( "Test failure requires aborting test!" );
+#endif
+		}
+	}
+	void AssertionHandler::setCompleted() {
+		m_completed = true;
+	}
 
-#  if !defined ( CATCH_CONFIG_WINDOWS_SEH )
+	void AssertionHandler::handleUnexpectedInflightException() {
+		m_resultCapture.handleUnexpectedInflightException( m_assertionInfo, Catch::translateActiveException(), m_reaction );
+	}
 
-namespace Catch {
-    struct FatalConditionHandler {
-        void reset();
-    };
-}
+	void AssertionHandler::handleExceptionThrownAsExpected() {
+		m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+	}
+	void AssertionHandler::handleExceptionNotThrownAsExpected() {
+		m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+	}
 
-#  else // CATCH_CONFIG_WINDOWS_SEH is defined
+	void AssertionHandler::handleUnexpectedExceptionNotThrown() {
+		m_resultCapture.handleUnexpectedExceptionNotThrown( m_assertionInfo, m_reaction );
+	}
+
+	void AssertionHandler::handleThrowingCallSkipped() {
+		m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+	}
+
+	// This is the overload that takes a string and infers the Equals matcher from it
+	// The more general overload, that takes any string matcher, is in catch_capture_matchers.cpp
+	void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString  ) {
+		handleExceptionMatchExpr( handler, Matchers::Equals( str ), matcherString );
+	}
+
+} // namespace Catch
+  // end catch_assertionhandler.cpp
+  // start catch_assertionresult.cpp
 
 namespace Catch {
+	AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const & _lazyExpression):
+		lazyExpression(_lazyExpression),
+		resultType(_resultType) {}
 
-    struct FatalConditionHandler {
+	std::string AssertionResultData::reconstructExpression() const {
 
-        static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo);
-        FatalConditionHandler();
-        static void reset();
-        ~FatalConditionHandler();
+		if( reconstructedExpression.empty() ) {
+			if( lazyExpression ) {
+				ReusableStringStream rss;
+				rss << lazyExpression;
+				reconstructedExpression = rss.str();
+			}
+		}
+		return reconstructedExpression;
+	}
 
-    private:
-        static bool isSet;
-        static ULONG guaranteeSize;
-        static PVOID exceptionHandlerHandle;
-    };
+	AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
+		:   m_info( info ),
+		m_resultData( data )
+	{}
 
-} // namespace Catch
+	// Result was a success
+	bool AssertionResult::succeeded() const {
+		return Catch::isOk( m_resultData.resultType );
+	}
 
-#  endif // CATCH_CONFIG_WINDOWS_SEH
+	// Result was a success, or failure is suppressed
+	bool AssertionResult::isOk() const {
+		return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
+	}
 
-#else // Not Windows - assumed to be POSIX compatible //////////////////////////
+	ResultWas::OfType AssertionResult::getResultType() const {
+		return m_resultData.resultType;
+	}
 
-#  if !defined(CATCH_CONFIG_POSIX_SIGNALS)
+	bool AssertionResult::hasExpression() const {
+		return m_info.capturedExpression[0] != 0;
+	}
 
-namespace Catch {
-    struct FatalConditionHandler {
-        void reset();
-    };
-}
+	bool AssertionResult::hasMessage() const {
+		return !m_resultData.message.empty();
+	}
 
-#  else // CATCH_CONFIG_POSIX_SIGNALS is defined
+	std::string AssertionResult::getExpression() const {
+		if( isFalseTest( m_info.resultDisposition ) )
+			return "!(" + m_info.capturedExpression + ")";
+		else
+			return m_info.capturedExpression;
+	}
 
-#include <signal.h>
+	std::string AssertionResult::getExpressionInMacro() const {
+		std::string expr;
+		if( m_info.macroName[0] == 0 )
+			expr = m_info.capturedExpression;
+		else {
+			expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
+			expr += m_info.macroName;
+			expr += "( ";
+			expr += m_info.capturedExpression;
+			expr += " )";
+		}
+		return expr;
+	}
 
-namespace Catch {
+	bool AssertionResult::hasExpandedExpression() const {
+		return hasExpression() && getExpandedExpression() != getExpression();
+	}
 
-    struct FatalConditionHandler {
+	std::string AssertionResult::getExpandedExpression() const {
+		std::string expr = m_resultData.reconstructExpression();
+		return expr.empty()
+			? getExpression()
+			: expr;
+	}
 
-        static bool isSet;
-        static struct sigaction oldSigActions[];// [sizeof(signalDefs) / sizeof(SignalDefs)];
-        static stack_t oldSigStack;
-        static char altStackMem[];
+	std::string AssertionResult::getMessage() const {
+		return m_resultData.message;
+	}
+	SourceLineInfo AssertionResult::getSourceInfo() const {
+		return m_info.lineInfo;
+	}
 
-        static void handleSignal( int sig );
+	StringRef AssertionResult::getTestMacroName() const {
+		return m_info.macroName;
+	}
 
-        FatalConditionHandler();
-        ~FatalConditionHandler();
-        static void reset();
-    };
+} // end namespace Catch
+  // end catch_assertionresult.cpp
+  // start catch_benchmark.cpp
 
-} // namespace Catch
+namespace Catch {
 
-#  endif // CATCH_CONFIG_POSIX_SIGNALS
+	auto BenchmarkLooper::getResolution() -> uint64_t {
+		return getEstimatedClockResolution() * getCurrentContext().getConfig()->benchmarkResolutionMultiple();
+	}
 
-#endif // not Windows
+	void BenchmarkLooper::reportStart() {
+		getResultCapture().benchmarkStarting( { m_name } );
+	}
+	auto BenchmarkLooper::needsMoreIterations() -> bool {
+		auto elapsed = m_timer.getElapsedNanoseconds();
 
-// end catch_fatal_condition.h
-namespace {
-    // Report the error condition
-    void reportFatal( char const * const message ) {
-        Catch::getCurrentContext().getResultCapture()->handleFatalErrorCondition( message );
-    }
-}
+		// Exponentially increasing iterations until we're confident in our timer resolution
+		if( elapsed < m_resolution ) {
+			m_iterationsToRun *= 10;
+			return true;
+		}
 
-#if defined ( CATCH_PLATFORM_WINDOWS ) /////////////////////////////////////////
+		getResultCapture().benchmarkEnded( { { m_name }, m_count, elapsed } );
+		return false;
+	}
 
-#  if !defined ( CATCH_CONFIG_WINDOWS_SEH )
+} // end namespace Catch
+  // end catch_benchmark.cpp
+  // start catch_capture_matchers.cpp
 
 namespace Catch {
-    void FatalConditionHandler::reset() {}
-}
 
-#  else // CATCH_CONFIG_WINDOWS_SEH is defined
-
-namespace Catch {
-    struct SignalDefs { DWORD id; const char* name; };
-
-    // There is no 1-1 mapping between signals and windows exceptions.
-    // Windows can easily distinguish between SO and SigSegV,
-    // but SigInt, SigTerm, etc are handled differently.
-    static SignalDefs signalDefs[] = {
-        { EXCEPTION_ILLEGAL_INSTRUCTION,  "SIGILL - Illegal instruction signal" },
-        { EXCEPTION_STACK_OVERFLOW, "SIGSEGV - Stack overflow" },
-        { EXCEPTION_ACCESS_VIOLATION, "SIGSEGV - Segmentation violation signal" },
-        { EXCEPTION_INT_DIVIDE_BY_ZERO, "Divide by zero error" },
-    };
-
-    LONG CALLBACK FatalConditionHandler::handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {
-        for (auto const& def : signalDefs) {
-            if (ExceptionInfo->ExceptionRecord->ExceptionCode == def.id) {
-                reportFatal(def.name);
-            }
-        }
-        // If its not an exception we care about, pass it along.
-        // This stops us from eating debugger breaks etc.
-        return EXCEPTION_CONTINUE_SEARCH;
-    }
-
-    FatalConditionHandler::FatalConditionHandler() {
-        isSet = true;
-        // 32k seems enough for Catch to handle stack overflow,
-        // but the value was found experimentally, so there is no strong guarantee
-        guaranteeSize = 32 * 1024;
-        exceptionHandlerHandle = nullptr;
-        // Register as first handler in current chain
-        exceptionHandlerHandle = AddVectoredExceptionHandler(1, handleVectoredException);
-        // Pass in guarantee size to be filled
-        SetThreadStackGuarantee(&guaranteeSize);
-    }
-
-    void FatalConditionHandler::reset() {
-        if (isSet) {
-            // Unregister handler and restore the old guarantee
-            RemoveVectoredExceptionHandler(exceptionHandlerHandle);
-            SetThreadStackGuarantee(&guaranteeSize);
-            exceptionHandlerHandle = nullptr;
-            isSet = false;
-        }
-    }
-
-    FatalConditionHandler::~FatalConditionHandler() {
-        reset();
-    }
-
-bool FatalConditionHandler::isSet = false;
-ULONG FatalConditionHandler::guaranteeSize = 0;
-PVOID FatalConditionHandler::exceptionHandlerHandle = nullptr;
+	using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
 
-} // namespace Catch
+	// This is the general overload that takes a any string matcher
+	// There is another overload, in catch_assertionhandler.h/.cpp, that only takes a string and infers
+	// the Equals matcher (so the header does not mention matchers)
+	void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString  ) {
+		std::string exceptionMessage = Catch::translateActiveException();
+		MatchExpr<std::string, StringMatcher const&> expr( exceptionMessage, matcher, matcherString );
+		handler.handleExpr( expr );
+	}
 
-#  endif // CATCH_CONFIG_WINDOWS_SEH
+} // namespace Catch
+  // end catch_capture_matchers.cpp
+  // start catch_commandline.cpp
 
-#else // Not Windows - assumed to be POSIX compatible //////////////////////////
+  // start catch_commandline.h
 
-#  if !defined(CATCH_CONFIG_POSIX_SIGNALS)
+  // start catch_clara.h
 
-namespace Catch {
-    void FatalConditionHandler::reset() {}
-}
+  // Use Catch's value for console width (store Clara's off to the side, if present)
+#ifdef CLARA_CONFIG_CONSOLE_WIDTH
+#define CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
+#undef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
+#endif
+#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH-1
 
-#  else // CATCH_CONFIG_POSIX_SIGNALS is defined
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wweak-vtables"
+#pragma clang diagnostic ignored "-Wexit-time-destructors"
+#pragma clang diagnostic ignored "-Wshadow"
+#endif
 
-#include <signal.h>
+  // start clara.hpp
+  // Copyright 2017 Two Blue Cubes Ltd. All rights reserved.
+  //
+  // Distributed under 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)
+  //
+  // See https://github.com/philsquared/Clara for more details
 
-namespace Catch {
+  // Clara v1.1.5
 
-    struct SignalDefs {
-        int id;
-        const char* name;
-    };
-    static SignalDefs signalDefs[] = {
-        { SIGINT,  "SIGINT - Terminal interrupt signal" },
-        { SIGILL,  "SIGILL - Illegal instruction signal" },
-        { SIGFPE,  "SIGFPE - Floating point error signal" },
-        { SIGSEGV, "SIGSEGV - Segmentation violation signal" },
-        { SIGTERM, "SIGTERM - Termination request signal" },
-        { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }
-    };
-
-    void FatalConditionHandler::handleSignal( int sig ) {
-        char const * name = "<unknown signal>";
-        for (auto const& def : signalDefs) {
-            if (sig == def.id) {
-                name = def.name;
-                break;
-            }
-        }
-        reset();
-        reportFatal(name);
-        raise( sig );
-    }
-
-    FatalConditionHandler::FatalConditionHandler() {
-        isSet = true;
-        stack_t sigStack;
-        sigStack.ss_sp = altStackMem;
-        sigStack.ss_size = SIGSTKSZ;
-        sigStack.ss_flags = 0;
-        sigaltstack(&sigStack, &oldSigStack);
-        struct sigaction sa = { };
-
-        sa.sa_handler = handleSignal;
-        sa.sa_flags = SA_ONSTACK;
-        for (std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i) {
-            sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
-        }
-    }
-
-    FatalConditionHandler::~FatalConditionHandler() {
-        reset();
-    }
-
-    void FatalConditionHandler::reset() {
-        if( isSet ) {
-            // Set signals back to previous values -- hopefully nobody overwrote them in the meantime
-            for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) {
-                sigaction(signalDefs[i].id, &oldSigActions[i], nullptr);
-            }
-            // Return the old stack
-            sigaltstack(&oldSigStack, nullptr);
-            isSet = false;
-        }
-    }
-
-    bool FatalConditionHandler::isSet = false;
-    struct sigaction FatalConditionHandler::oldSigActions[sizeof(signalDefs)/sizeof(SignalDefs)] = {};
-    stack_t FatalConditionHandler::oldSigStack = {};
-    char FatalConditionHandler::altStackMem[SIGSTKSZ] = {};
 
-} // namespace Catch
+#ifndef CATCH_CLARA_CONFIG_CONSOLE_WIDTH
+#define CATCH_CLARA_CONFIG_CONSOLE_WIDTH 80
+#endif
 
-#  endif // CATCH_CONFIG_POSIX_SIGNALS
+#ifndef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
+#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CLARA_CONFIG_CONSOLE_WIDTH
+#endif
 
-#endif // not Windows
-// end catch_fatal_condition.cpp
-// start catch_interfaces_capture.cpp
+#ifndef CLARA_CONFIG_OPTIONAL_TYPE
+#ifdef __has_include
+#if __has_include(<optional>) && __cplusplus >= 201703L
+#include <optional>
+#define CLARA_CONFIG_OPTIONAL_TYPE std::optional
+#endif
+#endif
+#endif
 
-namespace Catch {
-    IResultCapture::~IResultCapture() = default;
-}
-// end catch_interfaces_capture.cpp
-// start catch_interfaces_config.cpp
+  // ----------- #included from clara_textflow.hpp -----------
 
-namespace Catch {
-    IConfig::~IConfig() = default;
-}
-// end catch_interfaces_config.cpp
-// start catch_interfaces_exception.cpp
+  // TextFlowCpp
+  //
+  // A single-header library for wrapping and laying out basic text, by Phil Nash
+  //
+  // Distributed under the Boost Software License, Version 1.0. (See accompanying
+  // file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+  //
+  // This project is hosted at https://github.com/philsquared/textflowcpp
 
-namespace Catch {
-    IExceptionTranslator::~IExceptionTranslator() = default;
-    IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() = default;
-}
-// end catch_interfaces_exception.cpp
-// start catch_interfaces_registry_hub.cpp
 
-namespace Catch {
-    IRegistryHub::~IRegistryHub() = default;
-    IMutableRegistryHub::~IMutableRegistryHub() = default;
-}
-// end catch_interfaces_registry_hub.cpp
-// start catch_interfaces_reporter.cpp
+#include <cassert>
+#include <ostream>
+#include <sstream>
+#include <vector>
 
-// start catch_reporter_multi.h
+#ifndef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
+#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH 80
+#endif
 
 namespace Catch {
+	namespace clara {
+		namespace TextFlow {
+
+			inline auto isWhitespace(char c) -> bool {
+				static std::string chars = " \t\n\r";
+				return chars.find(c) != std::string::npos;
+			}
+			inline auto isBreakableBefore(char c) -> bool {
+				static std::string chars = "[({<|";
+				return chars.find(c) != std::string::npos;
+			}
+			inline auto isBreakableAfter(char c) -> bool {
+				static std::string chars = "])}>.,:;*+-=&/\\";
+				return chars.find(c) != std::string::npos;
+			}
+
+			class Columns;
+
+			class Column {
+				std::vector<std::string> m_strings;
+				size_t m_width = CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH;
+				size_t m_indent = 0;
+				size_t m_initialIndent = std::string::npos;
+
+			public:
+				class iterator {
+					friend Column;
+
+					Column const& m_column;
+					size_t m_stringIndex = 0;
+					size_t m_pos = 0;
+
+					size_t m_len = 0;
+					size_t m_end = 0;
+					bool m_suffix = false;
+
+					iterator(Column const& column, size_t stringIndex)
+						: m_column(column),
+						m_stringIndex(stringIndex) {}
+
+					auto line() const -> std::string const& { return m_column.m_strings[m_stringIndex]; }
+
+					auto isBoundary(size_t at) const -> bool {
+						assert(at > 0);
+						assert(at <= line().size());
+
+						return at == line().size() ||
+							(isWhitespace(line()[at]) && !isWhitespace(line()[at - 1])) ||
+							isBreakableBefore(line()[at]) ||
+							isBreakableAfter(line()[at - 1]);
+					}
+
+					void calcLength() {
+						assert(m_stringIndex < m_column.m_strings.size());
+
+						m_suffix = false;
+						auto width = m_column.m_width - indent();
+						m_end = m_pos;
+						while (m_end < line().size() && line()[m_end] != '\n')
+							++m_end;
+
+						if (m_end < m_pos + width) {
+							m_len = m_end - m_pos;
+						} else {
+							size_t len = width;
+							while (len > 0 && !isBoundary(m_pos + len))
+								--len;
+							while (len > 0 && isWhitespace(line()[m_pos + len - 1]))
+								--len;
+
+							if (len > 0) {
+								m_len = len;
+							} else {
+								m_suffix = true;
+								m_len = width - 1;
+							}
+						}
+					}
+
+					auto indent() const -> size_t {
+						auto initial = m_pos == 0 && m_stringIndex == 0 ? m_column.m_initialIndent : std::string::npos;
+						return initial == std::string::npos ? m_column.m_indent : initial;
+					}
+
+					auto addIndentAndSuffix(std::string const &plain) const -> std::string {
+						return std::string(indent(), ' ') + (m_suffix ? plain + "-" : plain);
+					}
+
+				public:
+					using difference_type = std::ptrdiff_t;
+					using value_type = std::string;
+					using pointer = value_type * ;
+					using reference = value_type & ;
+					using iterator_category = std::forward_iterator_tag;
+
+					explicit iterator(Column const& column) : m_column(column) {
+						assert(m_column.m_width > m_column.m_indent);
+						assert(m_column.m_initialIndent == std::string::npos || m_column.m_width > m_column.m_initialIndent);
+						calcLength();
+						if (m_len == 0)
+							m_stringIndex++; // Empty string
+					}
+
+					auto operator *() const -> std::string {
+						assert(m_stringIndex < m_column.m_strings.size());
+						assert(m_pos <= m_end);
+						return addIndentAndSuffix(line().substr(m_pos, m_len));
+					}
+
+					auto operator ++() -> iterator& {
+						m_pos += m_len;
+						if (m_pos < line().size() && line()[m_pos] == '\n')
+							m_pos += 1;
+						else
+							while (m_pos < line().size() && isWhitespace(line()[m_pos]))
+								++m_pos;
+
+						if (m_pos == line().size()) {
+							m_pos = 0;
+							++m_stringIndex;
+						}
+						if (m_stringIndex < m_column.m_strings.size())
+							calcLength();
+						return *this;
+					}
+					auto operator ++(int) -> iterator {
+						iterator prev(*this);
+						operator++();
+						return prev;
+					}
+
+					auto operator ==(iterator const& other) const -> bool {
+						return
+							m_pos == other.m_pos &&
+							m_stringIndex == other.m_stringIndex &&
+							&m_column == &other.m_column;
+					}
+					auto operator !=(iterator const& other) const -> bool {
+						return !operator==(other);
+					}
+				};
+				using const_iterator = iterator;
+
+				explicit Column(std::string const& text) { m_strings.push_back(text); }
+
+				auto width(size_t newWidth) -> Column& {
+					assert(newWidth > 0);
+					m_width = newWidth;
+					return *this;
+				}
+				auto indent(size_t newIndent) -> Column& {
+					m_indent = newIndent;
+					return *this;
+				}
+				auto initialIndent(size_t newIndent) -> Column& {
+					m_initialIndent = newIndent;
+					return *this;
+				}
+
+				auto width() const -> size_t { return m_width; }
+				auto begin() const -> iterator { return iterator(*this); }
+				auto end() const -> iterator { return { *this, m_strings.size() }; }
+
+				inline friend std::ostream& operator << (std::ostream& os, Column const& col) {
+					bool first = true;
+					for (auto line : col) {
+						if (first)
+							first = false;
+						else
+							os << "\n";
+						os << line;
+					}
+					return os;
+				}
+
+				auto operator + (Column const& other)->Columns;
+
+				auto toString() const -> std::string {
+					std::ostringstream oss;
+					oss << *this;
+					return oss.str();
+				}
+			};
+
+			class Spacer : public Column {
+
+			public:
+				explicit Spacer(size_t spaceWidth) : Column("") {
+					width(spaceWidth);
+				}
+			};
+
+			class Columns {
+				std::vector<Column> m_columns;
+
+			public:
+
+				class iterator {
+					friend Columns;
+					struct EndTag {};
+
+					std::vector<Column> const& m_columns;
+					std::vector<Column::iterator> m_iterators;
+					size_t m_activeIterators;
+
+					iterator(Columns const& columns, EndTag)
+						: m_columns(columns.m_columns),
+						m_activeIterators(0) {
+						m_iterators.reserve(m_columns.size());
+
+						for (auto const& col : m_columns)
+							m_iterators.push_back(col.end());
+					}
+
+				public:
+					using difference_type = std::ptrdiff_t;
+					using value_type = std::string;
+					using pointer = value_type * ;
+					using reference = value_type & ;
+					using iterator_category = std::forward_iterator_tag;
+
+					explicit iterator(Columns const& columns)
+						: m_columns(columns.m_columns),
+						m_activeIterators(m_columns.size()) {
+						m_iterators.reserve(m_columns.size());
+
+						for (auto const& col : m_columns)
+							m_iterators.push_back(col.begin());
+					}
+
+					auto operator ==(iterator const& other) const -> bool {
+						return m_iterators == other.m_iterators;
+					}
+					auto operator !=(iterator const& other) const -> bool {
+						return m_iterators != other.m_iterators;
+					}
+					auto operator *() const -> std::string {
+						std::string row, padding;
+
+						for (size_t i = 0; i < m_columns.size(); ++i) {
+							auto width = m_columns[i].width();
+							if (m_iterators[i] != m_columns[i].end()) {
+								std::string col = *m_iterators[i];
+								row += padding + col;
+								if (col.size() < width)
+									padding = std::string(width - col.size(), ' ');
+								else
+									padding = "";
+							} else {
+								padding += std::string(width, ' ');
+							}
+						}
+						return row;
+					}
+					auto operator ++() -> iterator& {
+						for (size_t i = 0; i < m_columns.size(); ++i) {
+							if (m_iterators[i] != m_columns[i].end())
+								++m_iterators[i];
+						}
+						return *this;
+					}
+					auto operator ++(int) -> iterator {
+						iterator prev(*this);
+						operator++();
+						return prev;
+					}
+				};
+				using const_iterator = iterator;
+
+				auto begin() const -> iterator { return iterator(*this); }
+				auto end() const -> iterator { return { *this, iterator::EndTag() }; }
+
+				auto operator += (Column const& col) -> Columns& {
+					m_columns.push_back(col);
+					return *this;
+				}
+				auto operator + (Column const& col) -> Columns {
+					Columns combined = *this;
+					combined += col;
+					return combined;
+				}
+
+				inline friend std::ostream& operator << (std::ostream& os, Columns const& cols) {
+
+					bool first = true;
+					for (auto line : cols) {
+						if (first)
+							first = false;
+						else
+							os << "\n";
+						os << line;
+					}
+					return os;
+				}
+
+				auto toString() const -> std::string {
+					std::ostringstream oss;
+					oss << *this;
+					return oss.str();
+				}
+			};
+
+			inline auto Column::operator + (Column const& other) -> Columns {
+				Columns cols;
+				cols += *this;
+				cols += other;
+				return cols;
+			}
+		}
 
-    class MultipleReporters : public IStreamingReporter {
-        using Reporters = std::vector<IStreamingReporterPtr>;
-        Reporters m_reporters;
-
-    public:
-        void add( IStreamingReporterPtr&& reporter );
+	}
+}
 
-    public: // IStreamingReporter
+// ----------- end of #include from clara_textflow.hpp -----------
+// ........... back in clara.hpp
 
-        ReporterPreferences getPreferences() const override;
+#include <string>
+#include <memory>
+#include <set>
+#include <algorithm>
 
-        void noMatchingTestCases( std::string const& spec ) override;
+#if !defined(CATCH_PLATFORM_WINDOWS) && ( defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) )
+#define CATCH_PLATFORM_WINDOWS
+#endif
 
-        static std::set<Verbosity> getSupportedVerbosities();
+namespace Catch { namespace clara {
+	namespace detail {
+
+		// Traits for extracting arg and return type of lambdas (for single argument lambdas)
+		template<typename L>
+		struct UnaryLambdaTraits : UnaryLambdaTraits<decltype( &L::operator() )> {};
+
+		template<typename ClassT, typename ReturnT, typename... Args>
+		struct UnaryLambdaTraits<ReturnT( ClassT::* )( Args... ) const> {
+			static const bool isValid = false;
+		};
+
+		template<typename ClassT, typename ReturnT, typename ArgT>
+		struct UnaryLambdaTraits<ReturnT( ClassT::* )( ArgT ) const> {
+			static const bool isValid = true;
+			using ArgType = typename std::remove_const<typename std::remove_reference<ArgT>::type>::type;
+			using ReturnType = ReturnT;
+		};
+
+		class TokenStream;
+
+		// Transport for raw args (copied from main args, or supplied via init list for testing)
+		class Args {
+			friend TokenStream;
+			std::string m_exeName;
+			std::vector<std::string> m_args;
+
+		public:
+			Args( int argc, char const* const* argv )
+				: m_exeName(argv[0]),
+				m_args(argv + 1, argv + argc) {}
+
+			Args( std::initializer_list<std::string> args )
+				:   m_exeName( *args.begin() ),
+				m_args( args.begin()+1, args.end() )
+			{}
+
+			auto exeName() const -> std::string {
+				return m_exeName;
+			}
+		};
+
+		// Wraps a token coming from a token stream. These may not directly correspond to strings as a single string
+		// may encode an option + its argument if the : or = form is used
+		enum class TokenType {
+			Option, Argument
+		};
+		struct Token {
+			TokenType type;
+			std::string token;
+		};
+
+		inline auto isOptPrefix( char c ) -> bool {
+			return c == '-'
+#ifdef CATCH_PLATFORM_WINDOWS
+				|| c == '/'
+#endif
+				;
+		}
+
+		// Abstracts iterators into args as a stream of tokens, with option arguments uniformly handled
+		class TokenStream {
+			using Iterator = std::vector<std::string>::const_iterator;
+			Iterator it;
+			Iterator itEnd;
+			std::vector<Token> m_tokenBuffer;
+
+			void loadBuffer() {
+				m_tokenBuffer.resize( 0 );
+
+				// Skip any empty strings
+				while( it != itEnd && it->empty() )
+					++it;
+
+				if( it != itEnd ) {
+					auto const &next = *it;
+					if( isOptPrefix( next[0] ) ) {
+						auto delimiterPos = next.find_first_of( " :=" );
+						if( delimiterPos != std::string::npos ) {
+							m_tokenBuffer.push_back( { TokenType::Option, next.substr( 0, delimiterPos ) } );
+							m_tokenBuffer.push_back( { TokenType::Argument, next.substr( delimiterPos + 1 ) } );
+						} else {
+							if( next[1] != '-' && next.size() > 2 ) {
+								std::string opt = "- ";
+								for( size_t i = 1; i < next.size(); ++i ) {
+									opt[1] = next[i];
+									m_tokenBuffer.push_back( { TokenType::Option, opt } );
+								}
+							} else {
+								m_tokenBuffer.push_back( { TokenType::Option, next } );
+							}
+						}
+					} else {
+						m_tokenBuffer.push_back( { TokenType::Argument, next } );
+					}
+				}
+			}
+
+		public:
+			explicit TokenStream( Args const &args ) : TokenStream( args.m_args.begin(), args.m_args.end() ) {}
+
+			TokenStream( Iterator it, Iterator itEnd ) : it( it ), itEnd( itEnd ) {
+				loadBuffer();
+			}
+
+			explicit operator bool() const {
+				return !m_tokenBuffer.empty() || it != itEnd;
+			}
+
+			auto count() const -> size_t { return m_tokenBuffer.size() + (itEnd - it); }
+
+			auto operator*() const -> Token {
+				assert( !m_tokenBuffer.empty() );
+				return m_tokenBuffer.front();
+			}
+
+			auto operator->() const -> Token const * {
+				assert( !m_tokenBuffer.empty() );
+				return &m_tokenBuffer.front();
+			}
+
+			auto operator++() -> TokenStream & {
+				if( m_tokenBuffer.size() >= 2 ) {
+					m_tokenBuffer.erase( m_tokenBuffer.begin() );
+				} else {
+					if( it != itEnd )
+						++it;
+					loadBuffer();
+				}
+				return *this;
+			}
+		};
+
+		class ResultBase {
+		public:
+			enum Type {
+				Ok, LogicError, RuntimeError
+			};
+
+		protected:
+			ResultBase( Type type ) : m_type( type ) {}
+			virtual ~ResultBase() = default;
+
+			virtual void enforceOk() const = 0;
+
+			Type m_type;
+		};
+
+		template<typename T>
+		class ResultValueBase : public ResultBase {
+		public:
+			auto value() const -> T const & {
+				enforceOk();
+				return m_value;
+			}
+
+		protected:
+			ResultValueBase( Type type ) : ResultBase( type ) {}
+
+			ResultValueBase( ResultValueBase const &other ) : ResultBase( other ) {
+				if( m_type == ResultBase::Ok )
+					new( &m_value ) T( other.m_value );
+			}
+
+			ResultValueBase( Type, T const &value ) : ResultBase( Ok ) {
+				new( &m_value ) T( value );
+			}
+
+			auto operator=( ResultValueBase const &other ) -> ResultValueBase & {
+				if( m_type == ResultBase::Ok )
+					m_value.~T();
+				ResultBase::operator=(other);
+				if( m_type == ResultBase::Ok )
+					new( &m_value ) T( other.m_value );
+				return *this;
+			}
+
+			~ResultValueBase() override {
+				if( m_type == Ok )
+					m_value.~T();
+			}
+
+			union {
+				T m_value;
+			};
+		};
+
+		template<>
+		class ResultValueBase<void> : public ResultBase {
+		protected:
+			using ResultBase::ResultBase;
+		};
+
+		template<typename T = void>
+		class BasicResult : public ResultValueBase<T> {
+		public:
+			template<typename U>
+			explicit BasicResult( BasicResult<U> const &other )
+				:   ResultValueBase<T>( other.type() ),
+				m_errorMessage( other.errorMessage() )
+			{
+				assert( type() != ResultBase::Ok );
+			}
+
+			template<typename U>
+			static auto ok( U const &value ) -> BasicResult { return { ResultBase::Ok, value }; }
+			static auto ok() -> BasicResult { return { ResultBase::Ok }; }
+			static auto logicError( std::string const &message ) -> BasicResult { return { ResultBase::LogicError, message }; }
+			static auto runtimeError( std::string const &message ) -> BasicResult { return { ResultBase::RuntimeError, message }; }
+
+			explicit operator bool() const { return m_type == ResultBase::Ok; }
+			auto type() const -> ResultBase::Type { return m_type; }
+			auto errorMessage() const -> std::string { return m_errorMessage; }
+
+		protected:
+			void enforceOk() const override {
+
+				// Errors shouldn't reach this point, but if they do
+				// the actual error message will be in m_errorMessage
+				assert( m_type != ResultBase::LogicError );
+				assert( m_type != ResultBase::RuntimeError );
+				if( m_type != ResultBase::Ok )
+					std::abort();
+			}
+
+			std::string m_errorMessage; // Only populated if resultType is an error
+
+			BasicResult( ResultBase::Type type, std::string const &message )
+				:   ResultValueBase<T>(type),
+				m_errorMessage(message)
+			{
+				assert( m_type != ResultBase::Ok );
+			}
+
+			using ResultValueBase<T>::ResultValueBase;
+			using ResultBase::m_type;
+		};
+
+		enum class ParseResultType {
+			Matched, NoMatch, ShortCircuitAll, ShortCircuitSame
+		};
+
+		class ParseState {
+		public:
+
+			ParseState( ParseResultType type, TokenStream const &remainingTokens )
+				: m_type(type),
+				m_remainingTokens( remainingTokens )
+			{}
+
+			auto type() const -> ParseResultType { return m_type; }
+			auto remainingTokens() const -> TokenStream { return m_remainingTokens; }
+
+		private:
+			ParseResultType m_type;
+			TokenStream m_remainingTokens;
+		};
+
+		using Result = BasicResult<void>;
+		using ParserResult = BasicResult<ParseResultType>;
+		using InternalParseResult = BasicResult<ParseState>;
+
+		struct HelpColumns {
+			std::string left;
+			std::string right;
+		};
+
+		template<typename T>
+		inline auto convertInto( std::string const &source, T& target ) -> ParserResult {
+			std::stringstream ss;
+			ss << source;
+			ss >> target;
+			if( ss.fail() )
+				return ParserResult::runtimeError( "Unable to convert '" + source + "' to destination type" );
+			else
+				return ParserResult::ok( ParseResultType::Matched );
+		}
+		inline auto convertInto( std::string const &source, std::string& target ) -> ParserResult {
+			target = source;
+			return ParserResult::ok( ParseResultType::Matched );
+		}
+		inline auto convertInto( std::string const &source, bool &target ) -> ParserResult {
+			std::string srcLC = source;
+			std::transform( srcLC.begin(), srcLC.end(), srcLC.begin(), []( char c ) { return static_cast<char>( ::tolower(c) ); } );
+			if (srcLC == "y" || srcLC == "1" || srcLC == "true" || srcLC == "yes" || srcLC == "on")
+				target = true;
+			else if (srcLC == "n" || srcLC == "0" || srcLC == "false" || srcLC == "no" || srcLC == "off")
+				target = false;
+			else
+				return ParserResult::runtimeError( "Expected a boolean value but did not recognise: '" + source + "'" );
+			return ParserResult::ok( ParseResultType::Matched );
+		}
+#ifdef CLARA_CONFIG_OPTIONAL_TYPE
+		template<typename T>
+		inline auto convertInto( std::string const &source, CLARA_CONFIG_OPTIONAL_TYPE<T>& target ) -> ParserResult {
+			T temp;
+			auto result = convertInto( source, temp );
+			if( result )
+				target = std::move(temp);
+			return result;
+		}
+#endif // CLARA_CONFIG_OPTIONAL_TYPE
+
+		struct NonCopyable {
+			NonCopyable() = default;
+			NonCopyable( NonCopyable const & ) = delete;
+			NonCopyable( NonCopyable && ) = delete;
+			NonCopyable &operator=( NonCopyable const & ) = delete;
+			NonCopyable &operator=( NonCopyable && ) = delete;
+		};
+
+		struct BoundRef : NonCopyable {
+			virtual ~BoundRef() = default;
+			virtual auto isContainer() const -> bool { return false; }
+			virtual auto isFlag() const -> bool { return false; }
+		};
+		struct BoundValueRefBase : BoundRef {
+			virtual auto setValue( std::string const &arg ) -> ParserResult = 0;
+		};
+		struct BoundFlagRefBase : BoundRef {
+			virtual auto setFlag( bool flag ) -> ParserResult = 0;
+			virtual auto isFlag() const -> bool { return true; }
+		};
+
+		template<typename T>
+		struct BoundValueRef : BoundValueRefBase {
+			T &m_ref;
+
+			explicit BoundValueRef( T &ref ) : m_ref( ref ) {}
+
+			auto setValue( std::string const &arg ) -> ParserResult override {
+				return convertInto( arg, m_ref );
+			}
+		};
+
+		template<typename T>
+		struct BoundValueRef<std::vector<T>> : BoundValueRefBase {
+			std::vector<T> &m_ref;
+
+			explicit BoundValueRef( std::vector<T> &ref ) : m_ref( ref ) {}
+
+			auto isContainer() const -> bool override { return true; }
+
+			auto setValue( std::string const &arg ) -> ParserResult override {
+				T temp;
+				auto result = convertInto( arg, temp );
+				if( result )
+					m_ref.push_back( temp );
+				return result;
+			}
+		};
+
+		struct BoundFlagRef : BoundFlagRefBase {
+			bool &m_ref;
+
+			explicit BoundFlagRef( bool &ref ) : m_ref( ref ) {}
+
+			auto setFlag( bool flag ) -> ParserResult override {
+				m_ref = flag;
+				return ParserResult::ok( ParseResultType::Matched );
+			}
+		};
+
+		template<typename ReturnType>
+		struct LambdaInvoker {
+			static_assert( std::is_same<ReturnType, ParserResult>::value, "Lambda must return void or clara::ParserResult" );
+
+			template<typename L, typename ArgType>
+			static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
+				return lambda( arg );
+			}
+		};
+
+		template<>
+		struct LambdaInvoker<void> {
+			template<typename L, typename ArgType>
+			static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
+				lambda( arg );
+				return ParserResult::ok( ParseResultType::Matched );
+			}
+		};
+
+		template<typename ArgType, typename L>
+		inline auto invokeLambda( L const &lambda, std::string const &arg ) -> ParserResult {
+			ArgType temp{};
+			auto result = convertInto( arg, temp );
+			return !result
+				? result
+				: LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( lambda, temp );
+		}
+
+		template<typename L>
+		struct BoundLambda : BoundValueRefBase {
+			L m_lambda;
+
+			static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
+			explicit BoundLambda( L const &lambda ) : m_lambda( lambda ) {}
+
+			auto setValue( std::string const &arg ) -> ParserResult override {
+				return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>( m_lambda, arg );
+			}
+		};
+
+		template<typename L>
+		struct BoundFlagLambda : BoundFlagRefBase {
+			L m_lambda;
+
+			static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
+			static_assert( std::is_same<typename UnaryLambdaTraits<L>::ArgType, bool>::value, "flags must be boolean" );
+
+			explicit BoundFlagLambda( L const &lambda ) : m_lambda( lambda ) {}
+
+			auto setFlag( bool flag ) -> ParserResult override {
+				return LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( m_lambda, flag );
+			}
+		};
+
+		enum class Optionality { Optional, Required };
+
+		struct Parser;
+
+		class ParserBase {
+		public:
+			virtual ~ParserBase() = default;
+			virtual auto validate() const -> Result { return Result::ok(); }
+			virtual auto parse( std::string const& exeName, TokenStream const &tokens) const -> InternalParseResult  = 0;
+			virtual auto cardinality() const -> size_t { return 1; }
+
+			auto parse( Args const &args ) const -> InternalParseResult {
+				return parse( args.exeName(), TokenStream( args ) );
+			}
+		};
+
+		template<typename DerivedT>
+		class ComposableParserImpl : public ParserBase {
+		public:
+			template<typename T>
+			auto operator|( T const &other ) const -> Parser;
+
+			template<typename T>
+			auto operator+( T const &other ) const -> Parser;
+		};
+
+		// Common code and state for Args and Opts
+		template<typename DerivedT>
+		class ParserRefImpl : public ComposableParserImpl<DerivedT> {
+		protected:
+			Optionality m_optionality = Optionality::Optional;
+			std::shared_ptr<BoundRef> m_ref;
+			std::string m_hint;
+			std::string m_description;
+
+			explicit ParserRefImpl( std::shared_ptr<BoundRef> const &ref ) : m_ref( ref ) {}
+
+		public:
+			template<typename T>
+			ParserRefImpl( T &ref, std::string const &hint )
+				:   m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
+				m_hint( hint )
+			{}
+
+			template<typename LambdaT>
+			ParserRefImpl( LambdaT const &ref, std::string const &hint )
+				:   m_ref( std::make_shared<BoundLambda<LambdaT>>( ref ) ),
+				m_hint(hint)
+			{}
+
+			auto operator()( std::string const &description ) -> DerivedT & {
+				m_description = description;
+				return static_cast<DerivedT &>( *this );
+			}
+
+			auto optional() -> DerivedT & {
+				m_optionality = Optionality::Optional;
+				return static_cast<DerivedT &>( *this );
+			};
+
+			auto required() -> DerivedT & {
+				m_optionality = Optionality::Required;
+				return static_cast<DerivedT &>( *this );
+			};
+
+			auto isOptional() const -> bool {
+				return m_optionality == Optionality::Optional;
+			}
+
+			auto cardinality() const -> size_t override {
+				if( m_ref->isContainer() )
+					return 0;
+				else
+					return 1;
+			}
+
+			auto hint() const -> std::string { return m_hint; }
+		};
+
+		class ExeName : public ComposableParserImpl<ExeName> {
+			std::shared_ptr<std::string> m_name;
+			std::shared_ptr<BoundValueRefBase> m_ref;
+
+			template<typename LambdaT>
+			static auto makeRef(LambdaT const &lambda) -> std::shared_ptr<BoundValueRefBase> {
+				return std::make_shared<BoundLambda<LambdaT>>( lambda) ;
+			}
+
+		public:
+			ExeName() : m_name( std::make_shared<std::string>( "<executable>" ) ) {}
+
+			explicit ExeName( std::string &ref ) : ExeName() {
+				m_ref = std::make_shared<BoundValueRef<std::string>>( ref );
+			}
+
+			template<typename LambdaT>
+			explicit ExeName( LambdaT const& lambda ) : ExeName() {
+				m_ref = std::make_shared<BoundLambda<LambdaT>>( lambda );
+			}
+
+			// The exe name is not parsed out of the normal tokens, but is handled specially
+			auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
+				return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
+			}
+
+			auto name() const -> std::string { return *m_name; }
+			auto set( std::string const& newName ) -> ParserResult {
+
+				auto lastSlash = newName.find_last_of( "\\/" );
+				auto filename = ( lastSlash == std::string::npos )
+					? newName
+					: newName.substr( lastSlash+1 );
+
+				*m_name = filename;
+				if( m_ref )
+					return m_ref->setValue( filename );
+				else
+					return ParserResult::ok( ParseResultType::Matched );
+			}
+		};
+
+		class Arg : public ParserRefImpl<Arg> {
+		public:
+			using ParserRefImpl::ParserRefImpl;
+
+			auto parse( std::string const &, TokenStream const &tokens ) const -> InternalParseResult override {
+				auto validationResult = validate();
+				if( !validationResult )
+					return InternalParseResult( validationResult );
+
+				auto remainingTokens = tokens;
+				auto const &token = *remainingTokens;
+				if( token.type != TokenType::Argument )
+					return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
+
+				assert( !m_ref->isFlag() );
+				auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );
+
+				auto result = valueRef->setValue( remainingTokens->token );
+				if( !result )
+					return InternalParseResult( result );
+				else
+					return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
+			}
+		};
+
+		inline auto normaliseOpt( std::string const &optName ) -> std::string {
+#ifdef CATCH_PLATFORM_WINDOWS
+			if( optName[0] == '/' )
+				return "-" + optName.substr( 1 );
+			else
+#endif
+				return optName;
+		}
+
+		class Opt : public ParserRefImpl<Opt> {
+		protected:
+			std::vector<std::string> m_optNames;
+
+		public:
+			template<typename LambdaT>
+			explicit Opt( LambdaT const &ref ) : ParserRefImpl( std::make_shared<BoundFlagLambda<LambdaT>>( ref ) ) {}
+
+			explicit Opt( bool &ref ) : ParserRefImpl( std::make_shared<BoundFlagRef>( ref ) ) {}
+
+			template<typename LambdaT>
+			Opt( LambdaT const &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}
+
+			template<typename T>
+			Opt( T &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}
+
+			auto operator[]( std::string const &optName ) -> Opt & {
+				m_optNames.push_back( optName );
+				return *this;
+			}
+
+			auto getHelpColumns() const -> std::vector<HelpColumns> {
+				std::ostringstream oss;
+				bool first = true;
+				for( auto const &opt : m_optNames ) {
+					if (first)
+						first = false;
+					else
+						oss << ", ";
+					oss << opt;
+				}
+				if( !m_hint.empty() )
+					oss << " <" << m_hint << ">";
+				return { { oss.str(), m_description } };
+			}
+
+			auto isMatch( std::string const &optToken ) const -> bool {
+				auto normalisedToken = normaliseOpt( optToken );
+				for( auto const &name : m_optNames ) {
+					if( normaliseOpt( name ) == normalisedToken )
+						return true;
+				}
+				return false;
+			}
+
+			using ParserBase::parse;
+
+			auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
+				auto validationResult = validate();
+				if( !validationResult )
+					return InternalParseResult( validationResult );
+
+				auto remainingTokens = tokens;
+				if( remainingTokens && remainingTokens->type == TokenType::Option ) {
+					auto const &token = *remainingTokens;
+					if( isMatch(token.token ) ) {
+						if( m_ref->isFlag() ) {
+							auto flagRef = static_cast<detail::BoundFlagRefBase*>( m_ref.get() );
+							auto result = flagRef->setFlag( true );
+							if( !result )
+								return InternalParseResult( result );
+							if( result.value() == ParseResultType::ShortCircuitAll )
+								return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
+						} else {
+							auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );
+							++remainingTokens;
+							if( !remainingTokens )
+								return InternalParseResult::runtimeError( "Expected argument following " + token.token );
+							auto const &argToken = *remainingTokens;
+							if( argToken.type != TokenType::Argument )
+								return InternalParseResult::runtimeError( "Expected argument following " + token.token );
+							auto result = valueRef->setValue( argToken.token );
+							if( !result )
+								return InternalParseResult( result );
+							if( result.value() == ParseResultType::ShortCircuitAll )
+								return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
+						}
+						return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
+					}
+				}
+				return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
+			}
+
+			auto validate() const -> Result override {
+				if( m_optNames.empty() )
+					return Result::logicError( "No options supplied to Opt" );
+				for( auto const &name : m_optNames ) {
+					if( name.empty() )
+						return Result::logicError( "Option name cannot be empty" );
+#ifdef CATCH_PLATFORM_WINDOWS
+					if( name[0] != '-' && name[0] != '/' )
+						return Result::logicError( "Option name must begin with '-' or '/'" );
+#else
+					if( name[0] != '-' )
+						return Result::logicError( "Option name must begin with '-'" );
+#endif
+				}
+				return ParserRefImpl::validate();
+			}
+		};
+
+		struct Help : Opt {
+			Help( bool &showHelpFlag )
+				:   Opt([&]( bool flag ) {
+				showHelpFlag = flag;
+				return ParserResult::ok( ParseResultType::ShortCircuitAll );
+			})
+			{
+				static_cast<Opt &>( *this )
+					("display usage information")
+					["-?"]["-h"]["--help"]
+					.optional();
+			}
+		};
+
+		struct Parser : ParserBase {
+
+			mutable ExeName m_exeName;
+			std::vector<Opt> m_options;
+			std::vector<Arg> m_args;
+
+			auto operator|=( ExeName const &exeName ) -> Parser & {
+				m_exeName = exeName;
+				return *this;
+			}
+
+			auto operator|=( Arg const &arg ) -> Parser & {
+				m_args.push_back(arg);
+				return *this;
+			}
+
+			auto operator|=( Opt const &opt ) -> Parser & {
+				m_options.push_back(opt);
+				return *this;
+			}
+
+			auto operator|=( Parser const &other ) -> Parser & {
+				m_options.insert(m_options.end(), other.m_options.begin(), other.m_options.end());
+				m_args.insert(m_args.end(), other.m_args.begin(), other.m_args.end());
+				return *this;
+			}
+
+			template<typename T>
+			auto operator|( T const &other ) const -> Parser {
+				return Parser( *this ) |= other;
+			}
+
+			// Forward deprecated interface with '+' instead of '|'
+			template<typename T>
+			auto operator+=( T const &other ) -> Parser & { return operator|=( other ); }
+			template<typename T>
+			auto operator+( T const &other ) const -> Parser { return operator|( other ); }
+
+			auto getHelpColumns() const -> std::vector<HelpColumns> {
+				std::vector<HelpColumns> cols;
+				for (auto const &o : m_options) {
+					auto childCols = o.getHelpColumns();
+					cols.insert( cols.end(), childCols.begin(), childCols.end() );
+				}
+				return cols;
+			}
+
+			void writeToStream( std::ostream &os ) const {
+				if (!m_exeName.name().empty()) {
+					os << "usage:\n" << "  " << m_exeName.name() << " ";
+					bool required = true, first = true;
+					for( auto const &arg : m_args ) {
+						if (first)
+							first = false;
+						else
+							os << " ";
+						if( arg.isOptional() && required ) {
+							os << "[";
+							required = false;
+						}
+						os << "<" << arg.hint() << ">";
+						if( arg.cardinality() == 0 )
+							os << " ... ";
+					}
+					if( !required )
+						os << "]";
+					if( !m_options.empty() )
+						os << " options";
+					os << "\n\nwhere options are:" << std::endl;
+				}
+
+				auto rows = getHelpColumns();
+				size_t consoleWidth = CATCH_CLARA_CONFIG_CONSOLE_WIDTH;
+				size_t optWidth = 0;
+				for( auto const &cols : rows )
+					optWidth = (std::max)(optWidth, cols.left.size() + 2);
+
+				optWidth = (std::min)(optWidth, consoleWidth/2);
+
+				for( auto const &cols : rows ) {
+					auto row =
+						TextFlow::Column( cols.left ).width( optWidth ).indent( 2 ) +
+						TextFlow::Spacer(4) +
+						TextFlow::Column( cols.right ).width( consoleWidth - 7 - optWidth );
+					os << row << std::endl;
+				}
+			}
+
+			friend auto operator<<( std::ostream &os, Parser const &parser ) -> std::ostream& {
+				parser.writeToStream( os );
+				return os;
+			}
+
+			auto validate() const -> Result override {
+				for( auto const &opt : m_options ) {
+					auto result = opt.validate();
+					if( !result )
+						return result;
+				}
+				for( auto const &arg : m_args ) {
+					auto result = arg.validate();
+					if( !result )
+						return result;
+				}
+				return Result::ok();
+			}
+
+			using ParserBase::parse;
+
+			auto parse( std::string const& exeName, TokenStream const &tokens ) const -> InternalParseResult override {
+
+				struct ParserInfo {
+					ParserBase const* parser = nullptr;
+					size_t count = 0;
+				};
+				const size_t totalParsers = m_options.size() + m_args.size();
+				assert( totalParsers < 512 );
+				// ParserInfo parseInfos[totalParsers]; // <-- this is what we really want to do
+				ParserInfo parseInfos[512];
+
+				{
+					size_t i = 0;
+					for (auto const &opt : m_options) parseInfos[i++].parser = &opt;
+					for (auto const &arg : m_args) parseInfos[i++].parser = &arg;
+				}
+
+				m_exeName.set( exeName );
+
+				auto result = InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
+				while( result.value().remainingTokens() ) {
+					bool tokenParsed = false;
+
+					for( size_t i = 0; i < totalParsers; ++i ) {
+						auto&  parseInfo = parseInfos[i];
+						if( parseInfo.parser->cardinality() == 0 || parseInfo.count < parseInfo.parser->cardinality() ) {
+							result = parseInfo.parser->parse(exeName, result.value().remainingTokens());
+							if (!result)
+								return result;
+							if (result.value().type() != ParseResultType::NoMatch) {
+								tokenParsed = true;
+								++parseInfo.count;
+								break;
+							}
+						}
+					}
+
+					if( result.value().type() == ParseResultType::ShortCircuitAll )
+						return result;
+					if( !tokenParsed )
+						return InternalParseResult::runtimeError( "Unrecognised token: " + result.value().remainingTokens()->token );
+				}
+				// !TBD Check missing required options
+				return result;
+			}
+		};
+
+		template<typename DerivedT>
+		template<typename T>
+		auto ComposableParserImpl<DerivedT>::operator|( T const &other ) const -> Parser {
+			return Parser() | static_cast<DerivedT const &>( *this ) | other;
+		}
+	} // namespace detail
+
+	  // A Combined parser
+	using detail::Parser;
+
+	// A parser for options
+	using detail::Opt;
+
+	// A parser for arguments
+	using detail::Arg;
+
+	// Wrapper for argc, argv from main()
+	using detail::Args;
+
+	// Specifies the name of the executable
+	using detail::ExeName;
+
+	// Convenience wrapper for option parser that specifies the help option
+	using detail::Help;
+
+	// enum of result types from a parse
+	using detail::ParseResultType;
+
+	// Result type for parser operation
+	using detail::ParserResult;
 
-        void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
-        void benchmarkEnded( BenchmarkStats const& benchmarkStats ) override;
+}} // namespace Catch::clara
 
-        void testRunStarting( TestRunInfo const& testRunInfo ) override;
-        void testGroupStarting( GroupInfo const& groupInfo ) override;
-        void testCaseStarting( TestCaseInfo const& testInfo ) override;
-        void sectionStarting( SectionInfo const& sectionInfo ) override;
-        void assertionStarting( AssertionInfo const& assertionInfo ) override;
+   // end clara.hpp
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
 
-        // The return value indicates if the messages buffer should be cleared:
-        bool assertionEnded( AssertionStats const& assertionStats ) override;
-        void sectionEnded( SectionStats const& sectionStats ) override;
-        void testCaseEnded( TestCaseStats const& testCaseStats ) override;
-        void testGroupEnded( TestGroupStats const& testGroupStats ) override;
-        void testRunEnded( TestRunStats const& testRunStats ) override;
+   // Restore Clara's value for console width, if present
+#ifdef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#undef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#endif
 
-        void skipTest( TestCaseInfo const& testInfo ) override;
-        bool isMulti() const override;
+   // end catch_clara.h
+namespace Catch {
 
-    };
+	clara::Parser makeCommandLineParser( ConfigData& config );
 
 } // end namespace Catch
 
-// end catch_reporter_multi.h
-namespace Catch {
-
-    ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig )
-    :   m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {}
-
-    ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream )
-    :   m_stream( &_stream ), m_fullConfig( _fullConfig ) {}
-
-    std::ostream& ReporterConfig::stream() const { return *m_stream; }
-    IConfigPtr ReporterConfig::fullConfig() const { return m_fullConfig; }
-
-    TestRunInfo::TestRunInfo( std::string const& _name ) : name( _name ) {}
-
-    GroupInfo::GroupInfo(  std::string const& _name,
-                           std::size_t _groupIndex,
-                           std::size_t _groupsCount )
-    :   name( _name ),
-        groupIndex( _groupIndex ),
-        groupsCounts( _groupsCount )
-    {}
-
-     AssertionStats::AssertionStats( AssertionResult const& _assertionResult,
-                                     std::vector<MessageInfo> const& _infoMessages,
-                                     Totals const& _totals )
-    :   assertionResult( _assertionResult ),
-        infoMessages( _infoMessages ),
-        totals( _totals )
-    {
-        assertionResult.m_resultData.lazyExpression.m_transientExpression = _assertionResult.m_resultData.lazyExpression.m_transientExpression;
-
-        if( assertionResult.hasMessage() ) {
-            // Copy message into messages list.
-            // !TBD This should have been done earlier, somewhere
-            MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
-            builder << assertionResult.getMessage();
-            builder.m_info.message = builder.m_stream.str();
-
-            infoMessages.push_back( builder.m_info );
-        }
-    }
-
-     AssertionStats::~AssertionStats() = default;
-
-    SectionStats::SectionStats(  SectionInfo const& _sectionInfo,
-                                 Counts const& _assertions,
-                                 double _durationInSeconds,
-                                 bool _missingAssertions )
-    :   sectionInfo( _sectionInfo ),
-        assertions( _assertions ),
-        durationInSeconds( _durationInSeconds ),
-        missingAssertions( _missingAssertions )
-    {}
-
-    SectionStats::~SectionStats() = default;
-
-    TestCaseStats::TestCaseStats(  TestCaseInfo const& _testInfo,
-                                   Totals const& _totals,
-                                   std::string const& _stdOut,
-                                   std::string const& _stdErr,
-                                   bool _aborting )
-    : testInfo( _testInfo ),
-        totals( _totals ),
-        stdOut( _stdOut ),
-        stdErr( _stdErr ),
-        aborting( _aborting )
-    {}
-
-    TestCaseStats::~TestCaseStats() = default;
-
-    TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo,
-                                    Totals const& _totals,
-                                    bool _aborting )
-    :   groupInfo( _groupInfo ),
-        totals( _totals ),
-        aborting( _aborting )
-    {}
-
-    TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo )
-    :   groupInfo( _groupInfo ),
-        aborting( false )
-    {}
-
-    TestGroupStats::~TestGroupStats() = default;
-
-    TestRunStats::TestRunStats(   TestRunInfo const& _runInfo,
-                    Totals const& _totals,
-                    bool _aborting )
-    :   runInfo( _runInfo ),
-        totals( _totals ),
-        aborting( _aborting )
-    {}
-
-    TestRunStats::~TestRunStats() = default;
-
-    void IStreamingReporter::fatalErrorEncountered( StringRef ) {}
-    bool IStreamingReporter::isMulti() const { return false; }
-
-    IReporterFactory::~IReporterFactory() = default;
-    IReporterRegistry::~IReporterRegistry() = default;
-
-    void addReporter( IStreamingReporterPtr& existingReporter, IStreamingReporterPtr&& additionalReporter ) {
-
-        if( !existingReporter ) {
-            existingReporter = std::move( additionalReporter );
-            return;
-        }
-
-        MultipleReporters* multi = nullptr;
-
-        if( existingReporter->isMulti() ) {
-            multi = static_cast<MultipleReporters*>( existingReporter.get() );
-        }
-        else {
-            auto newMulti = std::unique_ptr<MultipleReporters>( new MultipleReporters );
-            newMulti->add( std::move( existingReporter ) );
-            multi = newMulti.get();
-            existingReporter = std::move( newMulti );
-        }
-        multi->add( std::move( additionalReporter ) );
-    }
-
-} // end namespace Catch
-// end catch_interfaces_reporter.cpp
-// start catch_interfaces_runner.cpp
+  // end catch_commandline.h
+#include <fstream>
+#include <ctime>
 
 namespace Catch {
-    IRunner::~IRunner() = default;
-}
-// end catch_interfaces_runner.cpp
-// start catch_interfaces_testcase.cpp
 
-namespace Catch {
-    ITestInvoker::~ITestInvoker() = default;
-    ITestCaseRegistry::~ITestCaseRegistry() = default;
-}
-// end catch_interfaces_testcase.cpp
-// start catch_leak_detector.cpp
+	clara::Parser makeCommandLineParser( ConfigData& config ) {
+
+		using namespace clara;
+
+		auto const setWarning = [&]( std::string const& warning ) {
+			auto warningSet = [&]() {
+				if( warning == "NoAssertions" )
+					return WarnAbout::NoAssertions;
+
+				if ( warning == "NoTests" )
+					return WarnAbout::NoTests;
+
+				return WarnAbout::Nothing;
+			}();
+
+			if (warningSet == WarnAbout::Nothing)
+				return ParserResult::runtimeError( "Unrecognised warning: '" + warning + "'" );
+			config.warnings = static_cast<WarnAbout::What>( config.warnings | warningSet );
+			return ParserResult::ok( ParseResultType::Matched );
+		};
+		auto const loadTestNamesFromFile = [&]( std::string const& filename ) {
+			std::ifstream f( filename.c_str() );
+			if( !f.is_open() )
+				return ParserResult::runtimeError( "Unable to load input file: '" + filename + "'" );
+
+			std::string line;
+			while( std::getline( f, line ) ) {
+				line = trim(line);
+				if( !line.empty() && !startsWith( line, '#' ) ) {
+					if( !startsWith( line, '"' ) )
+						line = '"' + line + '"';
+					config.testsOrTags.push_back( line + ',' );
+				}
+			}
+			return ParserResult::ok( ParseResultType::Matched );
+		};
+		auto const setTestOrder = [&]( std::string const& order ) {
+			if( startsWith( "declared", order ) )
+				config.runOrder = RunTests::InDeclarationOrder;
+			else if( startsWith( "lexical", order ) )
+				config.runOrder = RunTests::InLexicographicalOrder;
+			else if( startsWith( "random", order ) )
+				config.runOrder = RunTests::InRandomOrder;
+			else
+				return clara::ParserResult::runtimeError( "Unrecognised ordering: '" + order + "'" );
+			return ParserResult::ok( ParseResultType::Matched );
+		};
+		auto const setRngSeed = [&]( std::string const& seed ) {
+			if( seed != "time" )
+				return clara::detail::convertInto( seed, config.rngSeed );
+			config.rngSeed = static_cast<unsigned int>( std::time(nullptr) );
+			return ParserResult::ok( ParseResultType::Matched );
+		};
+		auto const setColourUsage = [&]( std::string const& useColour ) {
+			auto mode = toLower( useColour );
+
+			if( mode == "yes" )
+				config.useColour = UseColour::Yes;
+			else if( mode == "no" )
+				config.useColour = UseColour::No;
+			else if( mode == "auto" )
+				config.useColour = UseColour::Auto;
+			else
+				return ParserResult::runtimeError( "colour mode must be one of: auto, yes or no. '" + useColour + "' not recognised" );
+			return ParserResult::ok( ParseResultType::Matched );
+		};
+		auto const setWaitForKeypress = [&]( std::string const& keypress ) {
+			auto keypressLc = toLower( keypress );
+			if( keypressLc == "start" )
+				config.waitForKeypress = WaitForKeypress::BeforeStart;
+			else if( keypressLc == "exit" )
+				config.waitForKeypress = WaitForKeypress::BeforeExit;
+			else if( keypressLc == "both" )
+				config.waitForKeypress = WaitForKeypress::BeforeStartAndExit;
+			else
+				return ParserResult::runtimeError( "keypress argument must be one of: start, exit or both. '" + keypress + "' not recognised" );
+			return ParserResult::ok( ParseResultType::Matched );
+		};
+		auto const setVerbosity = [&]( std::string const& verbosity ) {
+			auto lcVerbosity = toLower( verbosity );
+			if( lcVerbosity == "quiet" )
+				config.verbosity = Verbosity::Quiet;
+			else if( lcVerbosity == "normal" )
+				config.verbosity = Verbosity::Normal;
+			else if( lcVerbosity == "high" )
+				config.verbosity = Verbosity::High;
+			else
+				return ParserResult::runtimeError( "Unrecognised verbosity, '" + verbosity + "'" );
+			return ParserResult::ok( ParseResultType::Matched );
+		};
+		auto const setReporter = [&]( std::string const& reporter ) {
+			IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
+
+			auto lcReporter = toLower( reporter );
+			auto result = factories.find( lcReporter );
+
+			if( factories.end() != result )
+				config.reporterName = lcReporter;
+			else
+				return ParserResult::runtimeError( "Unrecognized reporter, '" + reporter + "'. Check available with --list-reporters" );
+			return ParserResult::ok( ParseResultType::Matched );
+		};
+
+		auto cli
+			= ExeName( config.processName )
+			| Help( config.showHelp )
+			| Opt( config.listTests )
+			["-l"]["--list-tests"]
+			( "list all/matching test cases" )
+			| Opt( config.listTags )
+			["-t"]["--list-tags"]
+			( "list all/matching tags" )
+			| Opt( config.showSuccessfulTests )
+			["-s"]["--success"]
+			( "include successful tests in output" )
+			| Opt( config.shouldDebugBreak )
+			["-b"]["--break"]
+			( "break into debugger on failure" )
+			| Opt( config.noThrow )
+			["-e"]["--nothrow"]
+			( "skip exception tests" )
+			| Opt( config.showInvisibles )
+			["-i"]["--invisibles"]
+			( "show invisibles (tabs, newlines)" )
+			| Opt( config.outputFilename, "filename" )
+			["-o"]["--out"]
+			( "output filename" )
+			| Opt( setReporter, "name" )
+			["-r"]["--reporter"]
+			( "reporter to use (defaults to console)" )
+			| Opt( config.name, "name" )
+			["-n"]["--name"]
+			( "suite name" )
+			| Opt( [&]( bool ){ config.abortAfter = 1; } )
+			["-a"]["--abort"]
+			( "abort at first failure" )
+			| Opt( [&]( int x ){ config.abortAfter = x; }, "no. failures" )
+			["-x"]["--abortx"]
+			( "abort after x failures" )
+			| Opt( setWarning, "warning name" )
+			["-w"]["--warn"]
+			( "enable warnings" )
+			| Opt( [&]( bool flag ) { config.showDurations = flag ? ShowDurations::Always : ShowDurations::Never; }, "yes|no" )
+			["-d"]["--durations"]
+			( "show test durations" )
+			| Opt( loadTestNamesFromFile, "filename" )
+			["-f"]["--input-file"]
+			( "load test names to run from a file" )
+			| Opt( config.filenamesAsTags )
+			["-#"]["--filenames-as-tags"]
+			( "adds a tag for the filename" )
+			| Opt( config.sectionsToRun, "section name" )
+			["-c"]["--section"]
+			( "specify section to run" )
+			| Opt( setVerbosity, "quiet|normal|high" )
+			["-v"]["--verbosity"]
+			( "set output verbosity" )
+			| Opt( config.listTestNamesOnly )
+			["--list-test-names-only"]
+		( "list all/matching test cases names only" )
+			| Opt( config.listReporters )
+			["--list-reporters"]
+		( "list all reporters" )
+			| Opt( setTestOrder, "decl|lex|rand" )
+			["--order"]
+		( "test case order (defaults to decl)" )
+			| Opt( setRngSeed, "'time'|number" )
+			["--rng-seed"]
+		( "set a specific seed for random numbers" )
+			| Opt( setColourUsage, "yes|no" )
+			["--use-colour"]
+		( "should output be colourised" )
+			| Opt( config.libIdentify )
+			["--libidentify"]
+		( "report name and version according to libidentify standard" )
+			| Opt( setWaitForKeypress, "start|exit|both" )
+			["--wait-for-keypress"]
+		( "waits for a keypress before exiting" )
+			| Opt( config.benchmarkResolutionMultiple, "multiplier" )
+			["--benchmark-resolution-multiple"]
+		( "multiple of clock resolution to run benchmarks" )
+
+			| Arg( config.testsOrTags, "test name|pattern|tags" )
+			( "which test or tests to use" );
+
+		return cli;
+	}
 
-namespace Catch {
+} // end namespace Catch
+  // end catch_commandline.cpp
+  // start catch_common.cpp
 
-#ifdef CATCH_CONFIG_WINDOWS_CRTDBG
-#include <crtdbg.h>
+#include <cstring>
+#include <ostream>
 
-	LeakDetector::LeakDetector() {
-		int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
-		flag |= _CRTDBG_LEAK_CHECK_DF;
-		flag |= _CRTDBG_ALLOC_MEM_DF;
-		_CrtSetDbgFlag(flag);
-		_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
-		_CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
-		// Change this to leaking allocation's number to break there
-		_CrtSetBreakAlloc(-1);
+namespace Catch {
+
+	bool SourceLineInfo::empty() const noexcept {
+		return file[0] == '\0';
+	}
+	bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const noexcept {
+		return line == other.line && (file == other.file || std::strcmp(file, other.file) == 0);
+	}
+	bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const noexcept {
+		// We can assume that the same file will usually have the same pointer.
+		// Thus, if the pointers are the same, there is no point in calling the strcmp
+		return line < other.line || ( line == other.line && file != other.file && (std::strcmp(file, other.file) < 0));
 	}
 
+	std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
+#ifndef __GNUG__
+		os << info.file << '(' << info.line << ')';
 #else
-
-    LeakDetector::LeakDetector(){}
-
+		os << info.file << ':' << info.line;
 #endif
+		return os;
+	}
 
-}
-// end catch_leak_detector.cpp
-// start catch_list.cpp
+	std::string StreamEndStop::operator+() const {
+		return std::string();
+	}
 
-// start catch_list.h
+	NonCopyable::NonCopyable() = default;
+	NonCopyable::~NonCopyable() = default;
 
-#include <set>
+}
+// end catch_common.cpp
+// start catch_config.cpp
 
 namespace Catch {
 
-    std::size_t listTests( Config const& config );
-
-    std::size_t listTestsNamesOnly( Config const& config );
+	Config::Config( ConfigData const& data )
+		:   m_data( data ),
+		m_stream( openStream() )
+	{
+		TestSpecParser parser(ITagAliasRegistry::get());
+		if (data.testsOrTags.empty()) {
+			parser.parse("~[.]"); // All not hidden tests
+		}
+		else {
+			m_hasTestFilters = true;
+			for( auto const& testOrTags : data.testsOrTags )
+				parser.parse( testOrTags );
+		}
+		m_testSpec = parser.testSpec();
+	}
 
-    struct TagInfo {
-        void add( std::string const& spelling );
-        std::string all() const;
+	std::string const& Config::getFilename() const {
+		return m_data.outputFilename ;
+	}
 
-        std::set<std::string> spellings;
-        std::size_t count = 0;
-    };
+	bool Config::listTests() const          { return m_data.listTests; }
+	bool Config::listTestNamesOnly() const  { return m_data.listTestNamesOnly; }
+	bool Config::listTags() const           { return m_data.listTags; }
+	bool Config::listReporters() const      { return m_data.listReporters; }
+
+	std::string Config::getProcessName() const { return m_data.processName; }
+	std::string const& Config::getReporterName() const { return m_data.reporterName; }
+
+	std::vector<std::string> const& Config::getTestsOrTags() const { return m_data.testsOrTags; }
+	std::vector<std::string> const& Config::getSectionsToRun() const { return m_data.sectionsToRun; }
+
+	TestSpec const& Config::testSpec() const { return m_testSpec; }
+	bool Config::hasTestFilters() const { return m_hasTestFilters; }
+
+	bool Config::showHelp() const { return m_data.showHelp; }
+
+	// IConfig interface
+	bool Config::allowThrows() const                   { return !m_data.noThrow; }
+	std::ostream& Config::stream() const               { return m_stream->stream(); }
+	std::string Config::name() const                   { return m_data.name.empty() ? m_data.processName : m_data.name; }
+	bool Config::includeSuccessfulResults() const      { return m_data.showSuccessfulTests; }
+	bool Config::warnAboutMissingAssertions() const    { return !!(m_data.warnings & WarnAbout::NoAssertions); }
+	bool Config::warnAboutNoTests() const              { return !!(m_data.warnings & WarnAbout::NoTests); }
+	ShowDurations::OrNot Config::showDurations() const { return m_data.showDurations; }
+	RunTests::InWhatOrder Config::runOrder() const     { return m_data.runOrder; }
+	unsigned int Config::rngSeed() const               { return m_data.rngSeed; }
+	int Config::benchmarkResolutionMultiple() const    { return m_data.benchmarkResolutionMultiple; }
+	UseColour::YesOrNo Config::useColour() const       { return m_data.useColour; }
+	bool Config::shouldDebugBreak() const              { return m_data.shouldDebugBreak; }
+	int Config::abortAfter() const                     { return m_data.abortAfter; }
+	bool Config::showInvisibles() const                { return m_data.showInvisibles; }
+	Verbosity Config::verbosity() const                { return m_data.verbosity; }
+
+	IStream const* Config::openStream() {
+		return Catch::makeStream(m_data.outputFilename);
+	}
 
-    std::size_t listTags( Config const& config );
+} // end namespace Catch
+  // end catch_config.cpp
+  // start catch_console_colour.cpp
 
-    std::size_t listReporters( Config const& /*config*/ );
+#if defined(__clang__)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wexit-time-destructors"
+#endif
 
-    Option<std::size_t> list( Config const& config );
+  // start catch_errno_guard.h
 
-} // end namespace Catch
+namespace Catch {
 
-// end catch_list.h
-// start catch_text.h
+	class ErrnoGuard {
+	public:
+		ErrnoGuard();
+		~ErrnoGuard();
+	private:
+		int m_oldErrno;
+	};
 
-namespace Catch {
-    using namespace clara::TextFlow;
 }
 
-// end catch_text.h
-#include <limits>
-#include <algorithm>
-#include <iomanip>
+// end catch_errno_guard.h
+#include <sstream>
 
 namespace Catch {
+	namespace {
 
-    std::size_t listTests( Config const& config ) {
-        TestSpec testSpec = config.testSpec();
-        if( config.testSpec().hasFilters() )
-            Catch::cout() << "Matching test cases:\n";
-        else {
-            Catch::cout() << "All available test cases:\n";
-            testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
-        }
-
-        auto matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
-        for( auto const& testCaseInfo : matchedTestCases ) {
-            Colour::Code colour = testCaseInfo.isHidden()
-                ? Colour::SecondaryText
-                : Colour::None;
-            Colour colourGuard( colour );
-
-            Catch::cout() << Column( testCaseInfo.name ).initialIndent( 2 ).indent( 4 ) << "\n";
-            if( config.verbosity() >= Verbosity::High ) {
-                Catch::cout() << Column( Catch::Detail::stringify( testCaseInfo.lineInfo ) ).indent(4) << std::endl;
-                std::string description = testCaseInfo.description;
-                if( description.empty() )
-                    description = "(NO DESCRIPTION)";
-                Catch::cout() << Column( description ).indent(4) << std::endl;
-            }
-            if( !testCaseInfo.tags.empty() )
-                Catch::cout() << Column( testCaseInfo.tagsAsString() ).indent( 6 ) << "\n";
-        }
-
-        if( !config.testSpec().hasFilters() )
-            Catch::cout() << pluralise( matchedTestCases.size(), "test case" ) << '\n' << std::endl;
-        else
-            Catch::cout() << pluralise( matchedTestCases.size(), "matching test case" ) << '\n' << std::endl;
-        return matchedTestCases.size();
-    }
-
-    std::size_t listTestsNamesOnly( Config const& config ) {
-        TestSpec testSpec = config.testSpec();
-        if( !config.testSpec().hasFilters() )
-            testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
-        std::size_t matchedTests = 0;
-        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
-        for( auto const& testCaseInfo : matchedTestCases ) {
-            matchedTests++;
-            if( startsWith( testCaseInfo.name, '#' ) )
-               Catch::cout() << '"' << testCaseInfo.name << '"';
-            else
-               Catch::cout() << testCaseInfo.name;
-            if ( config.verbosity() >= Verbosity::High )
-                Catch::cout() << "\t@" << testCaseInfo.lineInfo;
-            Catch::cout() << std::endl;
-        }
-        return matchedTests;
-    }
-
-    void TagInfo::add( std::string const& spelling ) {
-        ++count;
-        spellings.insert( spelling );
-    }
-
-    std::string TagInfo::all() const {
-        std::string out;
-        for( auto const& spelling : spellings )
-            out += "[" + spelling + "]";
-        return out;
-    }
-
-    std::size_t listTags( Config const& config ) {
-        TestSpec testSpec = config.testSpec();
-        if( config.testSpec().hasFilters() )
-            Catch::cout() << "Tags for matching test cases:\n";
-        else {
-            Catch::cout() << "All available tags:\n";
-            testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
-        }
-
-        std::map<std::string, TagInfo> tagCounts;
-
-        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
-        for( auto const& testCase : matchedTestCases ) {
-            for( auto const& tagName : testCase.getTestCaseInfo().tags ) {
-                std::string lcaseTagName = toLower( tagName );
-                auto countIt = tagCounts.find( lcaseTagName );
-                if( countIt == tagCounts.end() )
-                    countIt = tagCounts.insert( std::make_pair( lcaseTagName, TagInfo() ) ).first;
-                countIt->second.add( tagName );
-            }
-        }
-
-        for( auto const& tagCount : tagCounts ) {
-            std::ostringstream oss;
-            oss << "  " << std::setw(2) << tagCount.second.count << "  ";
-            auto wrapper = Column( tagCount.second.all() )
-                                                    .initialIndent( 0 )
-                                                    .indent( oss.str().size() )
-                                                    .width( CATCH_CONFIG_CONSOLE_WIDTH-10 );
-            Catch::cout() << oss.str() << wrapper << '\n';
-        }
-        Catch::cout() << pluralise( tagCounts.size(), "tag" ) << '\n' << std::endl;
-        return tagCounts.size();
-    }
-
-    std::size_t listReporters( Config const& /*config*/ ) {
-        Catch::cout() << "Available reporters:\n";
-        IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
-        std::size_t maxNameLen = 0;
-        for( auto const& factoryKvp : factories )
-            maxNameLen = (std::max)( maxNameLen, factoryKvp.first.size() );
-
-        for( auto const& factoryKvp : factories ) {
-            Catch::cout()
-                    << Column( factoryKvp.first + ":" )
-                            .indent(2)
-                            .width( 5+maxNameLen )
-                    +  Column( factoryKvp.second->getDescription() )
-                            .initialIndent(0)
-                            .indent(2)
-                            .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen-8 )
-                    << "\n";
-        }
-        Catch::cout() << std::endl;
-        return factories.size();
-    }
-
-    Option<std::size_t> list( Config const& config ) {
-        Option<std::size_t> listedCount;
-        if( config.listTests() )
-            listedCount = listedCount.valueOr(0) + listTests( config );
-        if( config.listTestNamesOnly() )
-            listedCount = listedCount.valueOr(0) + listTestsNamesOnly( config );
-        if( config.listTags() )
-            listedCount = listedCount.valueOr(0) + listTags( config );
-        if( config.listReporters() )
-            listedCount = listedCount.valueOr(0) + listReporters( config );
-        return listedCount;
-    }
+		struct IColourImpl {
+			virtual ~IColourImpl() = default;
+			virtual void use( Colour::Code _colourCode ) = 0;
+		};
 
-} // end namespace Catch
-// end catch_list.cpp
-// start catch_matchers.cpp
+		struct NoColourImpl : IColourImpl {
+			void use( Colour::Code ) {}
 
-namespace Catch {
-namespace Matchers {
-    namespace Impl {
+			static IColourImpl* instance() {
+				static NoColourImpl s_instance;
+				return &s_instance;
+			}
+		};
 
-        std::string MatcherUntypedBase::toString() const {
-            if( m_cachedToString.empty() )
-                m_cachedToString = describe();
-            return m_cachedToString;
-        }
+	} // anon namespace
+} // namespace Catch
 
-        MatcherUntypedBase::~MatcherUntypedBase() = default;
+#if !defined( CATCH_CONFIG_COLOUR_NONE ) && !defined( CATCH_CONFIG_COLOUR_WINDOWS ) && !defined( CATCH_CONFIG_COLOUR_ANSI )
+#   ifdef CATCH_PLATFORM_WINDOWS
+#       define CATCH_CONFIG_COLOUR_WINDOWS
+#   else
+#       define CATCH_CONFIG_COLOUR_ANSI
+#   endif
+#endif
 
-    } // namespace Impl
-} // namespace Matchers
+#if defined ( CATCH_CONFIG_COLOUR_WINDOWS ) /////////////////////////////////////////
 
-using namespace Matchers;
-using Matchers::Impl::MatcherBase;
+namespace Catch {
+	namespace {
+
+		class Win32ColourImpl : public IColourImpl {
+		public:
+			Win32ColourImpl() : stdoutHandle( GetStdHandle(STD_OUTPUT_HANDLE) )
+			{
+				CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
+				GetConsoleScreenBufferInfo( stdoutHandle, &csbiInfo );
+				originalForegroundAttributes = csbiInfo.wAttributes & ~( BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_INTENSITY );
+				originalBackgroundAttributes = csbiInfo.wAttributes & ~( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY );
+			}
+
+			virtual void use( Colour::Code _colourCode ) override {
+				switch( _colourCode ) {
+				case Colour::None:      return setTextAttribute( originalForegroundAttributes );
+				case Colour::White:     return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
+				case Colour::Red:       return setTextAttribute( FOREGROUND_RED );
+				case Colour::Green:     return setTextAttribute( FOREGROUND_GREEN );
+				case Colour::Blue:      return setTextAttribute( FOREGROUND_BLUE );
+				case Colour::Cyan:      return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN );
+				case Colour::Yellow:    return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN );
+				case Colour::Grey:      return setTextAttribute( 0 );
+
+				case Colour::LightGrey:     return setTextAttribute( FOREGROUND_INTENSITY );
+				case Colour::BrightRed:     return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED );
+				case Colour::BrightGreen:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN );
+				case Colour::BrightWhite:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
+				case Colour::BrightYellow:  return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN );
+
+				case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
+
+				default:
+					CATCH_ERROR( "Unknown colour requested" );
+				}
+			}
+
+		private:
+			void setTextAttribute( WORD _textAttribute ) {
+				SetConsoleTextAttribute( stdoutHandle, _textAttribute | originalBackgroundAttributes );
+			}
+			HANDLE stdoutHandle;
+			WORD originalForegroundAttributes;
+			WORD originalBackgroundAttributes;
+		};
+
+		IColourImpl* platformColourInstance() {
+			static Win32ColourImpl s_instance;
+
+			IConfigPtr config = getCurrentContext().getConfig();
+			UseColour::YesOrNo colourMode = config
+				? config->useColour()
+				: UseColour::Auto;
+			if( colourMode == UseColour::Auto )
+				colourMode = UseColour::Yes;
+			return colourMode == UseColour::Yes
+				? &s_instance
+				: NoColourImpl::instance();
+		}
+
+	} // end anon namespace
+} // end namespace Catch
 
-} // namespace Catch
-// end catch_matchers.cpp
-// start catch_matchers_string.cpp
+#elif defined( CATCH_CONFIG_COLOUR_ANSI ) //////////////////////////////////////
 
-namespace Catch {
-namespace Matchers {
-
-    namespace StdString {
-
-        CasedString::CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity )
-        :   m_caseSensitivity( caseSensitivity ),
-            m_str( adjustString( str ) )
-        {}
-        std::string CasedString::adjustString( std::string const& str ) const {
-            return m_caseSensitivity == CaseSensitive::No
-                   ? toLower( str )
-                   : str;
-        }
-        std::string CasedString::caseSensitivitySuffix() const {
-            return m_caseSensitivity == CaseSensitive::No
-                   ? " (case insensitive)"
-                   : std::string();
-        }
-
-        StringMatcherBase::StringMatcherBase( std::string const& operation, CasedString const& comparator )
-        : m_comparator( comparator ),
-          m_operation( operation ) {
-        }
-
-        std::string StringMatcherBase::describe() const {
-            std::string description;
-            description.reserve(5 + m_operation.size() + m_comparator.m_str.size() +
-                                        m_comparator.caseSensitivitySuffix().size());
-            description += m_operation;
-            description += ": \"";
-            description += m_comparator.m_str;
-            description += "\"";
-            description += m_comparator.caseSensitivitySuffix();
-            return description;
-        }
-
-        EqualsMatcher::EqualsMatcher( CasedString const& comparator ) : StringMatcherBase( "equals", comparator ) {}
-
-        bool EqualsMatcher::match( std::string const& source ) const {
-            return m_comparator.adjustString( source ) == m_comparator.m_str;
-        }
-
-        ContainsMatcher::ContainsMatcher( CasedString const& comparator ) : StringMatcherBase( "contains", comparator ) {}
-
-        bool ContainsMatcher::match( std::string const& source ) const {
-            return contains( m_comparator.adjustString( source ), m_comparator.m_str );
-        }
-
-        StartsWithMatcher::StartsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "starts with", comparator ) {}
-
-        bool StartsWithMatcher::match( std::string const& source ) const {
-            return startsWith( m_comparator.adjustString( source ), m_comparator.m_str );
-        }
-
-        EndsWithMatcher::EndsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "ends with", comparator ) {}
-
-        bool EndsWithMatcher::match( std::string const& source ) const {
-            return endsWith( m_comparator.adjustString( source ), m_comparator.m_str );
-        }
-
-    } // namespace StdString
-
-    StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
-        return StdString::EqualsMatcher( StdString::CasedString( str, caseSensitivity) );
-    }
-    StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
-        return StdString::ContainsMatcher( StdString::CasedString( str, caseSensitivity) );
-    }
-    StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
-        return StdString::EndsWithMatcher( StdString::CasedString( str, caseSensitivity) );
-    }
-    StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
-        return StdString::StartsWithMatcher( StdString::CasedString( str, caseSensitivity) );
-    }
-
-} // namespace Matchers
-} // namespace Catch
-// end catch_matchers_string.cpp
-// start catch_message.cpp
+#include <unistd.h>
 
 namespace Catch {
+	namespace {
+
+		// use POSIX/ ANSI console terminal codes
+		// Thanks to Adam Strzelecki for original contribution
+		// (http://github.com/nanoant)
+		// https://github.com/philsquared/Catch/pull/131
+		class PosixColourImpl : public IColourImpl {
+		public:
+			virtual void use( Colour::Code _colourCode ) override {
+				switch( _colourCode ) {
+				case Colour::None:
+				case Colour::White:     return setColour( "[0m" );
+				case Colour::Red:       return setColour( "[0;31m" );
+				case Colour::Green:     return setColour( "[0;32m" );
+				case Colour::Blue:      return setColour( "[0;34m" );
+				case Colour::Cyan:      return setColour( "[0;36m" );
+				case Colour::Yellow:    return setColour( "[0;33m" );
+				case Colour::Grey:      return setColour( "[1;30m" );
+
+				case Colour::LightGrey:     return setColour( "[0;37m" );
+				case Colour::BrightRed:     return setColour( "[1;31m" );
+				case Colour::BrightGreen:   return setColour( "[1;32m" );
+				case Colour::BrightWhite:   return setColour( "[1;37m" );
+				case Colour::BrightYellow:  return setColour( "[1;33m" );
+
+				case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
+				default: CATCH_INTERNAL_ERROR( "Unknown colour requested" );
+				}
+			}
+			static IColourImpl* instance() {
+				static PosixColourImpl s_instance;
+				return &s_instance;
+			}
+
+		private:
+			void setColour( const char* _escapeCode ) {
+				Catch::cout() << '\033' << _escapeCode;
+			}
+		};
+
+		bool useColourOnPlatform() {
+			return
+#ifdef CATCH_PLATFORM_MAC
+				!isDebuggerActive() &&
+#endif
+#if !(defined(__DJGPP__) && defined(__STRICT_ANSI__))
+				isatty(STDOUT_FILENO)
+#else
+				false
+#endif
+				;
+		}
+		IColourImpl* platformColourInstance() {
+			ErrnoGuard guard;
+			IConfigPtr config = getCurrentContext().getConfig();
+			UseColour::YesOrNo colourMode = config
+				? config->useColour()
+				: UseColour::Auto;
+			if( colourMode == UseColour::Auto )
+				colourMode = useColourOnPlatform()
+				? UseColour::Yes
+				: UseColour::No;
+			return colourMode == UseColour::Yes
+				? PosixColourImpl::instance()
+				: NoColourImpl::instance();
+		}
+
+	} // end anon namespace
+} // end namespace Catch
+
+#else  // not Windows or ANSI ///////////////////////////////////////////////
 
-    MessageInfo::MessageInfo(   std::string const& _macroName,
-                                SourceLineInfo const& _lineInfo,
-                                ResultWas::OfType _type )
-    :   macroName( _macroName ),
-        lineInfo( _lineInfo ),
-        type( _type ),
-        sequence( ++globalCount )
-    {}
+namespace Catch {
 
-    bool MessageInfo::operator==( MessageInfo const& other ) const {
-        return sequence == other.sequence;
-    }
+	static IColourImpl* platformColourInstance() { return NoColourImpl::instance(); }
 
-    bool MessageInfo::operator<( MessageInfo const& other ) const {
-        return sequence < other.sequence;
-    }
+} // end namespace Catch
 
-    // This may need protecting if threading support is added
-    unsigned int MessageInfo::globalCount = 0;
+#endif // Windows/ ANSI/ None
 
-    ////////////////////////////////////////////////////////////////////////////
+namespace Catch {
 
-    Catch::MessageBuilder::MessageBuilder( std::string const& macroName,
-                                           SourceLineInfo const& lineInfo,
-                                           ResultWas::OfType type )
-        :m_info(macroName, lineInfo, type) {}
+	Colour::Colour( Code _colourCode ) { use( _colourCode ); }
+	Colour::Colour( Colour&& rhs ) noexcept {
+		m_moved = rhs.m_moved;
+		rhs.m_moved = true;
+	}
+	Colour& Colour::operator=( Colour&& rhs ) noexcept {
+		m_moved = rhs.m_moved;
+		rhs.m_moved  = true;
+		return *this;
+	}
 
-    ////////////////////////////////////////////////////////////////////////////
+	Colour::~Colour(){ if( !m_moved ) use( None ); }
 
-    ScopedMessage::ScopedMessage( MessageBuilder const& builder )
-    : m_info( builder.m_info )
-    {
-        m_info.message = builder.m_stream.str();
-        getResultCapture().pushScopedMessage( m_info );
-    }
+	void Colour::use( Code _colourCode ) {
+		static IColourImpl* impl = platformColourInstance();
+		impl->use( _colourCode );
+	}
 
-    ScopedMessage::~ScopedMessage() {
-        if ( !std::uncaught_exception() ){
-            getResultCapture().popScopedMessage(m_info);
-        }
-    }
+	std::ostream& operator << ( std::ostream& os, Colour const& ) {
+		return os;
+	}
 
 } // end namespace Catch
-// end catch_message.cpp
-// start catch_random_number_generator.cpp
 
-// start catch_random_number_generator.h
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#endif
 
-#include <algorithm>
+  // end catch_console_colour.cpp
+  // start catch_context.cpp
 
 namespace Catch {
 
-    struct IConfig;
+	class Context : public IMutableContext, NonCopyable {
 
-    void seedRng( IConfig const& config );
+	public: // IContext
+		virtual IResultCapture* getResultCapture() override {
+			return m_resultCapture;
+		}
+		virtual IRunner* getRunner() override {
+			return m_runner;
+		}
 
-    unsigned int rngSeed();
+		virtual IConfigPtr const& getConfig() const override {
+			return m_config;
+		}
 
-    struct RandomNumberGenerator {
-        using result_type = unsigned int;
+		virtual ~Context() override;
 
-        static constexpr result_type (min)() { return 0; }
-        static constexpr result_type (max)() { return 1000000; }
+	public: // IMutableContext
+		virtual void setResultCapture( IResultCapture* resultCapture ) override {
+			m_resultCapture = resultCapture;
+		}
+		virtual void setRunner( IRunner* runner ) override {
+			m_runner = runner;
+		}
+		virtual void setConfig( IConfigPtr const& config ) override {
+			m_config = config;
+		}
 
-        result_type operator()( result_type n ) const;
-        result_type operator()() const;
+		friend IMutableContext& getCurrentMutableContext();
 
-        template<typename V>
-        static void shuffle( V& vector ) {
-            RandomNumberGenerator rng;
-            std::shuffle( vector.begin(), vector.end(), rng );
-        }
-    };
+	private:
+		IConfigPtr m_config;
+		IRunner* m_runner = nullptr;
+		IResultCapture* m_resultCapture = nullptr;
+	};
 
-}
+	IMutableContext *IMutableContext::currentContext = nullptr;
 
-// end catch_random_number_generator.h
-#include <cstdlib>
+	void IMutableContext::createContext()
+	{
+		currentContext = new Context();
+	}
 
-namespace Catch {
+	void cleanUpContext() {
+		delete IMutableContext::currentContext;
+		IMutableContext::currentContext = nullptr;
+	}
+	IContext::~IContext() = default;
+	IMutableContext::~IMutableContext() = default;
+	Context::~Context() = default;
+}
+// end catch_context.cpp
+// start catch_debug_console.cpp
 
-    void seedRng( IConfig const& config ) {
-        if( config.rngSeed() != 0 )
-            std::srand( config.rngSeed() );
-    }
-    unsigned int rngSeed() {
-        return getCurrentContext().getConfig()->rngSeed();
-    }
+// start catch_debug_console.h
 
-    RandomNumberGenerator::result_type RandomNumberGenerator::operator()( result_type n ) const {
-        return std::rand() % n;
-    }
-    RandomNumberGenerator::result_type RandomNumberGenerator::operator()() const {
-        return std::rand() % (max)();
-    }
+#include <string>
 
+namespace Catch {
+	void writeToDebugConsole( std::string const& text );
 }
-// end catch_random_number_generator.cpp
-// start catch_registry_hub.cpp
-
-// start catch_test_case_registry_impl.h
 
-#include <vector>
-#include <set>
-#include <algorithm>
-#include <ios>
+// end catch_debug_console.h
+#ifdef CATCH_PLATFORM_WINDOWS
 
 namespace Catch {
+	void writeToDebugConsole( std::string const& text ) {
+		::OutputDebugStringA( text.c_str() );
+	}
+}
 
-    class TestCase;
-    struct IConfig;
-
-    std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases );
-    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
+#else
 
-    void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions );
+namespace Catch {
+	void writeToDebugConsole( std::string const& text ) {
+		// !TBD: Need a version for Mac/ XCode and other IDEs
+		Catch::cout() << text;
+	}
+}
 
-    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
-    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
+#endif // Platform
+// end catch_debug_console.cpp
+// start catch_debugger.cpp
 
-    class TestRegistry : public ITestCaseRegistry {
-    public:
-        virtual ~TestRegistry() = default;
+#ifdef CATCH_PLATFORM_MAC
 
-        virtual void registerTest( TestCase const& testCase );
+#  include <assert.h>
+#  include <stdbool.h>
+#  include <sys/types.h>
+#  include <unistd.h>
+#  include <sys/sysctl.h>
+#  include <cstddef>
+#  include <ostream>
 
-        std::vector<TestCase> const& getAllTests() const override;
-        std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const override;
+namespace Catch {
 
-    private:
-        std::vector<TestCase> m_functions;
-        mutable RunTests::InWhatOrder m_currentSortOrder = RunTests::InDeclarationOrder;
-        mutable std::vector<TestCase> m_sortedFunctions;
-        std::size_t m_unnamedCount = 0;
-        std::ios_base::Init m_ostreamInit; // Forces cout/ cerr to be initialised
-    };
+	// The following function is taken directly from the following technical note:
+	// http://developer.apple.com/library/mac/#qa/qa2004/qa1361.html
 
-    ///////////////////////////////////////////////////////////////////////////
+	// Returns true if the current process is being debugged (either
+	// running under the debugger or has a debugger attached post facto).
+	bool isDebuggerActive(){
 
-    class TestInvokerAsFunction : public ITestInvoker {
-        void(*m_testAsFunction)();
-    public:
-        TestInvokerAsFunction( void(*testAsFunction)() ) noexcept;
+		int                 mib[4];
+		struct kinfo_proc   info;
+		std::size_t         size;
 
-        void invoke() const override;
-    };
+		// Initialize the flags so that, if sysctl fails for some bizarre
+		// reason, we get a predictable result.
 
-    std::string extractClassName( std::string const& classOrQualifiedMethodName );
+		info.kp_proc.p_flag = 0;
 
-    ///////////////////////////////////////////////////////////////////////////
+		// Initialize mib, which tells sysctl the info we want, in this case
+		// we're looking for information about a specific process ID.
 
-} // end namespace Catch
+		mib[0] = CTL_KERN;
+		mib[1] = KERN_PROC;
+		mib[2] = KERN_PROC_PID;
+		mib[3] = getpid();
 
-// end catch_test_case_registry_impl.h
-// start catch_reporter_registry.h
+		// Call sysctl.
 
-#include <map>
+		size = sizeof(info);
+		if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, nullptr, 0) != 0 ) {
+			Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n" << std::endl;
+			return false;
+		}
 
-namespace Catch {
+		// We're being debugged if the P_TRACED flag is set.
 
-    class ReporterRegistry : public IReporterRegistry {
-
-    public:
-
-        ~ReporterRegistry() override;
-
-        IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const override;
-
-        void registerReporter( std::string const& name, IReporterFactoryPtr const& factory );
-        void registerListener( IReporterFactoryPtr const& factory );
-
-        FactoryMap const& getFactories() const override;
-        Listeners const& getListeners() const override;
-
-    private:
-        FactoryMap m_factories;
-        Listeners m_listeners;
-    };
-}
-
-// end catch_reporter_registry.h
-// start catch_tag_alias_registry.h
-
-// start catch_tag_alias.h
+		return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
+	}
+} // namespace Catch
 
+#elif defined(CATCH_PLATFORM_LINUX)
+#include <fstream>
 #include <string>
 
+namespace Catch{
+	// The standard POSIX way of detecting a debugger is to attempt to
+	// ptrace() the process, but this needs to be done from a child and not
+	// this process itself to still allow attaching to this process later
+	// if wanted, so is rather heavy. Under Linux we have the PID of the
+	// "debugger" (which doesn't need to be gdb, of course, it could also
+	// be strace, for example) in /proc/$PID/status, so just get it from
+	// there instead.
+	bool isDebuggerActive(){
+		// Libstdc++ has a bug, where std::ifstream sets errno to 0
+		// This way our users can properly assert over errno values
+		ErrnoGuard guard;
+		std::ifstream in("/proc/self/status");
+		for( std::string line; std::getline(in, line); ) {
+			static const int PREFIX_LEN = 11;
+			if( line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0 ) {
+				// We're traced if the PID is not 0 and no other PID starts
+				// with 0 digit, so it's enough to check for just a single
+				// character.
+				return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0';
+			}
+		}
+
+		return false;
+	}
+} // namespace Catch
+#elif defined(_MSC_VER)
+extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
 namespace Catch {
+	bool isDebuggerActive() {
+		return IsDebuggerPresent() != 0;
+	}
+}
+#elif defined(__MINGW32__)
+extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
+namespace Catch {
+	bool isDebuggerActive() {
+		return IsDebuggerPresent() != 0;
+	}
+}
+#else
+namespace Catch {
+	bool isDebuggerActive() { return false; }
+}
+#endif // Platform
+// end catch_debugger.cpp
+// start catch_decomposer.cpp
 
-    struct TagAlias {
-        TagAlias(std::string const& _tag, SourceLineInfo _lineInfo);
-
-        std::string tag;
-        SourceLineInfo lineInfo;
-    };
+namespace Catch {
 
-} // end namespace Catch
+	ITransientExpression::~ITransientExpression() = default;
 
-// end catch_tag_alias.h
-#include <map>
+	void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs ) {
+		if( lhs.size() + rhs.size() < 40 &&
+			lhs.find('\n') == std::string::npos &&
+			rhs.find('\n') == std::string::npos )
+			os << lhs << " " << op << " " << rhs;
+		else
+			os << lhs << "\n" << op << "\n" << rhs;
+	}
+}
+// end catch_decomposer.cpp
+// start catch_enforce.cpp
 
 namespace Catch {
+#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS_CUSTOM_HANDLER)
+	[[noreturn]]
+	void throw_exception(std::exception const& e) {
+		Catch::cerr() << "Catch will terminate because it needed to throw an exception.\n"
+			<< "The message was: " << e.what() << '\n';
+		std::terminate();
+	}
+#endif
+} // namespace Catch;
+  // end catch_enforce.cpp
+  // start catch_errno_guard.cpp
 
-    class TagAliasRegistry : public ITagAliasRegistry {
-    public:
-        ~TagAliasRegistry() override;
-        TagAlias const* find( std::string const& alias ) const override;
-        std::string expandAliases( std::string const& unexpandedTestSpec ) const override;
-        void add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo );
-
-    private:
-        std::map<std::string, TagAlias> m_registry;
-    };
+#include <cerrno>
 
-} // end namespace Catch
+namespace Catch {
+	ErrnoGuard::ErrnoGuard():m_oldErrno(errno){}
+	ErrnoGuard::~ErrnoGuard() { errno = m_oldErrno; }
+}
+// end catch_errno_guard.cpp
+// start catch_exception_translator_registry.cpp
 
-// end catch_tag_alias_registry.h
-// start catch_startup_exception_registry.h
+// start catch_exception_translator_registry.h
 
 #include <vector>
-#include <exception>
+#include <string>
+#include <memory>
 
 namespace Catch {
 
-    class StartupExceptionRegistry {
-    public:
-        void add(std::exception_ptr const& exception) noexcept;
-        std::vector<std::exception_ptr> const& getExceptions() const noexcept;
-    private:
-        std::vector<std::exception_ptr> m_exceptions;
-    };
-
-} // end namespace Catch
+	class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry {
+	public:
+		~ExceptionTranslatorRegistry();
+		virtual void registerTranslator( const IExceptionTranslator* translator );
+		virtual std::string translateActiveException() const override;
+		std::string tryTranslators() const;
 
-// end catch_startup_exception_registry.h
-namespace Catch {
-
-    namespace {
-
-        class RegistryHub : public IRegistryHub, public IMutableRegistryHub,
-                            private NonCopyable {
-
-        public: // IRegistryHub
-            RegistryHub() = default;
-            IReporterRegistry const& getReporterRegistry() const override {
-                return m_reporterRegistry;
-            }
-            ITestCaseRegistry const& getTestCaseRegistry() const override {
-                return m_testCaseRegistry;
-            }
-            IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() override {
-                return m_exceptionTranslatorRegistry;
-            }
-            ITagAliasRegistry const& getTagAliasRegistry() const override {
-                return m_tagAliasRegistry;
-            }
-            StartupExceptionRegistry const& getStartupExceptionRegistry() const override {
-                return m_exceptionRegistry;
-            }
-
-        public: // IMutableRegistryHub
-            void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) override {
-                m_reporterRegistry.registerReporter( name, factory );
-            }
-            void registerListener( IReporterFactoryPtr const& factory ) override {
-                m_reporterRegistry.registerListener( factory );
-            }
-            void registerTest( TestCase const& testInfo ) override {
-                m_testCaseRegistry.registerTest( testInfo );
-            }
-            void registerTranslator( const IExceptionTranslator* translator ) override {
-                m_exceptionTranslatorRegistry.registerTranslator( translator );
-            }
-            void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) override {
-                m_tagAliasRegistry.add( alias, tag, lineInfo );
-            }
-            void registerStartupException() noexcept override {
-                m_exceptionRegistry.add(std::current_exception());
-            }
-
-        private:
-            TestRegistry m_testCaseRegistry;
-            ReporterRegistry m_reporterRegistry;
-            ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
-            TagAliasRegistry m_tagAliasRegistry;
-            StartupExceptionRegistry m_exceptionRegistry;
-        };
-
-        // Single, global, instance
-        RegistryHub*& getTheRegistryHub() {
-            static RegistryHub* theRegistryHub = nullptr;
-            if( !theRegistryHub )
-                theRegistryHub = new RegistryHub();
-            return theRegistryHub;
-        }
-    }
-
-    IRegistryHub& getRegistryHub() {
-        return *getTheRegistryHub();
-    }
-    IMutableRegistryHub& getMutableRegistryHub() {
-        return *getTheRegistryHub();
-    }
-    void cleanUp() {
-        delete getTheRegistryHub();
-        getTheRegistryHub() = nullptr;
-        cleanUpContext();
-    }
-    std::string translateActiveException() {
-        return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
-    }
+	private:
+		std::vector<std::unique_ptr<IExceptionTranslator const>> m_translators;
+	};
+}
 
-} // end namespace Catch
-// end catch_registry_hub.cpp
-// start catch_reporter_registry.cpp
+// end catch_exception_translator_registry.h
+#ifdef __OBJC__
+#import "Foundation/Foundation.h"
+#endif
 
 namespace Catch {
 
-    ReporterRegistry::~ReporterRegistry() = default;
+	ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry() {
+	}
 
-    IStreamingReporterPtr ReporterRegistry::create( std::string const& name, IConfigPtr const& config ) const {
-        auto it =  m_factories.find( name );
-        if( it == m_factories.end() )
-            return nullptr;
-        return it->second->create( ReporterConfig( config ) );
-    }
+	void ExceptionTranslatorRegistry::registerTranslator( const IExceptionTranslator* translator ) {
+		m_translators.push_back( std::unique_ptr<const IExceptionTranslator>( translator ) );
+	}
 
-    void ReporterRegistry::registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) {
-        m_factories.emplace(name, factory);
-    }
-    void ReporterRegistry::registerListener( IReporterFactoryPtr const& factory ) {
-        m_listeners.push_back( factory );
-    }
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+	std::string ExceptionTranslatorRegistry::translateActiveException() const {
+		try {
+#ifdef __OBJC__
+			// In Objective-C try objective-c exceptions first
+			@try {
+				return tryTranslators();
+			}
+			@catch (NSException *exception) {
+				return Catch::Detail::stringify( [exception description] );
+			}
+#else
+			// Compiling a mixed mode project with MSVC means that CLR
+			// exceptions will be caught in (...) as well. However, these
+			// do not fill-in std::current_exception and thus lead to crash
+			// when attempting rethrow.
+			// /EHa switch also causes structured exceptions to be caught
+			// here, but they fill-in current_exception properly, so
+			// at worst the output should be a little weird, instead of
+			// causing a crash.
+			if (std::current_exception() == nullptr) {
+				return "Non C++ exception. Possibly a CLR exception.";
+			}
+			return tryTranslators();
+#endif
+		}
+		catch( TestFailureException& ) {
+			std::rethrow_exception(std::current_exception());
+		}
+		catch( std::exception& ex ) {
+			return ex.what();
+		}
+		catch( std::string& msg ) {
+			return msg;
+		}
+		catch( const char* msg ) {
+			return msg;
+		}
+		catch(...) {
+			return "Unknown exception";
+		}
+	}
 
-    IReporterRegistry::FactoryMap const& ReporterRegistry::getFactories() const {
-        return m_factories;
-    }
-    IReporterRegistry::Listeners const& ReporterRegistry::getListeners() const {
-        return m_listeners;
-    }
+#else // ^^ Exceptions are enabled // Exceptions are disabled vv
+	std::string ExceptionTranslatorRegistry::translateActiveException() const {
+		CATCH_INTERNAL_ERROR("Attempted to translate active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
+	}
+#endif
 
+	std::string ExceptionTranslatorRegistry::tryTranslators() const {
+		if( m_translators.empty() )
+			std::rethrow_exception(std::current_exception());
+		else
+			return m_translators[0]->translate( m_translators.begin()+1, m_translators.end() );
+	}
 }
-// end catch_reporter_registry.cpp
-// start catch_result_type.cpp
-
-namespace Catch {
+// end catch_exception_translator_registry.cpp
+// start catch_fatal_condition.cpp
 
-    bool isOk( ResultWas::OfType resultType ) {
-        return ( resultType & ResultWas::FailureBit ) == 0;
-    }
-    bool isJustInfo( int flags ) {
-        return flags == ResultWas::Info;
-    }
+#if defined(__GNUC__)
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+#endif
 
-    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) {
-        return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) | static_cast<int>( rhs ) );
-    }
+#if defined( CATCH_CONFIG_WINDOWS_SEH ) || defined( CATCH_CONFIG_POSIX_SIGNALS )
 
-    bool shouldContinueOnFailure( int flags )    { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }
-    bool isFalseTest( int flags )                { return ( flags & ResultDisposition::FalseTest ) != 0; }
-    bool shouldSuppressFailure( int flags )      { return ( flags & ResultDisposition::SuppressFail ) != 0; }
+namespace {
+	// Report the error condition
+	void reportFatal( char const * const message ) {
+		Catch::getCurrentContext().getResultCapture()->handleFatalErrorCondition( message );
+	}
+}
 
-} // end namespace Catch
-// end catch_result_type.cpp
-// start catch_run_context.cpp
-// start catch_run_context.h
+#endif // signals/SEH handling
 
-#include <string>
+#if defined( CATCH_CONFIG_WINDOWS_SEH )
 
 namespace Catch {
+	struct SignalDefs { DWORD id; const char* name; };
 
-    struct IMutableContext;
+	// There is no 1-1 mapping between signals and windows exceptions.
+	// Windows can easily distinguish between SO and SigSegV,
+	// but SigInt, SigTerm, etc are handled differently.
+	static SignalDefs signalDefs[] = {
+		{ EXCEPTION_ILLEGAL_INSTRUCTION,  "SIGILL - Illegal instruction signal" },
+	{ EXCEPTION_STACK_OVERFLOW, "SIGSEGV - Stack overflow" },
+	{ EXCEPTION_ACCESS_VIOLATION, "SIGSEGV - Segmentation violation signal" },
+	{ EXCEPTION_INT_DIVIDE_BY_ZERO, "Divide by zero error" },
+	};
 
-    class StreamRedirect {
-
-    public:
-        StreamRedirect(std::ostream& stream, std::string& targetString);
-
-        ~StreamRedirect();
-
-    private:
-        std::ostream& m_stream;
-        std::streambuf* m_prevBuf;
-        std::ostringstream m_oss;
-        std::string& m_targetString;
-    };
+	LONG CALLBACK FatalConditionHandler::handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {
+		for (auto const& def : signalDefs) {
+			if (ExceptionInfo->ExceptionRecord->ExceptionCode == def.id) {
+				reportFatal(def.name);
+			}
+		}
+		// If its not an exception we care about, pass it along.
+		// This stops us from eating debugger breaks etc.
+		return EXCEPTION_CONTINUE_SEARCH;
+	}
 
-    // StdErr has two constituent streams in C++, std::cerr and std::clog
-    // This means that we need to redirect 2 streams into 1 to keep proper
-    // order of writes and cannot use StreamRedirect on its own
-    class StdErrRedirect {
-    public:
-        StdErrRedirect(std::string& targetString);
-        ~StdErrRedirect();
-    private:
-        std::streambuf* m_cerrBuf;
-        std::streambuf* m_clogBuf;
-        std::ostringstream m_oss;
-        std::string& m_targetString;
-    };
+	FatalConditionHandler::FatalConditionHandler() {
+		isSet = true;
+		// 32k seems enough for Catch to handle stack overflow,
+		// but the value was found experimentally, so there is no strong guarantee
+		guaranteeSize = 32 * 1024;
+		exceptionHandlerHandle = nullptr;
+		// Register as first handler in current chain
+		exceptionHandlerHandle = AddVectoredExceptionHandler(1, handleVectoredException);
+		// Pass in guarantee size to be filled
+		SetThreadStackGuarantee(&guaranteeSize);
+	}
 
-    ///////////////////////////////////////////////////////////////////////////
+	void FatalConditionHandler::reset() {
+		if (isSet) {
+			RemoveVectoredExceptionHandler(exceptionHandlerHandle);
+			SetThreadStackGuarantee(&guaranteeSize);
+			exceptionHandlerHandle = nullptr;
+			isSet = false;
+		}
+	}
 
-    class RunContext : public IResultCapture, public IRunner {
+	FatalConditionHandler::~FatalConditionHandler() {
+		reset();
+	}
 
-    public:
-        RunContext( RunContext const& ) = delete;
-        RunContext& operator =( RunContext const& ) = delete;
+	bool FatalConditionHandler::isSet = false;
+	ULONG FatalConditionHandler::guaranteeSize = 0;
+	PVOID FatalConditionHandler::exceptionHandlerHandle = nullptr;
 
-        explicit RunContext(IConfigPtr const& _config, IStreamingReporterPtr&& reporter);
+} // namespace Catch
 
-        virtual ~RunContext();
+#elif defined( CATCH_CONFIG_POSIX_SIGNALS )
+
+namespace Catch {
+
+	struct SignalDefs {
+		int id;
+		const char* name;
+	};
+
+	// 32kb for the alternate stack seems to be sufficient. However, this value
+	// is experimentally determined, so that's not guaranteed.
+	constexpr static std::size_t sigStackSize = 32768 >= MINSIGSTKSZ ? 32768 : MINSIGSTKSZ;
+
+	static SignalDefs signalDefs[] = {
+		{ SIGINT,  "SIGINT - Terminal interrupt signal" },
+	{ SIGILL,  "SIGILL - Illegal instruction signal" },
+	{ SIGFPE,  "SIGFPE - Floating point error signal" },
+	{ SIGSEGV, "SIGSEGV - Segmentation violation signal" },
+	{ SIGTERM, "SIGTERM - Termination request signal" },
+	{ SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }
+	};
+
+	void FatalConditionHandler::handleSignal( int sig ) {
+		char const * name = "<unknown signal>";
+		for (auto const& def : signalDefs) {
+			if (sig == def.id) {
+				name = def.name;
+				break;
+			}
+		}
+		reset();
+		reportFatal(name);
+		raise( sig );
+	}
 
-        void testGroupStarting(std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount);
-        void testGroupEnded(std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount);
+	FatalConditionHandler::FatalConditionHandler() {
+		isSet = true;
+		stack_t sigStack;
+		sigStack.ss_sp = altStackMem;
+		sigStack.ss_size = sigStackSize;
+		sigStack.ss_flags = 0;
+		sigaltstack(&sigStack, &oldSigStack);
+		struct sigaction sa = { };
+
+		sa.sa_handler = handleSignal;
+		sa.sa_flags = SA_ONSTACK;
+		for (std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i) {
+			sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
+		}
+	}
 
-        Totals runTest(TestCase const& testCase);
+	FatalConditionHandler::~FatalConditionHandler() {
+		reset();
+	}
 
-        IConfigPtr config() const;
-        IStreamingReporter& reporter() const;
+	void FatalConditionHandler::reset() {
+		if( isSet ) {
+			// Set signals back to previous values -- hopefully nobody overwrote them in the meantime
+			for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) {
+				sigaction(signalDefs[i].id, &oldSigActions[i], nullptr);
+			}
+			// Return the old stack
+			sigaltstack(&oldSigStack, nullptr);
+			isSet = false;
+		}
+	}
 
-    private: // IResultCapture
+	bool FatalConditionHandler::isSet = false;
+	struct sigaction FatalConditionHandler::oldSigActions[sizeof(signalDefs)/sizeof(SignalDefs)] = {};
+	stack_t FatalConditionHandler::oldSigStack = {};
+	char FatalConditionHandler::altStackMem[sigStackSize] = {};
 
-        void assertionStarting(AssertionInfo const& info) override;
-        void assertionEnded(AssertionResult const& result) override;
+} // namespace Catch
 
-        bool sectionStarted( SectionInfo const& sectionInfo, Counts& assertions ) override;
-        bool testForMissingAssertions(Counts& assertions);
+#else
 
-        void sectionEnded(SectionEndInfo const& endInfo) override;
-        void sectionEndedEarly(SectionEndInfo const& endInfo) override;
+namespace Catch {
+	void FatalConditionHandler::reset() {}
+}
 
-        void benchmarkStarting( BenchmarkInfo const& info ) override;
-        void benchmarkEnded( BenchmarkStats const& stats ) override;
+#endif // signals/SEH handling
 
-        void pushScopedMessage(MessageInfo const& message) override;
-        void popScopedMessage(MessageInfo const& message) override;
+#if defined(__GNUC__)
+#    pragma GCC diagnostic pop
+#endif
+// end catch_fatal_condition.cpp
+// start catch_generators.cpp
 
-        std::string getCurrentTestName() const override;
+// start catch_random_number_generator.h
 
-        const AssertionResult* getLastResult() const override;
+#include <algorithm>
+#include <random>
 
-        void exceptionEarlyReported() override;
+namespace Catch {
 
-        void handleFatalErrorCondition( StringRef message ) override;
+	struct IConfig;
 
-        bool lastAssertionPassed() override;
+	std::mt19937& rng();
+	void seedRng( IConfig const& config );
+	unsigned int rngSeed();
 
-        void assertionPassed() override;
+}
 
-        void assertionRun() override;
+// end catch_random_number_generator.h
+#include <limits>
+#include <set>
 
-    public:
-        // !TBD We need to do this another way!
-        bool aborting() const override;
+namespace Catch {
 
-    private:
+	IGeneratorTracker::~IGeneratorTracker() {}
 
-        void runCurrentTest(std::string& redirectedCout, std::string& redirectedCerr);
-        void invokeActiveTestCase();
+	namespace Generators {
 
-    private:
+		GeneratorBase::~GeneratorBase() {}
 
-        void handleUnfinishedSections();
+		std::vector<size_t> randomiseIndices( size_t selectionSize, size_t sourceSize ) {
 
-        TestRunInfo m_runInfo;
-        IMutableContext& m_context;
-        TestCase const* m_activeTestCase = nullptr;
-        ITracker* m_testCaseTracker;
-        Option<AssertionResult> m_lastResult;
+			assert( selectionSize <= sourceSize );
+			std::vector<size_t> indices;
+			indices.reserve( selectionSize );
+			std::uniform_int_distribution<size_t> uid( 0, sourceSize-1 );
 
-        IConfigPtr m_config;
-        Totals m_totals;
-        IStreamingReporterPtr m_reporter;
-        std::vector<MessageInfo> m_messages;
-        AssertionInfo m_lastAssertionInfo;
-        std::vector<SectionEndInfo> m_unfinishedSections;
-        std::vector<ITracker*> m_activeSections;
-        TrackerContext m_trackerContext;
-        std::size_t m_prevPassed = 0;
-        bool m_shouldReportUnexpected = true;
-    };
+			std::set<size_t> seen;
+			// !TBD: improve this algorithm
+			while( indices.size() < selectionSize ) {
+				auto index = uid( rng() );
+				if( seen.insert( index ).second )
+					indices.push_back( index );
+			}
+			return indices;
+		}
 
-    IResultCapture& getResultCapture();
+		auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
+			return getResultCapture().acquireGeneratorTracker( lineInfo );
+		}
 
-} // end namespace Catch
+		template<>
+		auto all<int>() -> Generator<int> {
+			return range( std::numeric_limits<int>::min(), std::numeric_limits<int>::max() );
+		}
 
-// end catch_run_context.h
+	} // namespace Generators
+} // namespace Catch
+  // end catch_generators.cpp
+  // start catch_interfaces_capture.cpp
 
-#include <cassert>
-#include <algorithm>
+namespace Catch {
+	IResultCapture::~IResultCapture() = default;
+}
+// end catch_interfaces_capture.cpp
+// start catch_interfaces_config.cpp
 
 namespace Catch {
+	IConfig::~IConfig() = default;
+}
+// end catch_interfaces_config.cpp
+// start catch_interfaces_exception.cpp
 
-    StreamRedirect::StreamRedirect(std::ostream& stream, std::string& targetString)
-        : m_stream(stream),
-        m_prevBuf(stream.rdbuf()),
-        m_targetString(targetString) {
-        stream.rdbuf(m_oss.rdbuf());
-    }
-
-    StreamRedirect::~StreamRedirect() {
-        m_targetString += m_oss.str();
-        m_stream.rdbuf(m_prevBuf);
-    }
-
-    StdErrRedirect::StdErrRedirect(std::string & targetString)
-        :m_cerrBuf(cerr().rdbuf()), m_clogBuf(clog().rdbuf()),
-        m_targetString(targetString) {
-        cerr().rdbuf(m_oss.rdbuf());
-        clog().rdbuf(m_oss.rdbuf());
-    }
-
-    StdErrRedirect::~StdErrRedirect() {
-        m_targetString += m_oss.str();
-        cerr().rdbuf(m_cerrBuf);
-        clog().rdbuf(m_clogBuf);
-    }
-
-    RunContext::RunContext(IConfigPtr const& _config, IStreamingReporterPtr&& reporter)
-    :   m_runInfo(_config->name()),
-        m_context(getCurrentMutableContext()),
-        m_config(_config),
-        m_reporter(std::move(reporter)),
-        m_lastAssertionInfo{ "", SourceLineInfo("",0), "", ResultDisposition::Normal }
-    {
-        m_context.setRunner(this);
-        m_context.setConfig(m_config);
-        m_context.setResultCapture(this);
-        m_reporter->testRunStarting(m_runInfo);
-    }
-
-    RunContext::~RunContext() {
-        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting()));
-    }
-
-    void RunContext::testGroupStarting(std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount) {
-        m_reporter->testGroupStarting(GroupInfo(testSpec, groupIndex, groupsCount));
-    }
-
-    void RunContext::testGroupEnded(std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount) {
-        m_reporter->testGroupEnded(TestGroupStats(GroupInfo(testSpec, groupIndex, groupsCount), totals, aborting()));
-    }
-
-    Totals RunContext::runTest(TestCase const& testCase) {
-        Totals prevTotals = m_totals;
-
-        std::string redirectedCout;
-        std::string redirectedCerr;
-
-        TestCaseInfo testInfo = testCase.getTestCaseInfo();
-
-        m_reporter->testCaseStarting(testInfo);
-
-        m_activeTestCase = &testCase;
-
-        ITracker& rootTracker = m_trackerContext.startRun();
-        assert(rootTracker.isSectionTracker());
-        static_cast<SectionTracker&>(rootTracker).addInitialFilters(m_config->getSectionsToRun());
-        do {
-            m_trackerContext.startCycle();
-            m_testCaseTracker = &SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(testInfo.name, testInfo.lineInfo));
-            runCurrentTest(redirectedCout, redirectedCerr);
-        } while (!m_testCaseTracker->isSuccessfullyCompleted() && !aborting());
-
-        Totals deltaTotals = m_totals.delta(prevTotals);
-        if (testInfo.expectedToFail() && deltaTotals.testCases.passed > 0) {
-            deltaTotals.assertions.failed++;
-            deltaTotals.testCases.passed--;
-            deltaTotals.testCases.failed++;
-        }
-        m_totals.testCases += deltaTotals.testCases;
-        m_reporter->testCaseEnded(TestCaseStats(testInfo,
-                                  deltaTotals,
-                                  redirectedCout,
-                                  redirectedCerr,
-                                  aborting()));
-
-        m_activeTestCase = nullptr;
-        m_testCaseTracker = nullptr;
-
-        return deltaTotals;
-    }
-
-    IConfigPtr RunContext::config() const {
-        return m_config;
-    }
-
-    IStreamingReporter& RunContext::reporter() const {
-        return *m_reporter;
-    }
-
-    void RunContext::assertionStarting(AssertionInfo const& info) {
-        m_reporter->assertionStarting( info );
-    }
-    void RunContext::assertionEnded(AssertionResult const & result) {
-        if (result.getResultType() == ResultWas::Ok) {
-            m_totals.assertions.passed++;
-        } else if (!result.isOk()) {
-            if( m_activeTestCase->getTestCaseInfo().okToFail() )
-                m_totals.assertions.failedButOk++;
-            else
-                m_totals.assertions.failed++;
-        }
-
-        // We have no use for the return value (whether messages should be cleared), because messages were made scoped
-        // and should be let to clear themselves out.
-        static_cast<void>(m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals)));
-
-        // Reset working state
-        m_lastAssertionInfo = { "", m_lastAssertionInfo.lineInfo, "{Unknown expression after the reported line}", m_lastAssertionInfo.resultDisposition };
-        m_lastResult = result;
-    }
-
-    bool RunContext::sectionStarted(SectionInfo const & sectionInfo, Counts & assertions) {
-        ITracker& sectionTracker = SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(sectionInfo.name, sectionInfo.lineInfo));
-        if (!sectionTracker.isOpen())
-            return false;
-        m_activeSections.push_back(&sectionTracker);
-
-        m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
-
-        m_reporter->sectionStarting(sectionInfo);
-
-        assertions = m_totals.assertions;
-
-        return true;
-    }
-
-    bool RunContext::testForMissingAssertions(Counts& assertions) {
-        if (assertions.total() != 0)
-            return false;
-        if (!m_config->warnAboutMissingAssertions())
-            return false;
-        if (m_trackerContext.currentTracker().hasChildren())
-            return false;
-        m_totals.assertions.failed++;
-        assertions.failed++;
-        return true;
-    }
-
-    void RunContext::sectionEnded(SectionEndInfo const & endInfo) {
-        Counts assertions = m_totals.assertions - endInfo.prevAssertions;
-        bool missingAssertions = testForMissingAssertions(assertions);
-
-        if (!m_activeSections.empty()) {
-            m_activeSections.back()->close();
-            m_activeSections.pop_back();
-        }
-
-        m_reporter->sectionEnded(SectionStats(endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions));
-        m_messages.clear();
-    }
-
-    void RunContext::sectionEndedEarly(SectionEndInfo const & endInfo) {
-        if (m_unfinishedSections.empty())
-            m_activeSections.back()->fail();
-        else
-            m_activeSections.back()->close();
-        m_activeSections.pop_back();
-
-        m_unfinishedSections.push_back(endInfo);
-    }
-    void RunContext::benchmarkStarting( BenchmarkInfo const& info ) {
-        m_reporter->benchmarkStarting( info );
-    }
-    void RunContext::benchmarkEnded( BenchmarkStats const& stats ) {
-        m_reporter->benchmarkEnded( stats );
-    }
-
-    void RunContext::pushScopedMessage(MessageInfo const & message) {
-        m_messages.push_back(message);
-    }
-
-    void RunContext::popScopedMessage(MessageInfo const & message) {
-        m_messages.erase(std::remove(m_messages.begin(), m_messages.end(), message), m_messages.end());
-    }
-
-    std::string RunContext::getCurrentTestName() const {
-        return m_activeTestCase
-            ? m_activeTestCase->getTestCaseInfo().name
-            : std::string();
-    }
-
-    const AssertionResult * RunContext::getLastResult() const {
-        return &(*m_lastResult);
-    }
-
-    void RunContext::exceptionEarlyReported() {
-        m_shouldReportUnexpected = false;
-    }
-
-    void RunContext::handleFatalErrorCondition( StringRef message ) {
-        // First notify reporter that bad things happened
-        m_reporter->fatalErrorEncountered(message);
-
-        // Don't rebuild the result -- the stringification itself can cause more fatal errors
-        // Instead, fake a result data.
-        AssertionResultData tempResult( ResultWas::FatalErrorCondition, { false } );
-        tempResult.message = message;
-        AssertionResult result(m_lastAssertionInfo, tempResult);
-
-        getResultCapture().assertionEnded(result);
-
-        handleUnfinishedSections();
-
-        // Recreate section for test case (as we will lose the one that was in scope)
-        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
-        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description);
-
-        Counts assertions;
-        assertions.failed = 1;
-        SectionStats testCaseSectionStats(testCaseSection, assertions, 0, false);
-        m_reporter->sectionEnded(testCaseSectionStats);
-
-        auto const& testInfo = m_activeTestCase->getTestCaseInfo();
-
-        Totals deltaTotals;
-        deltaTotals.testCases.failed = 1;
-        deltaTotals.assertions.failed = 1;
-        m_reporter->testCaseEnded(TestCaseStats(testInfo,
-                                  deltaTotals,
-                                  std::string(),
-                                  std::string(),
-                                  false));
-        m_totals.testCases.failed++;
-        testGroupEnded(std::string(), m_totals, 1, 1);
-        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, false));
-    }
-
-    bool RunContext::lastAssertionPassed() {
-         return m_totals.assertions.passed == (m_prevPassed + 1);
-    }
-
-    void RunContext::assertionPassed() {
-        ++m_totals.assertions.passed;
-        m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}";
-        m_lastAssertionInfo.macroName = "";
-    }
-
-    void RunContext::assertionRun() {
-        m_prevPassed = m_totals.assertions.passed;
-    }
-
-    bool RunContext::aborting() const {
-        return m_totals.assertions.failed == static_cast<std::size_t>(m_config->abortAfter());
-    }
-
-    void RunContext::runCurrentTest(std::string & redirectedCout, std::string & redirectedCerr) {
-        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
-        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description);
-        m_reporter->sectionStarting(testCaseSection);
-        Counts prevAssertions = m_totals.assertions;
-        double duration = 0;
-        m_shouldReportUnexpected = true;
-        try {
-            m_lastAssertionInfo = { "TEST_CASE", testCaseInfo.lineInfo, "", ResultDisposition::Normal };
-
-            seedRng(*m_config);
-
-            Timer timer;
-            timer.start();
-            if (m_reporter->getPreferences().shouldRedirectStdOut) {
-                StreamRedirect coutRedir(cout(), redirectedCout);
-                StdErrRedirect errRedir(redirectedCerr);
-                invokeActiveTestCase();
-            } else {
-                invokeActiveTestCase();
-            }
-            duration = timer.getElapsedSeconds();
-        } catch (TestFailureException&) {
-            // This just means the test was aborted due to failure
-        } catch (...) {
-            // Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions
-            // are reported without translation at the point of origin.
-            if (m_shouldReportUnexpected) {
-                AssertionHandler
-                    ( m_lastAssertionInfo.macroName,
-                      m_lastAssertionInfo.lineInfo,
-                      m_lastAssertionInfo.capturedExpression,
-                      m_lastAssertionInfo.resultDisposition ).useActiveException();
-            }
-        }
-        m_testCaseTracker->close();
-        handleUnfinishedSections();
-        m_messages.clear();
-
-        Counts assertions = m_totals.assertions - prevAssertions;
-        bool missingAssertions = testForMissingAssertions(assertions);
-        SectionStats testCaseSectionStats(testCaseSection, assertions, duration, missingAssertions);
-        m_reporter->sectionEnded(testCaseSectionStats);
-    }
-
-    void RunContext::invokeActiveTestCase() {
-        FatalConditionHandler fatalConditionHandler; // Handle signals
-        m_activeTestCase->invoke();
-        fatalConditionHandler.reset();
-    }
-
-    void RunContext::handleUnfinishedSections() {
-        // If sections ended prematurely due to an exception we stored their
-        // infos here so we can tear them down outside the unwind process.
-        for (auto it = m_unfinishedSections.rbegin(),
-             itEnd = m_unfinishedSections.rend();
-             it != itEnd;
-             ++it)
-            sectionEnded(*it);
-        m_unfinishedSections.clear();
-    }
-
-    IResultCapture& getResultCapture() {
-        if (auto* capture = getCurrentContext().getResultCapture())
-            return *capture;
-        else
-            CATCH_INTERNAL_ERROR("No result capture instance");
-    }
+namespace Catch {
+	IExceptionTranslator::~IExceptionTranslator() = default;
+	IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() = default;
 }
-// end catch_run_context.cpp
-// start catch_section.cpp
+// end catch_interfaces_exception.cpp
+// start catch_interfaces_registry_hub.cpp
 
 namespace Catch {
+	IRegistryHub::~IRegistryHub() = default;
+	IMutableRegistryHub::~IMutableRegistryHub() = default;
+}
+// end catch_interfaces_registry_hub.cpp
+// start catch_interfaces_reporter.cpp
 
-    Section::Section( SectionInfo const& info )
-    :   m_info( info ),
-        m_sectionIncluded( getResultCapture().sectionStarted( m_info, m_assertions ) )
-    {
-        m_timer.start();
-    }
+// start catch_reporter_listening.h
 
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4996) // std::uncaught_exception is deprecated in C++17
-#endif
-    Section::~Section() {
-        if( m_sectionIncluded ) {
-            SectionEndInfo endInfo( m_info, m_assertions, m_timer.getElapsedSeconds() );
-            if( std::uncaught_exception() )
-                getResultCapture().sectionEndedEarly( endInfo );
-            else
-                getResultCapture().sectionEnded( endInfo );
-        }
-    }
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
+namespace Catch {
 
-    // This indicates whether the section should be executed or not
-    Section::operator bool() const {
-        return m_sectionIncluded;
-    }
+	class ListeningReporter : public IStreamingReporter {
+		using Reporters = std::vector<IStreamingReporterPtr>;
+		Reporters m_listeners;
+		IStreamingReporterPtr m_reporter = nullptr;
+		ReporterPreferences m_preferences;
 
-} // end namespace Catch
-// end catch_section.cpp
-// start catch_section_info.cpp
+	public:
+		ListeningReporter();
 
-namespace Catch {
+		void addListener( IStreamingReporterPtr&& listener );
+		void addReporter( IStreamingReporterPtr&& reporter );
 
-    SectionInfo::SectionInfo
-        (   SourceLineInfo const& _lineInfo,
-            std::string const& _name,
-            std::string const& _description )
-    :   name( _name ),
-        description( _description ),
-        lineInfo( _lineInfo )
-    {}
+	public: // IStreamingReporter
 
-    SectionEndInfo::SectionEndInfo( SectionInfo const& _sectionInfo, Counts const& _prevAssertions, double _durationInSeconds )
-    : sectionInfo( _sectionInfo ), prevAssertions( _prevAssertions ), durationInSeconds( _durationInSeconds )
-    {}
+		ReporterPreferences getPreferences() const override;
 
-} // end namespace Catch
-// end catch_section_info.cpp
-// start catch_session.cpp
+		void noMatchingTestCases( std::string const& spec ) override;
 
-// start catch_session.h
+		static std::set<Verbosity> getSupportedVerbosities();
 
-#include <memory>
+		void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
+		void benchmarkEnded( BenchmarkStats const& benchmarkStats ) override;
 
-namespace Catch {
+		void testRunStarting( TestRunInfo const& testRunInfo ) override;
+		void testGroupStarting( GroupInfo const& groupInfo ) override;
+		void testCaseStarting( TestCaseInfo const& testInfo ) override;
+		void sectionStarting( SectionInfo const& sectionInfo ) override;
+		void assertionStarting( AssertionInfo const& assertionInfo ) override;
 
-    class Session : NonCopyable {
-    public:
+		// The return value indicates if the messages buffer should be cleared:
+		bool assertionEnded( AssertionStats const& assertionStats ) override;
+		void sectionEnded( SectionStats const& sectionStats ) override;
+		void testCaseEnded( TestCaseStats const& testCaseStats ) override;
+		void testGroupEnded( TestGroupStats const& testGroupStats ) override;
+		void testRunEnded( TestRunStats const& testRunStats ) override;
 
-        Session();
-        ~Session() override;
+		void skipTest( TestCaseInfo const& testInfo ) override;
+		bool isMulti() const override;
 
-        void showHelp() const;
-        void libIdentify();
+	};
 
-        int applyCommandLine( int argc, char* argv[] );
+} // end namespace Catch
 
-        void useConfigData( ConfigData const& configData );
+  // end catch_reporter_listening.h
+namespace Catch {
 
-        int run( int argc, char* argv[] );
-    #if defined(WIN32) && defined(UNICODE)
-        int run( int argc, wchar_t* const argv[] );
-    #endif
-        int run();
+	ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig )
+		:   m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {}
 
-        clara::Parser const& cli() const;
-        void cli( clara::Parser const& newParser );
-        ConfigData& configData();
-        Config& config();
-    private:
-        int runInternal();
+	ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream )
+		:   m_stream( &_stream ), m_fullConfig( _fullConfig ) {}
 
-        clara::Parser m_cli;
-        ConfigData m_configData;
-        std::shared_ptr<Config> m_config;
-        bool m_startupExceptions = false;
-    };
+	std::ostream& ReporterConfig::stream() const { return *m_stream; }
+	IConfigPtr ReporterConfig::fullConfig() const { return m_fullConfig; }
 
-} // end namespace Catch
+	TestRunInfo::TestRunInfo( std::string const& _name ) : name( _name ) {}
 
-// end catch_session.h
-// start catch_version.h
+	GroupInfo::GroupInfo(  std::string const& _name,
+		std::size_t _groupIndex,
+		std::size_t _groupsCount )
+		:   name( _name ),
+		groupIndex( _groupIndex ),
+		groupsCounts( _groupsCount )
+	{}
 
-#include <iosfwd>
+	AssertionStats::AssertionStats( AssertionResult const& _assertionResult,
+		std::vector<MessageInfo> const& _infoMessages,
+		Totals const& _totals )
+		:   assertionResult( _assertionResult ),
+		infoMessages( _infoMessages ),
+		totals( _totals )
+	{
+		assertionResult.m_resultData.lazyExpression.m_transientExpression = _assertionResult.m_resultData.lazyExpression.m_transientExpression;
 
-namespace Catch {
+		if( assertionResult.hasMessage() ) {
+			// Copy message into messages list.
+			// !TBD This should have been done earlier, somewhere
+			MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
+			builder << assertionResult.getMessage();
+			builder.m_info.message = builder.m_stream.str();
 
-    // Versioning information
-    struct Version {
-        Version( Version const& ) = delete;
-        Version& operator=( Version const& ) = delete;
-        Version(    unsigned int _majorVersion,
-                    unsigned int _minorVersion,
-                    unsigned int _patchNumber,
-                    char const * const _branchName,
-                    unsigned int _buildNumber );
+			infoMessages.push_back( builder.m_info );
+		}
+	}
 
-        unsigned int const majorVersion;
-        unsigned int const minorVersion;
-        unsigned int const patchNumber;
+	AssertionStats::~AssertionStats() = default;
+
+	SectionStats::SectionStats(  SectionInfo const& _sectionInfo,
+		Counts const& _assertions,
+		double _durationInSeconds,
+		bool _missingAssertions )
+		:   sectionInfo( _sectionInfo ),
+		assertions( _assertions ),
+		durationInSeconds( _durationInSeconds ),
+		missingAssertions( _missingAssertions )
+	{}
+
+	SectionStats::~SectionStats() = default;
+
+	TestCaseStats::TestCaseStats(  TestCaseInfo const& _testInfo,
+		Totals const& _totals,
+		std::string const& _stdOut,
+		std::string const& _stdErr,
+		bool _aborting )
+		: testInfo( _testInfo ),
+		totals( _totals ),
+		stdOut( _stdOut ),
+		stdErr( _stdErr ),
+		aborting( _aborting )
+	{}
+
+	TestCaseStats::~TestCaseStats() = default;
+
+	TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo,
+		Totals const& _totals,
+		bool _aborting )
+		:   groupInfo( _groupInfo ),
+		totals( _totals ),
+		aborting( _aborting )
+	{}
+
+	TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo )
+		:   groupInfo( _groupInfo ),
+		aborting( false )
+	{}
+
+	TestGroupStats::~TestGroupStats() = default;
+
+	TestRunStats::TestRunStats(   TestRunInfo const& _runInfo,
+		Totals const& _totals,
+		bool _aborting )
+		:   runInfo( _runInfo ),
+		totals( _totals ),
+		aborting( _aborting )
+	{}
+
+	TestRunStats::~TestRunStats() = default;
+
+	void IStreamingReporter::fatalErrorEncountered( StringRef ) {}
+	bool IStreamingReporter::isMulti() const { return false; }
+
+	IReporterFactory::~IReporterFactory() = default;
+	IReporterRegistry::~IReporterRegistry() = default;
 
-        // buildNumber is only used if branchName is not null
-        char const * const branchName;
-        unsigned int const buildNumber;
+} // end namespace Catch
+  // end catch_interfaces_reporter.cpp
+  // start catch_interfaces_runner.cpp
 
-        friend std::ostream& operator << ( std::ostream& os, Version const& version );
-    };
+namespace Catch {
+	IRunner::~IRunner() = default;
+}
+// end catch_interfaces_runner.cpp
+// start catch_interfaces_testcase.cpp
 
-    Version const& libraryVersion();
+namespace Catch {
+	ITestInvoker::~ITestInvoker() = default;
+	ITestCaseRegistry::~ITestCaseRegistry() = default;
 }
+// end catch_interfaces_testcase.cpp
+// start catch_leak_detector.cpp
 
-// end catch_version.h
-#include <cstdlib>
-#include <iomanip>
+#ifdef CATCH_CONFIG_WINDOWS_CRTDBG
+#include <crtdbg.h>
 
-namespace {
-    const int MaxExitCode = 255;
-    using Catch::IStreamingReporterPtr;
-    using Catch::IConfigPtr;
-    using Catch::Config;
+namespace Catch {
+
+	LeakDetector::LeakDetector() {
+		int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
+		flag |= _CRTDBG_LEAK_CHECK_DF;
+		flag |= _CRTDBG_ALLOC_MEM_DF;
+		_CrtSetDbgFlag(flag);
+		_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
+		_CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
+		// Change this to leaking allocation's number to break there
+		_CrtSetBreakAlloc(-1);
+	}
+}
 
-    IStreamingReporterPtr createReporter(std::string const& reporterName, IConfigPtr const& config) {
-        auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, config);
-        CATCH_ENFORCE(reporter, "No reporter registered with name: '" << reporterName << "'");
+#else
 
-        return reporter;
-    }
+Catch::LeakDetector::LeakDetector() {}
 
-#ifndef CATCH_CONFIG_DEFAULT_REPORTER
-#define CATCH_CONFIG_DEFAULT_REPORTER "console"
 #endif
 
-    IStreamingReporterPtr makeReporter(std::shared_ptr<Config> const& config) {
-        auto const& reporterNames = config->getReporterNames();
-        if (reporterNames.empty())
-            return createReporter(CATCH_CONFIG_DEFAULT_REPORTER, config);
+Catch::LeakDetector::~LeakDetector() {
+	Catch::cleanUp();
+}
+// end catch_leak_detector.cpp
+// start catch_list.cpp
+
+// start catch_list.h
 
-        IStreamingReporterPtr reporter;
-        for (auto const& name : reporterNames)
-            addReporter(reporter, createReporter(name, config));
-        return reporter;
-    }
+#include <set>
 
-#undef CATCH_CONFIG_DEFAULT_REPORTER
+namespace Catch {
 
-    void addListeners(IStreamingReporterPtr& reporters, IConfigPtr const& config) {
-        auto const& listeners = Catch::getRegistryHub().getReporterRegistry().getListeners();
-        for (auto const& listener : listeners)
-            addReporter(reporters, listener->create(Catch::ReporterConfig(config)));
-    }
-
-    Catch::Totals runTests(std::shared_ptr<Config> const& config) {
-        using namespace Catch;
-        IStreamingReporterPtr reporter = makeReporter(config);
-        addListeners(reporter, config);
-
-        RunContext context(config, std::move(reporter));
-
-        Totals totals;
-
-        context.testGroupStarting(config->name(), 1, 1);
-
-        TestSpec testSpec = config->testSpec();
-        if (!testSpec.hasFilters())
-            testSpec = TestSpecParser(ITagAliasRegistry::get()).parse("~[.]").testSpec(); // All not hidden tests
-
-        auto const& allTestCases = getAllTestCasesSorted(*config);
-        for (auto const& testCase : allTestCases) {
-            if (!context.aborting() && matchTest(testCase, testSpec, *config))
-                totals += context.runTest(testCase);
-            else
-                context.reporter().skipTest(testCase);
-        }
-
-        context.testGroupEnded(config->name(), totals, 1, 1);
-        return totals;
-    }
-
-    void applyFilenamesAsTags(Catch::IConfig const& config) {
-        using namespace Catch;
-        auto& tests = const_cast<std::vector<TestCase>&>(getAllTestCasesSorted(config));
-        for (auto& testCase : tests) {
-            auto tags = testCase.tags;
-
-            std::string filename = testCase.lineInfo.file;
-            auto lastSlash = filename.find_last_of("\\/");
-            if (lastSlash != std::string::npos) {
-                filename.erase(0, lastSlash);
-                filename[0] = '#';
-            }
-
-            auto lastDot = filename.find_last_of('.');
-            if (lastDot != std::string::npos) {
-                filename.erase(lastDot);
-            }
-
-            tags.push_back(std::move(filename));
-            setTags(testCase, tags);
-        }
-    }
+	std::size_t listTests( Config const& config );
 
-}
+	std::size_t listTestsNamesOnly( Config const& config );
 
-namespace Catch {
+	struct TagInfo {
+		void add( std::string const& spelling );
+		std::string all() const;
 
-    Session::Session() {
-        static bool alreadyInstantiated = false;
-        if( alreadyInstantiated ) {
-            try         { CATCH_INTERNAL_ERROR( "Only one instance of Catch::Session can ever be used" ); }
-            catch(...)  { getMutableRegistryHub().registerStartupException(); }
-        }
-
-        const auto& exceptions = getRegistryHub().getStartupExceptionRegistry().getExceptions();
-        if ( !exceptions.empty() ) {
-            m_startupExceptions = true;
-            Colour colourGuard( Colour::Red );
-            Catch::cerr() << "Errors occured during startup!" << '\n';
-            // iterate over all exceptions and notify user
-            for ( const auto& ex_ptr : exceptions ) {
-                try {
-                    std::rethrow_exception(ex_ptr);
-                } catch ( std::exception const& ex ) {
-                    Catch::cerr() << Column( ex.what() ).indent(2) << '\n';
-                }
-            }
-        }
-
-        alreadyInstantiated = true;
-        m_cli = makeCommandLineParser( m_configData );
-    }
-    Session::~Session() {
-        Catch::cleanUp();
-    }
-
-    void Session::showHelp() const {
-        Catch::cout()
-                << "\nCatch v" << libraryVersion() << "\n"
-                << m_cli << std::endl
-                << "For more detailed usage please see the project docs\n" << std::endl;
-    }
-    void Session::libIdentify() {
-        Catch::cout()
-                << std::left << std::setw(16) << "description: " << "A Catch test executable\n"
-                << std::left << std::setw(16) << "category: " << "testframework\n"
-                << std::left << std::setw(16) << "framework: " << "Catch Test\n"
-                << std::left << std::setw(16) << "version: " << libraryVersion() << std::endl;
-    }
-
-    int Session::applyCommandLine( int argc, char* argv[] ) {
-        if( m_startupExceptions )
-            return 1;
-
-        auto result = m_cli.parse( clara::Args( argc, argv ) );
-        if( !result ) {
-            Catch::cerr()
-                << Colour( Colour::Red )
-                << "\nError(s) in input:\n"
-                << Column( result.errorMessage() ).indent( 2 )
-                << "\n\n";
-            Catch::cerr() << "Run with -? for usage\n" << std::endl;
-            return MaxExitCode;
-        }
-
-        if( m_configData.showHelp )
-            showHelp();
-        if( m_configData.libIdentify )
-            libIdentify();
-        m_config.reset();
-        return 0;
-    }
-
-    void Session::useConfigData( ConfigData const& configData ) {
-        m_configData = configData;
-        m_config.reset();
-    }
-
-    int Session::run( int argc, char* argv[] ) {
-        if( m_startupExceptions )
-            return 1;
-        int returnCode = applyCommandLine( argc, argv );
-        if( returnCode == 0 )
-            returnCode = run();
-        return returnCode;
-    }
-
-#if defined(WIN32) && defined(UNICODE)
-    int Session::run( int argc, wchar_t* const argv[] ) {
-
-        char **utf8Argv = new char *[ argc ];
-
-        for ( int i = 0; i < argc; ++i ) {
-            int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, NULL, 0, NULL, NULL );
-
-            utf8Argv[ i ] = new char[ bufSize ];
-
-            WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, NULL, NULL );
-        }
-
-        int returnCode = run( argc, utf8Argv );
-
-        for ( int i = 0; i < argc; ++i )
-            delete [] utf8Argv[ i ];
-
-        delete [] utf8Argv;
-
-        return returnCode;
-    }
-#endif
-    int Session::run() {
-        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
-            Catch::cout() << "...waiting for enter/ return before starting" << std::endl;
-            static_cast<void>(std::getchar());
-        }
-        int exitCode = runInternal();
-        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeExit ) != 0 ) {
-            Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode << std::endl;
-            static_cast<void>(std::getchar());
-        }
-        return exitCode;
-    }
-
-    clara::Parser const& Session::cli() const {
-        return m_cli;
-    }
-    void Session::cli( clara::Parser const& newParser ) {
-        m_cli = newParser;
-    }
-    ConfigData& Session::configData() {
-        return m_configData;
-    }
-    Config& Session::config() {
-        if( !m_config )
-            m_config = std::make_shared<Config>( m_configData );
-        return *m_config;
-    }
-
-    int Session::runInternal() {
-        if( m_startupExceptions )
-            return 1;
-
-        if( m_configData.showHelp || m_configData.libIdentify )
-            return 0;
-
-        try
-        {
-            config(); // Force config to be constructed
-
-            seedRng( *m_config );
-
-            if( m_configData.filenamesAsTags )
-                applyFilenamesAsTags( *m_config );
-
-            // Handle list request
-            if( Option<std::size_t> listed = list( config() ) )
-                return static_cast<int>( *listed );
-
-            return (std::min)( MaxExitCode, static_cast<int>( runTests( m_config ).assertions.failed ) );
-        }
-        catch( std::exception& ex ) {
-            Catch::cerr() << ex.what() << std::endl;
-            return MaxExitCode;
-        }
-    }
+		std::set<std::string> spellings;
+		std::size_t count = 0;
+	};
 
-} // end namespace Catch
-// end catch_session.cpp
-// start catch_startup_exception_registry.cpp
+	std::size_t listTags( Config const& config );
 
-namespace Catch {
-    void StartupExceptionRegistry::add( std::exception_ptr const& exception ) noexcept {
-        try {
-            m_exceptions.push_back(exception);
-        }
-        catch(...) {
-            // If we run out of memory during start-up there's really not a lot more we can do about it
-            std::terminate();
-        }
-    }
+	std::size_t listReporters();
 
-    std::vector<std::exception_ptr> const& StartupExceptionRegistry::getExceptions() const noexcept {
-        return m_exceptions;
-    }
+	Option<std::size_t> list( Config const& config );
 
 } // end namespace Catch
-// end catch_startup_exception_registry.cpp
-// start catch_stream.cpp
 
-#include <stdexcept>
-#include <cstdio>
-#include <iostream>
+  // end catch_list.h
+  // start catch_text.h
 
 namespace Catch {
+	using namespace clara::TextFlow;
+}
 
-    template<typename WriterF, std::size_t bufferSize=256>
-    class StreamBufImpl : public StreamBufBase {
-        char data[bufferSize];
-        WriterF m_writer;
+// end catch_text.h
+#include <limits>
+#include <algorithm>
+#include <iomanip>
 
-    public:
-        StreamBufImpl() {
-            setp( data, data + sizeof(data) );
-        }
+namespace Catch {
 
-        ~StreamBufImpl() noexcept {
-            StreamBufImpl::sync();
-        }
+	std::size_t listTests( Config const& config ) {
+		TestSpec testSpec = config.testSpec();
+		if( config.hasTestFilters() )
+			Catch::cout() << "Matching test cases:\n";
+		else {
+			Catch::cout() << "All available test cases:\n";
+		}
+
+		auto matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
+		for( auto const& testCaseInfo : matchedTestCases ) {
+			Colour::Code colour = testCaseInfo.isHidden()
+				? Colour::SecondaryText
+				: Colour::None;
+			Colour colourGuard( colour );
+
+			Catch::cout() << Column( testCaseInfo.name ).initialIndent( 2 ).indent( 4 ) << "\n";
+			if( config.verbosity() >= Verbosity::High ) {
+				Catch::cout() << Column( Catch::Detail::stringify( testCaseInfo.lineInfo ) ).indent(4) << std::endl;
+				std::string description = testCaseInfo.description;
+				if( description.empty() )
+					description = "(NO DESCRIPTION)";
+				Catch::cout() << Column( description ).indent(4) << std::endl;
+			}
+			if( !testCaseInfo.tags.empty() )
+				Catch::cout() << Column( testCaseInfo.tagsAsString() ).indent( 6 ) << "\n";
+		}
+
+		if( !config.hasTestFilters() )
+			Catch::cout() << pluralise( matchedTestCases.size(), "test case" ) << '\n' << std::endl;
+		else
+			Catch::cout() << pluralise( matchedTestCases.size(), "matching test case" ) << '\n' << std::endl;
+		return matchedTestCases.size();
+	}
 
-    private:
-        int overflow( int c ) override {
-            sync();
+	std::size_t listTestsNamesOnly( Config const& config ) {
+		TestSpec testSpec = config.testSpec();
+		std::size_t matchedTests = 0;
+		std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
+		for( auto const& testCaseInfo : matchedTestCases ) {
+			matchedTests++;
+			if( startsWith( testCaseInfo.name, '#' ) )
+				Catch::cout() << '"' << testCaseInfo.name << '"';
+			else
+				Catch::cout() << testCaseInfo.name;
+			if ( config.verbosity() >= Verbosity::High )
+				Catch::cout() << "\t@" << testCaseInfo.lineInfo;
+			Catch::cout() << std::endl;
+		}
+		return matchedTests;
+	}
 
-            if( c != EOF ) {
-                if( pbase() == epptr() )
-                    m_writer( std::string( 1, static_cast<char>( c ) ) );
-                else
-                    sputc( static_cast<char>( c ) );
-            }
-            return 0;
-        }
+	void TagInfo::add( std::string const& spelling ) {
+		++count;
+		spellings.insert( spelling );
+	}
 
-        int sync() override {
-            if( pbase() != pptr() ) {
-                m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
-                setp( pbase(), epptr() );
-            }
-            return 0;
-        }
-    };
+	std::string TagInfo::all() const {
+		std::string out;
+		for( auto const& spelling : spellings )
+			out += "[" + spelling + "]";
+		return out;
+	}
 
-    ///////////////////////////////////////////////////////////////////////////
+	std::size_t listTags( Config const& config ) {
+		TestSpec testSpec = config.testSpec();
+		if( config.hasTestFilters() )
+			Catch::cout() << "Tags for matching test cases:\n";
+		else {
+			Catch::cout() << "All available tags:\n";
+		}
+
+		std::map<std::string, TagInfo> tagCounts;
+
+		std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
+		for( auto const& testCase : matchedTestCases ) {
+			for( auto const& tagName : testCase.getTestCaseInfo().tags ) {
+				std::string lcaseTagName = toLower( tagName );
+				auto countIt = tagCounts.find( lcaseTagName );
+				if( countIt == tagCounts.end() )
+					countIt = tagCounts.insert( std::make_pair( lcaseTagName, TagInfo() ) ).first;
+				countIt->second.add( tagName );
+			}
+		}
+
+		for( auto const& tagCount : tagCounts ) {
+			ReusableStringStream rss;
+			rss << "  " << std::setw(2) << tagCount.second.count << "  ";
+			auto str = rss.str();
+			auto wrapper = Column( tagCount.second.all() )
+				.initialIndent( 0 )
+				.indent( str.size() )
+				.width( CATCH_CONFIG_CONSOLE_WIDTH-10 );
+			Catch::cout() << str << wrapper << '\n';
+		}
+		Catch::cout() << pluralise( tagCounts.size(), "tag" ) << '\n' << std::endl;
+		return tagCounts.size();
+	}
 
-    Catch::IStream::~IStream() = default;
+	std::size_t listReporters() {
+		Catch::cout() << "Available reporters:\n";
+		IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
+		std::size_t maxNameLen = 0;
+		for( auto const& factoryKvp : factories )
+			maxNameLen = (std::max)( maxNameLen, factoryKvp.first.size() );
+
+		for( auto const& factoryKvp : factories ) {
+			Catch::cout()
+				<< Column( factoryKvp.first + ":" )
+				.indent(2)
+				.width( 5+maxNameLen )
+				+  Column( factoryKvp.second->getDescription() )
+				.initialIndent(0)
+				.indent(2)
+				.width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen-8 )
+				<< "\n";
+		}
+		Catch::cout() << std::endl;
+		return factories.size();
+	}
 
-    FileStream::FileStream( std::string const& filename ) {
-        m_ofs.open( filename.c_str() );
-        CATCH_ENFORCE( !m_ofs.fail(), "Unable to open file: '" << filename << "'" );
-    }
+	Option<std::size_t> list( Config const& config ) {
+		Option<std::size_t> listedCount;
+		if( config.listTests() )
+			listedCount = listedCount.valueOr(0) + listTests( config );
+		if( config.listTestNamesOnly() )
+			listedCount = listedCount.valueOr(0) + listTestsNamesOnly( config );
+		if( config.listTags() )
+			listedCount = listedCount.valueOr(0) + listTags( config );
+		if( config.listReporters() )
+			listedCount = listedCount.valueOr(0) + listReporters();
+		return listedCount;
+	}
 
-    std::ostream& FileStream::stream() const {
-        return m_ofs;
-    }
+} // end namespace Catch
+  // end catch_list.cpp
+  // start catch_matchers.cpp
 
-    struct OutputDebugWriter {
+namespace Catch {
+	namespace Matchers {
+		namespace Impl {
 
-        void operator()( std::string const&str ) {
-            writeToDebugConsole( str );
-        }
-    };
+			std::string MatcherUntypedBase::toString() const {
+				if( m_cachedToString.empty() )
+					m_cachedToString = describe();
+				return m_cachedToString;
+			}
 
-    DebugOutStream::DebugOutStream()
-    :   m_streamBuf( new StreamBufImpl<OutputDebugWriter>() ),
-        m_os( m_streamBuf.get() )
-    {}
+			MatcherUntypedBase::~MatcherUntypedBase() = default;
 
-    std::ostream& DebugOutStream::stream() const {
-        return m_os;
-    }
+		} // namespace Impl
+	} // namespace Matchers
 
-    // Store the streambuf from cout up-front because
-    // cout may get redirected when running tests
-    CoutStream::CoutStream()
-    :   m_os( Catch::cout().rdbuf() )
-    {}
+	using namespace Matchers;
+	using Matchers::Impl::MatcherBase;
 
-    std::ostream& CoutStream::stream() const {
-        return m_os;
-    }
+} // namespace Catch
+  // end catch_matchers.cpp
+  // start catch_matchers_floating.cpp
 
-#ifndef CATCH_CONFIG_NOSTDOUT // If you #define this you must implement these functions
-    std::ostream& cout() {
-        return std::cout;
-    }
-    std::ostream& cerr() {
-        return std::cerr;
-    }
-    std::ostream& clog() {
-        return std::clog;
-    }
-#endif
-}
-// end catch_stream.cpp
-// start catch_streambuf.cpp
+  // start catch_polyfills.hpp
 
 namespace Catch {
-    StreamBufBase::~StreamBufBase() = default;
+	bool isnan(float f);
+	bool isnan(double d);
 }
-// end catch_streambuf.cpp
-// start catch_string_manip.cpp
 
-#include <algorithm>
-#include <ostream>
-#include <cstring>
-#include <cctype>
+// end catch_polyfills.hpp
+// start catch_to_string.hpp
+
+#include <string>
 
 namespace Catch {
+	template <typename T>
+	std::string to_string(T const& t) {
+#if defined(CATCH_CONFIG_CPP11_TO_STRING)
+		return std::to_string(t);
+#else
+		ReusableStringStream rss;
+		rss << t;
+		return rss.str();
+#endif
+	}
+} // end namespace Catch
 
-    bool startsWith( std::string const& s, std::string const& prefix ) {
-        return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin());
-    }
-    bool startsWith( std::string const& s, char prefix ) {
-        return !s.empty() && s[0] == prefix;
-    }
-    bool endsWith( std::string const& s, std::string const& suffix ) {
-        return s.size() >= suffix.size() && std::equal(suffix.rbegin(), suffix.rend(), s.rbegin());
-    }
-    bool endsWith( std::string const& s, char suffix ) {
-        return !s.empty() && s[s.size()-1] == suffix;
-    }
-    bool contains( std::string const& s, std::string const& infix ) {
-        return s.find( infix ) != std::string::npos;
-    }
-    char toLowerCh(char c) {
-        return static_cast<char>( std::tolower( c ) );
-    }
-    void toLowerInPlace( std::string& s ) {
-        std::transform( s.begin(), s.end(), s.begin(), toLowerCh );
-    }
-    std::string toLower( std::string const& s ) {
-        std::string lc = s;
-        toLowerInPlace( lc );
-        return lc;
-    }
-    std::string trim( std::string const& str ) {
-        static char const* whitespaceChars = "\n\r\t ";
-        std::string::size_type start = str.find_first_not_of( whitespaceChars );
-        std::string::size_type end = str.find_last_not_of( whitespaceChars );
-
-        return start != std::string::npos ? str.substr( start, 1+end-start ) : std::string();
-    }
-
-    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
-        bool replaced = false;
-        std::size_t i = str.find( replaceThis );
-        while( i != std::string::npos ) {
-            replaced = true;
-            str = str.substr( 0, i ) + withThis + str.substr( i+replaceThis.size() );
-            if( i < str.size()-withThis.size() )
-                i = str.find( replaceThis, i+withThis.size() );
-            else
-                i = std::string::npos;
-        }
-        return replaced;
-    }
-
-    pluralise::pluralise( std::size_t count, std::string const& label )
-    :   m_count( count ),
-        m_label( label )
-    {}
-
-    std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
-        os << pluraliser.m_count << ' ' << pluraliser.m_label;
-        if( pluraliser.m_count != 1 )
-            os << 's';
-        return os;
-    }
+  // end catch_to_string.hpp
+#include <cstdlib>
+#include <cstdint>
+#include <cstring>
 
+namespace Catch {
+	namespace Matchers {
+		namespace Floating {
+			enum class FloatingPointKind : uint8_t {
+				Float,
+				Double
+			};
+		}
+	}
 }
-// end catch_string_manip.cpp
-// start catch_stringref.cpp
 
-#if defined(__clang__)
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wexit-time-destructors"
-#endif
+namespace {
 
-#include <ostream>
-#include <cassert>
-#include <cstring>
+	template <typename T>
+	struct Converter;
+
+	template <>
+	struct Converter<float> {
+		static_assert(sizeof(float) == sizeof(int32_t), "Important ULP matcher assumption violated");
+		Converter(float f) {
+			std::memcpy(&i, &f, sizeof(f));
+		}
+		int32_t i;
+	};
+
+	template <>
+	struct Converter<double> {
+		static_assert(sizeof(double) == sizeof(int64_t), "Important ULP matcher assumption violated");
+		Converter(double d) {
+			std::memcpy(&i, &d, sizeof(d));
+		}
+		int64_t i;
+	};
+
+	template <typename T>
+	auto convert(T t) -> Converter<T> {
+		return Converter<T>(t);
+	}
 
-namespace Catch {
+	template <typename FP>
+	bool almostEqualUlps(FP lhs, FP rhs, int maxUlpDiff) {
+		// Comparison with NaN should always be false.
+		// This way we can rule it out before getting into the ugly details
+		if (Catch::isnan(lhs) || Catch::isnan(rhs)) {
+			return false;
+		}
 
-    auto getEmptyStringRef() -> StringRef {
-        static StringRef s_emptyStringRef("");
-        return s_emptyStringRef;
-    }
-
-    StringRef::StringRef() noexcept
-    :   StringRef( getEmptyStringRef() )
-    {}
-
-    StringRef::StringRef( StringRef const& other ) noexcept
-    :   m_start( other.m_start ),
-        m_size( other.m_size )
-    {}
-
-    StringRef::StringRef( StringRef&& other ) noexcept
-    :   m_start( other.m_start ),
-        m_size( other.m_size ),
-        m_data( other.m_data )
-    {
-        other.m_data = nullptr;
-    }
-
-    StringRef::StringRef( char const* rawChars ) noexcept
-    :   m_start( rawChars ),
-        m_size( static_cast<size_type>( std::strlen( rawChars ) ) )
-    {
-        assert( rawChars != nullptr );
-    }
-
-    StringRef::StringRef( char const* rawChars, size_type size ) noexcept
-    :   m_start( rawChars ),
-        m_size( size )
-    {
-        size_type rawSize = rawChars == nullptr ? 0 : static_cast<size_type>( std::strlen( rawChars ) );
-        if( rawSize < size )
-            m_size = rawSize;
-    }
-
-    StringRef::StringRef( std::string const& stdString ) noexcept
-    :   m_start( stdString.c_str() ),
-        m_size( stdString.size() )
-    {}
-
-    StringRef::~StringRef() noexcept {
-        delete[] m_data;
-    }
-
-    auto StringRef::operator = ( StringRef other ) noexcept -> StringRef& {
-        swap( other );
-        return *this;
-    }
-    StringRef::operator std::string() const {
-        return std::string( m_start, m_size );
-    }
-
-    void StringRef::swap( StringRef& other ) noexcept {
-        std::swap( m_start, other.m_start );
-        std::swap( m_size, other.m_size );
-        std::swap( m_data, other.m_data );
-    }
-
-    auto StringRef::c_str() const -> char const* {
-        if( isSubstring() )
-           const_cast<StringRef*>( this )->takeOwnership();
-        return m_start;
-    }
-    auto StringRef::data() const noexcept -> char const* {
-        return m_start;
-    }
-
-    auto StringRef::isOwned() const noexcept -> bool {
-        return m_data != nullptr;
-    }
-    auto StringRef::isSubstring() const noexcept -> bool {
-        return m_start[m_size] != '\0';
-    }
-
-    void StringRef::takeOwnership() {
-        if( !isOwned() ) {
-            m_data = new char[m_size+1];
-            memcpy( m_data, m_start, m_size );
-            m_data[m_size] = '\0';
-            m_start = m_data;
-        }
-    }
-    auto StringRef::substr( size_type start, size_type size ) const noexcept -> StringRef {
-        if( start < m_size )
-            return StringRef( m_start+start, size );
-        else
-            return StringRef();
-    }
-    auto StringRef::operator == ( StringRef const& other ) const noexcept -> bool {
-        return
-            size() == other.size() &&
-            (std::strncmp( m_start, other.m_start, size() ) == 0);
-    }
-    auto StringRef::operator != ( StringRef const& other ) const noexcept -> bool {
-        return !operator==( other );
-    }
-
-    auto StringRef::operator[](size_type index) const noexcept -> char {
-        return m_start[index];
-    }
-
-    auto StringRef::empty() const noexcept -> bool {
-        return m_size == 0;
-    }
-
-    auto StringRef::size() const noexcept -> size_type {
-        return m_size;
-    }
-    auto StringRef::numberOfCharacters() const noexcept -> size_type {
-        size_type noChars = m_size;
-        // Make adjustments for uft encodings
-        for( size_type i=0; i < m_size; ++i ) {
-            char c = m_start[i];
-            if( ( c & 0b11000000 ) == 0b11000000 ) {
-                if( ( c & 0b11100000 ) == 0b11000000 )
-                    noChars--;
-                else if( ( c & 0b11110000 ) == 0b11100000 )
-                    noChars-=2;
-                else if( ( c & 0b11111000 ) == 0b11110000 )
-                    noChars-=3;
-            }
-        }
-        return noChars;
-    }
-
-    auto operator + ( StringRef const& lhs, StringRef const& rhs ) -> std::string {
-        std::string str;
-        str.reserve( lhs.size() + rhs.size() );
-        str += lhs;
-        str += rhs;
-        return str;
-    }
-    auto operator + ( StringRef const& lhs, const char* rhs ) -> std::string {
-        return std::string( lhs ) + std::string( rhs );
-    }
-    auto operator + ( char const* lhs, StringRef const& rhs ) -> std::string {
-        return std::string( lhs ) + std::string( rhs );
-    }
-
-    auto operator << ( std::ostream& os, StringRef const& str ) -> std::ostream& {
-        return os << str.c_str();
-    }
+		auto lc = convert(lhs);
+		auto rc = convert(rhs);
 
-} // namespace Catch
+		if ((lc.i < 0) != (rc.i < 0)) {
+			// Potentially we can have +0 and -0
+			return lhs == rhs;
+		}
 
-#if defined(__clang__)
-#    pragma clang diagnostic pop
-#endif
-// end catch_stringref.cpp
-// start catch_tag_alias.cpp
+		auto ulpDiff = std::abs(lc.i - rc.i);
+		return ulpDiff <= maxUlpDiff;
+	}
 
-namespace Catch {
-    TagAlias::TagAlias(std::string const & _tag, SourceLineInfo _lineInfo): tag(_tag), lineInfo(_lineInfo) {}
 }
-// end catch_tag_alias.cpp
-// start catch_tag_alias_autoregistrar.cpp
 
 namespace Catch {
+	namespace Matchers {
+		namespace Floating {
+			WithinAbsMatcher::WithinAbsMatcher(double target, double margin)
+				:m_target{ target }, m_margin{ margin } {
+				CATCH_ENFORCE(margin >= 0, "Invalid margin: " << margin << '.'
+					<< " Margin has to be non-negative.");
+			}
 
-    RegistrarForTagAliases::RegistrarForTagAliases(char const* alias, char const* tag, SourceLineInfo const& lineInfo) {
-        try {
-            getMutableRegistryHub().registerTagAlias(alias, tag, lineInfo);
-        } catch (...) {
-            // Do not throw when constructing global objects, instead register the exception to be processed later
-            getMutableRegistryHub().registerStartupException();
-        }
-    }
+			// Performs equivalent check of std::fabs(lhs - rhs) <= margin
+			// But without the subtraction to allow for INFINITY in comparison
+			bool WithinAbsMatcher::match(double const& matchee) const {
+				return (matchee + m_margin >= m_target) && (m_target + m_margin >= matchee);
+			}
 
-}
-// end catch_tag_alias_autoregistrar.cpp
-// start catch_tag_alias_registry.cpp
+			std::string WithinAbsMatcher::describe() const {
+				return "is within " + ::Catch::Detail::stringify(m_margin) + " of " + ::Catch::Detail::stringify(m_target);
+			}
 
-namespace Catch {
+			WithinUlpsMatcher::WithinUlpsMatcher(double target, int ulps, FloatingPointKind baseType)
+				:m_target{ target }, m_ulps{ ulps }, m_type{ baseType } {
+				CATCH_ENFORCE(ulps >= 0, "Invalid ULP setting: " << ulps << '.'
+					<< " ULPs have to be non-negative.");
+			}
 
-    TagAliasRegistry::~TagAliasRegistry() {}
+#if defined(__clang__)
+#pragma clang diagnostic push
+			// Clang <3.5 reports on the default branch in the switch below
+#pragma clang diagnostic ignored "-Wunreachable-code"
+#endif
 
-    TagAlias const* TagAliasRegistry::find( std::string const& alias ) const {
-        auto it = m_registry.find( alias );
-        if( it != m_registry.end() )
-            return &(it->second);
-        else
-            return nullptr;
-    }
+			bool WithinUlpsMatcher::match(double const& matchee) const {
+				switch (m_type) {
+				case FloatingPointKind::Float:
+					return almostEqualUlps<float>(static_cast<float>(matchee), static_cast<float>(m_target), m_ulps);
+				case FloatingPointKind::Double:
+					return almostEqualUlps<double>(matchee, m_target, m_ulps);
+				default:
+					CATCH_INTERNAL_ERROR( "Unknown FloatingPointKind value" );
+				}
+			}
 
-    std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
-        std::string expandedTestSpec = unexpandedTestSpec;
-        for( auto const& registryKvp : m_registry ) {
-            std::size_t pos = expandedTestSpec.find( registryKvp.first );
-            if( pos != std::string::npos ) {
-                expandedTestSpec =  expandedTestSpec.substr( 0, pos ) +
-                                    registryKvp.second.tag +
-                                    expandedTestSpec.substr( pos + registryKvp.first.size() );
-            }
-        }
-        return expandedTestSpec;
-    }
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
 
-    void TagAliasRegistry::add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) {
-        CATCH_ENFORCE( startsWith(alias, "[@") && endsWith(alias, ']'),
-                      "error: tag alias, '" << alias << "' is not of the form [@alias name].\n" << lineInfo );
+			std::string WithinUlpsMatcher::describe() const {
+				return "is within " + Catch::to_string(m_ulps) + " ULPs of " + ::Catch::Detail::stringify(m_target) + ((m_type == FloatingPointKind::Float)? "f" : "");
+			}
 
-        CATCH_ENFORCE( m_registry.insert(std::make_pair(alias, TagAlias(tag, lineInfo))).second,
-                      "error: tag alias, '" << alias << "' already registered.\n"
-                      << "\tFirst seen at: " << find(alias)->lineInfo << "\n"
-                      << "\tRedefined at: " << lineInfo );
-    }
+		}// namespace Floating
 
-    ITagAliasRegistry::~ITagAliasRegistry() {}
+		Floating::WithinUlpsMatcher WithinULP(double target, int maxUlpDiff) {
+			return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Double);
+		}
 
-    ITagAliasRegistry const& ITagAliasRegistry::get() {
-        return getRegistryHub().getTagAliasRegistry();
-    }
+		Floating::WithinUlpsMatcher WithinULP(float target, int maxUlpDiff) {
+			return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Float);
+		}
 
-} // end namespace Catch
-// end catch_tag_alias_registry.cpp
-// start catch_test_case_info.cpp
+		Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
+			return Floating::WithinAbsMatcher(target, margin);
+		}
 
-#include <cctype>
+	} // namespace Matchers
+} // namespace Catch
+
+  // end catch_matchers_floating.cpp
+  // start catch_matchers_generic.cpp
+
+std::string Catch::Matchers::Generic::Detail::finalizeDescription(const std::string& desc) {
+	if (desc.empty()) {
+		return "matches undescribed predicate";
+	} else {
+		return "matches predicate: \"" + desc + '"';
+	}
+}
+// end catch_matchers_generic.cpp
+// start catch_matchers_string.cpp
+
+#include <regex>
+
+namespace Catch {
+	namespace Matchers {
+
+		namespace StdString {
+
+			CasedString::CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity )
+				:   m_caseSensitivity( caseSensitivity ),
+				m_str( adjustString( str ) )
+			{}
+			std::string CasedString::adjustString( std::string const& str ) const {
+				return m_caseSensitivity == CaseSensitive::No
+					? toLower( str )
+					: str;
+			}
+			std::string CasedString::caseSensitivitySuffix() const {
+				return m_caseSensitivity == CaseSensitive::No
+					? " (case insensitive)"
+					: std::string();
+			}
+
+			StringMatcherBase::StringMatcherBase( std::string const& operation, CasedString const& comparator )
+				: m_comparator( comparator ),
+				m_operation( operation ) {
+			}
+
+			std::string StringMatcherBase::describe() const {
+				std::string description;
+				description.reserve(5 + m_operation.size() + m_comparator.m_str.size() +
+					m_comparator.caseSensitivitySuffix().size());
+				description += m_operation;
+				description += ": \"";
+				description += m_comparator.m_str;
+				description += "\"";
+				description += m_comparator.caseSensitivitySuffix();
+				return description;
+			}
+
+			EqualsMatcher::EqualsMatcher( CasedString const& comparator ) : StringMatcherBase( "equals", comparator ) {}
+
+			bool EqualsMatcher::match( std::string const& source ) const {
+				return m_comparator.adjustString( source ) == m_comparator.m_str;
+			}
+
+			ContainsMatcher::ContainsMatcher( CasedString const& comparator ) : StringMatcherBase( "contains", comparator ) {}
+
+			bool ContainsMatcher::match( std::string const& source ) const {
+				return contains( m_comparator.adjustString( source ), m_comparator.m_str );
+			}
+
+			StartsWithMatcher::StartsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "starts with", comparator ) {}
+
+			bool StartsWithMatcher::match( std::string const& source ) const {
+				return startsWith( m_comparator.adjustString( source ), m_comparator.m_str );
+			}
+
+			EndsWithMatcher::EndsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "ends with", comparator ) {}
+
+			bool EndsWithMatcher::match( std::string const& source ) const {
+				return endsWith( m_comparator.adjustString( source ), m_comparator.m_str );
+			}
+
+			RegexMatcher::RegexMatcher(std::string regex, CaseSensitive::Choice caseSensitivity): m_regex(std::move(regex)), m_caseSensitivity(caseSensitivity) {}
+
+			bool RegexMatcher::match(std::string const& matchee) const {
+				auto flags = std::regex::ECMAScript; // ECMAScript is the default syntax option anyway
+				if (m_caseSensitivity == CaseSensitive::Choice::No) {
+					flags |= std::regex::icase;
+				}
+				auto reg = std::regex(m_regex, flags);
+				return std::regex_match(matchee, reg);
+			}
+
+			std::string RegexMatcher::describe() const {
+				return "matches " + ::Catch::Detail::stringify(m_regex) + ((m_caseSensitivity == CaseSensitive::Choice::Yes)? " case sensitively" : " case insensitively");
+			}
+
+		} // namespace StdString
+
+		StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+			return StdString::EqualsMatcher( StdString::CasedString( str, caseSensitivity) );
+		}
+		StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+			return StdString::ContainsMatcher( StdString::CasedString( str, caseSensitivity) );
+		}
+		StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+			return StdString::EndsWithMatcher( StdString::CasedString( str, caseSensitivity) );
+		}
+		StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+			return StdString::StartsWithMatcher( StdString::CasedString( str, caseSensitivity) );
+		}
+
+		StdString::RegexMatcher Matches(std::string const& regex, CaseSensitive::Choice caseSensitivity) {
+			return StdString::RegexMatcher(regex, caseSensitivity);
+		}
+
+	} // namespace Matchers
+} // namespace Catch
+  // end catch_matchers_string.cpp
+  // start catch_message.cpp
+
+  // start catch_uncaught_exceptions.h
+
+namespace Catch {
+	bool uncaught_exceptions();
+} // end namespace Catch
+
+  // end catch_uncaught_exceptions.h
+#include <cassert>
+#include <stack>
+
+namespace Catch {
+
+	MessageInfo::MessageInfo(   StringRef const& _macroName,
+		SourceLineInfo const& _lineInfo,
+		ResultWas::OfType _type )
+		:   macroName( _macroName ),
+		lineInfo( _lineInfo ),
+		type( _type ),
+		sequence( ++globalCount )
+	{}
+
+	bool MessageInfo::operator==( MessageInfo const& other ) const {
+		return sequence == other.sequence;
+	}
+
+	bool MessageInfo::operator<( MessageInfo const& other ) const {
+		return sequence < other.sequence;
+	}
+
+	// This may need protecting if threading support is added
+	unsigned int MessageInfo::globalCount = 0;
+
+	////////////////////////////////////////////////////////////////////////////
+
+	Catch::MessageBuilder::MessageBuilder( StringRef const& macroName,
+		SourceLineInfo const& lineInfo,
+		ResultWas::OfType type )
+		:m_info(macroName, lineInfo, type) {}
+
+	////////////////////////////////////////////////////////////////////////////
+
+	ScopedMessage::ScopedMessage( MessageBuilder const& builder )
+		: m_info( builder.m_info )
+	{
+		m_info.message = builder.m_stream.str();
+		getResultCapture().pushScopedMessage( m_info );
+	}
+
+	ScopedMessage::~ScopedMessage() {
+		if ( !uncaught_exceptions() ){
+			getResultCapture().popScopedMessage(m_info);
+		}
+	}
+
+	Capturer::Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names ) {
+		auto trimmed = [&] (size_t start, size_t end) {
+			while (names[start] == ',' || isspace(names[start])) {
+				++start;
+			}
+			while (names[end] == ',' || isspace(names[end])) {
+				--end;
+			}
+			return names.substr(start, end - start + 1);
+		};
+
+		size_t start = 0;
+		std::stack<char> openings;
+		for (size_t pos = 0; pos < names.size(); ++pos) {
+			char c = names[pos];
+			switch (c) {
+			case '[':
+			case '{':
+			case '(':
+				// It is basically impossible to disambiguate between
+				// comparison and start of template args in this context
+				//            case '<':
+				openings.push(c);
+				break;
+			case ']':
+			case '}':
+			case ')':
+				//           case '>':
+				openings.pop();
+				break;
+			case ',':
+				if (start != pos && openings.size() == 0) {
+					m_messages.emplace_back(macroName, lineInfo, resultType);
+					m_messages.back().message = trimmed(start, pos);
+					m_messages.back().message += " := ";
+					start = pos;
+				}
+			}
+		}
+		assert(openings.size() == 0 && "Mismatched openings");
+		m_messages.emplace_back(macroName, lineInfo, resultType);
+		m_messages.back().message = trimmed(start, names.size() - 1);
+		m_messages.back().message += " := ";
+	}
+	Capturer::~Capturer() {
+		if ( !uncaught_exceptions() ){
+			assert( m_captured == m_messages.size() );
+			for( size_t i = 0; i < m_captured; ++i  )
+				m_resultCapture.popScopedMessage( m_messages[i] );
+		}
+	}
+
+	void Capturer::captureValue( size_t index, std::string const& value ) {
+		assert( index < m_messages.size() );
+		m_messages[index].message += value;
+		m_resultCapture.pushScopedMessage( m_messages[index] );
+		m_captured++;
+	}
+
+} // end namespace Catch
+  // end catch_message.cpp
+  // start catch_output_redirect.cpp
+
+  // start catch_output_redirect.h
+#ifndef TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
+#define TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
+
+#include <cstdio>
+#include <iosfwd>
+#include <string>
+
+namespace Catch {
+
+	class RedirectedStream {
+		std::ostream& m_originalStream;
+		std::ostream& m_redirectionStream;
+		std::streambuf* m_prevBuf;
+
+	public:
+		RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream );
+		~RedirectedStream();
+	};
+
+	class RedirectedStdOut {
+		ReusableStringStream m_rss;
+		RedirectedStream m_cout;
+	public:
+		RedirectedStdOut();
+		auto str() const -> std::string;
+	};
+
+	// StdErr has two constituent streams in C++, std::cerr and std::clog
+	// This means that we need to redirect 2 streams into 1 to keep proper
+	// order of writes
+	class RedirectedStdErr {
+		ReusableStringStream m_rss;
+		RedirectedStream m_cerr;
+		RedirectedStream m_clog;
+	public:
+		RedirectedStdErr();
+		auto str() const -> std::string;
+	};
+
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+
+	// Windows's implementation of std::tmpfile is terrible (it tries
+	// to create a file inside system folder, thus requiring elevated
+	// privileges for the binary), so we have to use tmpnam(_s) and
+	// create the file ourselves there.
+	class TempFile {
+	public:
+		TempFile(TempFile const&) = delete;
+		TempFile& operator=(TempFile const&) = delete;
+		TempFile(TempFile&&) = delete;
+		TempFile& operator=(TempFile&&) = delete;
+
+		TempFile();
+		~TempFile();
+
+		std::FILE* getFile();
+		std::string getContents();
+
+	private:
+		std::FILE* m_file = nullptr;
+#if defined(_MSC_VER)
+		char m_buffer[L_tmpnam] = { 0 };
+#endif
+	};
+
+	class OutputRedirect {
+	public:
+		OutputRedirect(OutputRedirect const&) = delete;
+		OutputRedirect& operator=(OutputRedirect const&) = delete;
+		OutputRedirect(OutputRedirect&&) = delete;
+		OutputRedirect& operator=(OutputRedirect&&) = delete;
+
+		OutputRedirect(std::string& stdout_dest, std::string& stderr_dest);
+		~OutputRedirect();
+
+	private:
+		int m_originalStdout = -1;
+		int m_originalStderr = -1;
+		TempFile m_stdoutFile;
+		TempFile m_stderrFile;
+		std::string& m_stdoutDest;
+		std::string& m_stderrDest;
+	};
+
+#endif
+
+} // end namespace Catch
+
+#endif // TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
+  // end catch_output_redirect.h
+#include <cstdio>
+#include <cstring>
+#include <fstream>
+#include <sstream>
+#include <stdexcept>
+
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+#if defined(_MSC_VER)
+#include <io.h>      //_dup and _dup2
+#define dup _dup
+#define dup2 _dup2
+#define fileno _fileno
+#else
+#include <unistd.h>  // dup and dup2
+#endif
+#endif
+
+namespace Catch {
+
+	RedirectedStream::RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream )
+		:   m_originalStream( originalStream ),
+		m_redirectionStream( redirectionStream ),
+		m_prevBuf( m_originalStream.rdbuf() )
+	{
+		m_originalStream.rdbuf( m_redirectionStream.rdbuf() );
+	}
+
+	RedirectedStream::~RedirectedStream() {
+		m_originalStream.rdbuf( m_prevBuf );
+	}
+
+	RedirectedStdOut::RedirectedStdOut() : m_cout( Catch::cout(), m_rss.get() ) {}
+	auto RedirectedStdOut::str() const -> std::string { return m_rss.str(); }
+
+	RedirectedStdErr::RedirectedStdErr()
+		:   m_cerr( Catch::cerr(), m_rss.get() ),
+		m_clog( Catch::clog(), m_rss.get() )
+	{}
+	auto RedirectedStdErr::str() const -> std::string { return m_rss.str(); }
+
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+
+#if defined(_MSC_VER)
+	TempFile::TempFile() {
+		if (tmpnam_s(m_buffer)) {
+			CATCH_RUNTIME_ERROR("Could not get a temp filename");
+		}
+		if (fopen_s(&m_file, m_buffer, "w")) {
+			char buffer[100];
+			if (strerror_s(buffer, errno)) {
+				CATCH_RUNTIME_ERROR("Could not translate errno to a string");
+			}
+			CATCH_RUNTIME_ERROR("Coul dnot open the temp file: '" << m_buffer << "' because: " << buffer);
+		}
+	}
+#else
+	TempFile::TempFile() {
+		m_file = std::tmpfile();
+		if (!m_file) {
+			CATCH_RUNTIME_ERROR("Could not create a temp file.");
+		}
+	}
+
+#endif
+
+	TempFile::~TempFile() {
+		// TBD: What to do about errors here?
+		std::fclose(m_file);
+		// We manually create the file on Windows only, on Linux
+		// it will be autodeleted
+#if defined(_MSC_VER)
+		std::remove(m_buffer);
+#endif
+	}
+
+	FILE* TempFile::getFile() {
+		return m_file;
+	}
+
+	std::string TempFile::getContents() {
+		std::stringstream sstr;
+		char buffer[100] = {};
+		std::rewind(m_file);
+		while (std::fgets(buffer, sizeof(buffer), m_file)) {
+			sstr << buffer;
+		}
+		return sstr.str();
+	}
+
+	OutputRedirect::OutputRedirect(std::string& stdout_dest, std::string& stderr_dest) :
+		m_originalStdout(dup(1)),
+		m_originalStderr(dup(2)),
+		m_stdoutDest(stdout_dest),
+		m_stderrDest(stderr_dest) {
+		dup2(fileno(m_stdoutFile.getFile()), 1);
+		dup2(fileno(m_stderrFile.getFile()), 2);
+	}
+
+	OutputRedirect::~OutputRedirect() {
+		Catch::cout() << std::flush;
+		fflush(stdout);
+		// Since we support overriding these streams, we flush cerr
+		// even though std::cerr is unbuffered
+		Catch::cerr() << std::flush;
+		Catch::clog() << std::flush;
+		fflush(stderr);
+
+		dup2(m_originalStdout, 1);
+		dup2(m_originalStderr, 2);
+
+		m_stdoutDest += m_stdoutFile.getContents();
+		m_stderrDest += m_stderrFile.getContents();
+	}
+
+#endif // CATCH_CONFIG_NEW_CAPTURE
+
+} // namespace Catch
+
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+#if defined(_MSC_VER)
+#undef dup
+#undef dup2
+#undef fileno
+#endif
+#endif
+  // end catch_output_redirect.cpp
+  // start catch_polyfills.cpp
+
+#include <cmath>
+
+namespace Catch {
+
+#if !defined(CATCH_CONFIG_POLYFILL_ISNAN)
+	bool isnan(float f) {
+		return std::isnan(f);
+	}
+	bool isnan(double d) {
+		return std::isnan(d);
+	}
+#else
+	// For now we only use this for embarcadero
+	bool isnan(float f) {
+		return std::_isnan(f);
+	}
+	bool isnan(double d) {
+		return std::_isnan(d);
+	}
+#endif
+
+} // end namespace Catch
+  // end catch_polyfills.cpp
+  // start catch_random_number_generator.cpp
+
+namespace Catch {
+
+	std::mt19937& rng() {
+		static std::mt19937 s_rng;
+		return s_rng;
+	}
+
+	void seedRng( IConfig const& config ) {
+		if( config.rngSeed() != 0 ) {
+			std::srand( config.rngSeed() );
+			rng().seed( config.rngSeed() );
+		}
+	}
+
+	unsigned int rngSeed() {
+		return getCurrentContext().getConfig()->rngSeed();
+	}
+}
+// end catch_random_number_generator.cpp
+// start catch_registry_hub.cpp
+
+// start catch_test_case_registry_impl.h
+
+#include <vector>
+#include <set>
+#include <algorithm>
+#include <ios>
+
+namespace Catch {
+
+	class TestCase;
+	struct IConfig;
+
+	std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases );
+	bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
+
+	void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions );
+
+	std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
+	std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
+
+	class TestRegistry : public ITestCaseRegistry {
+	public:
+		virtual ~TestRegistry() = default;
+
+		virtual void registerTest( TestCase const& testCase );
+
+		std::vector<TestCase> const& getAllTests() const override;
+		std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const override;
+
+	private:
+		std::vector<TestCase> m_functions;
+		mutable RunTests::InWhatOrder m_currentSortOrder = RunTests::InDeclarationOrder;
+		mutable std::vector<TestCase> m_sortedFunctions;
+		std::size_t m_unnamedCount = 0;
+		std::ios_base::Init m_ostreamInit; // Forces cout/ cerr to be initialised
+	};
+
+	///////////////////////////////////////////////////////////////////////////
+
+	class TestInvokerAsFunction : public ITestInvoker {
+		void(*m_testAsFunction)();
+	public:
+		TestInvokerAsFunction( void(*testAsFunction)() ) noexcept;
+
+		void invoke() const override;
+	};
+
+	std::string extractClassName( StringRef const& classOrQualifiedMethodName );
+
+	///////////////////////////////////////////////////////////////////////////
+
+} // end namespace Catch
+
+  // end catch_test_case_registry_impl.h
+  // start catch_reporter_registry.h
+
+#include <map>
+
+namespace Catch {
+
+	class ReporterRegistry : public IReporterRegistry {
+
+	public:
+
+		~ReporterRegistry() override;
+
+		IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const override;
+
+		void registerReporter( std::string const& name, IReporterFactoryPtr const& factory );
+		void registerListener( IReporterFactoryPtr const& factory );
+
+		FactoryMap const& getFactories() const override;
+		Listeners const& getListeners() const override;
+
+	private:
+		FactoryMap m_factories;
+		Listeners m_listeners;
+	};
+}
+
+// end catch_reporter_registry.h
+// start catch_tag_alias_registry.h
+
+// start catch_tag_alias.h
+
+#include <string>
+
+namespace Catch {
+
+	struct TagAlias {
+		TagAlias(std::string const& _tag, SourceLineInfo _lineInfo);
+
+		std::string tag;
+		SourceLineInfo lineInfo;
+	};
+
+} // end namespace Catch
+
+  // end catch_tag_alias.h
+#include <map>
+
+namespace Catch {
+
+	class TagAliasRegistry : public ITagAliasRegistry {
+	public:
+		~TagAliasRegistry() override;
+		TagAlias const* find( std::string const& alias ) const override;
+		std::string expandAliases( std::string const& unexpandedTestSpec ) const override;
+		void add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo );
+
+	private:
+		std::map<std::string, TagAlias> m_registry;
+	};
+
+} // end namespace Catch
+
+  // end catch_tag_alias_registry.h
+  // start catch_startup_exception_registry.h
+
+#include <vector>
 #include <exception>
+
+namespace Catch {
+
+	class StartupExceptionRegistry {
+	public:
+		void add(std::exception_ptr const& exception) noexcept;
+		std::vector<std::exception_ptr> const& getExceptions() const noexcept;
+	private:
+		std::vector<std::exception_ptr> m_exceptions;
+	};
+
+} // end namespace Catch
+
+  // end catch_startup_exception_registry.h
+  // start catch_singletons.hpp
+
+namespace Catch {
+
+	struct ISingleton {
+		virtual ~ISingleton();
+	};
+
+	void addSingleton( ISingleton* singleton );
+	void cleanupSingletons();
+
+	template<typename SingletonImplT, typename InterfaceT = SingletonImplT, typename MutableInterfaceT = InterfaceT>
+	class Singleton : SingletonImplT, public ISingleton {
+
+		static auto getInternal() -> Singleton* {
+			static Singleton* s_instance = nullptr;
+			if( !s_instance ) {
+				s_instance = new Singleton;
+				addSingleton( s_instance );
+			}
+			return s_instance;
+		}
+
+	public:
+		static auto get() -> InterfaceT const& {
+			return *getInternal();
+		}
+		static auto getMutable() -> MutableInterfaceT& {
+			return *getInternal();
+		}
+	};
+
+} // namespace Catch
+
+  // end catch_singletons.hpp
+namespace Catch {
+
+	namespace {
+
+		class RegistryHub : public IRegistryHub, public IMutableRegistryHub,
+			private NonCopyable {
+
+		public: // IRegistryHub
+			RegistryHub() = default;
+			IReporterRegistry const& getReporterRegistry() const override {
+				return m_reporterRegistry;
+			}
+			ITestCaseRegistry const& getTestCaseRegistry() const override {
+				return m_testCaseRegistry;
+			}
+			IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const override {
+				return m_exceptionTranslatorRegistry;
+			}
+			ITagAliasRegistry const& getTagAliasRegistry() const override {
+				return m_tagAliasRegistry;
+			}
+			StartupExceptionRegistry const& getStartupExceptionRegistry() const override {
+				return m_exceptionRegistry;
+			}
+
+		public: // IMutableRegistryHub
+			void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) override {
+				m_reporterRegistry.registerReporter( name, factory );
+			}
+			void registerListener( IReporterFactoryPtr const& factory ) override {
+				m_reporterRegistry.registerListener( factory );
+			}
+			void registerTest( TestCase const& testInfo ) override {
+				m_testCaseRegistry.registerTest( testInfo );
+			}
+			void registerTranslator( const IExceptionTranslator* translator ) override {
+				m_exceptionTranslatorRegistry.registerTranslator( translator );
+			}
+			void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) override {
+				m_tagAliasRegistry.add( alias, tag, lineInfo );
+			}
+			void registerStartupException() noexcept override {
+				m_exceptionRegistry.add(std::current_exception());
+			}
+
+		private:
+			TestRegistry m_testCaseRegistry;
+			ReporterRegistry m_reporterRegistry;
+			ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
+			TagAliasRegistry m_tagAliasRegistry;
+			StartupExceptionRegistry m_exceptionRegistry;
+		};
+	}
+
+	using RegistryHubSingleton = Singleton<RegistryHub, IRegistryHub, IMutableRegistryHub>;
+
+	IRegistryHub const& getRegistryHub() {
+		return RegistryHubSingleton::get();
+	}
+	IMutableRegistryHub& getMutableRegistryHub() {
+		return RegistryHubSingleton::getMutable();
+	}
+	void cleanUp() {
+		cleanupSingletons();
+		cleanUpContext();
+	}
+	std::string translateActiveException() {
+		return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
+	}
+
+} // end namespace Catch
+  // end catch_registry_hub.cpp
+  // start catch_reporter_registry.cpp
+
+namespace Catch {
+
+	ReporterRegistry::~ReporterRegistry() = default;
+
+	IStreamingReporterPtr ReporterRegistry::create( std::string const& name, IConfigPtr const& config ) const {
+		auto it =  m_factories.find( name );
+		if( it == m_factories.end() )
+			return nullptr;
+		return it->second->create( ReporterConfig( config ) );
+	}
+
+	void ReporterRegistry::registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) {
+		m_factories.emplace(name, factory);
+	}
+	void ReporterRegistry::registerListener( IReporterFactoryPtr const& factory ) {
+		m_listeners.push_back( factory );
+	}
+
+	IReporterRegistry::FactoryMap const& ReporterRegistry::getFactories() const {
+		return m_factories;
+	}
+	IReporterRegistry::Listeners const& ReporterRegistry::getListeners() const {
+		return m_listeners;
+	}
+
+}
+// end catch_reporter_registry.cpp
+// start catch_result_type.cpp
+
+namespace Catch {
+
+	bool isOk( ResultWas::OfType resultType ) {
+		return ( resultType & ResultWas::FailureBit ) == 0;
+	}
+	bool isJustInfo( int flags ) {
+		return flags == ResultWas::Info;
+	}
+
+	ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) {
+		return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) | static_cast<int>( rhs ) );
+	}
+
+	bool shouldContinueOnFailure( int flags )    { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }
+	bool shouldSuppressFailure( int flags )      { return ( flags & ResultDisposition::SuppressFail ) != 0; }
+
+} // end namespace Catch
+  // end catch_result_type.cpp
+  // start catch_run_context.cpp
+
+#include <cassert>
 #include <algorithm>
+#include <sstream>
 
 namespace Catch {
 
-    TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
-        if( startsWith( tag, '.' ) ||
-            tag == "!hide" )
-            return TestCaseInfo::IsHidden;
-        else if( tag == "!throws" )
-            return TestCaseInfo::Throws;
-        else if( tag == "!shouldfail" )
-            return TestCaseInfo::ShouldFail;
-        else if( tag == "!mayfail" )
-            return TestCaseInfo::MayFail;
-        else if( tag == "!nonportable" )
-            return TestCaseInfo::NonPortable;
-        else if( tag == "!benchmark" )
-            return static_cast<TestCaseInfo::SpecialProperties>( TestCaseInfo::Benchmark | TestCaseInfo::IsHidden );
-        else
-            return TestCaseInfo::None;
-    }
-    bool isReservedTag( std::string const& tag ) {
-        return parseSpecialTag( tag ) == TestCaseInfo::None && tag.size() > 0 && !std::isalnum( tag[0] );
-    }
-    void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
-        CATCH_ENFORCE( !isReservedTag(tag),
-                      "Tag name: [" << tag << "] is not allowed.\n"
-                      << "Tag names starting with non alpha-numeric characters are reserved\n"
-                      << _lineInfo );
-    }
-
-    TestCase makeTestCase(  ITestInvoker* _testCase,
-                            std::string const& _className,
-                            std::string const& _name,
-                            std::string const& _descOrTags,
-                            SourceLineInfo const& _lineInfo )
-    {
-        bool isHidden = false;
-
-        // Parse out tags
-        std::vector<std::string> tags;
-        std::string desc, tag;
-        bool inTag = false;
-        for (char c : _descOrTags) {
-            if( !inTag ) {
-                if( c == '[' )
-                    inTag = true;
-                else
-                    desc += c;
-            }
-            else {
-                if( c == ']' ) {
-                    TestCaseInfo::SpecialProperties prop = parseSpecialTag( tag );
-                    if( ( prop & TestCaseInfo::IsHidden ) != 0 )
-                        isHidden = true;
-                    else if( prop == TestCaseInfo::None )
-                        enforceNotReservedTag( tag, _lineInfo );
-
-                    tags.push_back( tag );
-                    tag.clear();
-                    inTag = false;
-                }
-                else
-                    tag += c;
-            }
-        }
-        if( isHidden ) {
-            tags.push_back( "." );
-        }
-
-        TestCaseInfo info( _name, _className, desc, tags, _lineInfo );
-        return TestCase( _testCase, info );
-    }
-
-    void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags ) {
-        std::sort(begin(tags), end(tags));
-        tags.erase(std::unique(begin(tags), end(tags)), end(tags));
-        testCaseInfo.lcaseTags.clear();
-
-        for( auto const& tag : tags ) {
-            std::string lcaseTag = toLower( tag );
-            testCaseInfo.properties = static_cast<TestCaseInfo::SpecialProperties>( testCaseInfo.properties | parseSpecialTag( lcaseTag ) );
-            testCaseInfo.lcaseTags.push_back( lcaseTag );
-        }
-        testCaseInfo.tags = std::move(tags);
-    }
-
-    TestCaseInfo::TestCaseInfo( std::string const& _name,
-                                std::string const& _className,
-                                std::string const& _description,
-                                std::vector<std::string> const& _tags,
-                                SourceLineInfo const& _lineInfo )
-    :   name( _name ),
-        className( _className ),
-        description( _description ),
-        lineInfo( _lineInfo ),
-        properties( None )
-    {
-        setTags( *this, _tags );
-    }
-
-    bool TestCaseInfo::isHidden() const {
-        return ( properties & IsHidden ) != 0;
-    }
-    bool TestCaseInfo::throws() const {
-        return ( properties & Throws ) != 0;
-    }
-    bool TestCaseInfo::okToFail() const {
-        return ( properties & (ShouldFail | MayFail ) ) != 0;
-    }
-    bool TestCaseInfo::expectedToFail() const {
-        return ( properties & (ShouldFail ) ) != 0;
-    }
-
-    std::string TestCaseInfo::tagsAsString() const {
-        std::string ret;
-        // '[' and ']' per tag
-        std::size_t full_size = 2 * tags.size();
-        for (const auto& tag : tags) {
-            full_size += tag.size();
-        }
-        ret.reserve(full_size);
-        for (const auto& tag : tags) {
-            ret.push_back('[');
-            ret.append(tag);
-            ret.push_back(']');
-        }
-
-        return ret;
-    }
-
-    TestCase::TestCase( ITestInvoker* testCase, TestCaseInfo const& info ) : TestCaseInfo( info ), test( testCase ) {}
-
-    TestCase TestCase::withName( std::string const& _newName ) const {
-        TestCase other( *this );
-        other.name = _newName;
-        return other;
-    }
-
-    void TestCase::invoke() const {
-        test->invoke();
-    }
-
-    bool TestCase::operator == ( TestCase const& other ) const {
-        return  test.get() == other.test.get() &&
-                name == other.name &&
-                className == other.className;
-    }
-
-    bool TestCase::operator < ( TestCase const& other ) const {
-        return name < other.name;
-    }
-
-    TestCaseInfo const& TestCase::getTestCaseInfo() const
-    {
-        return *this;
-    }
+	namespace Generators {
+		struct GeneratorTracker : TestCaseTracking::TrackerBase, IGeneratorTracker {
+			size_t m_index = static_cast<size_t>( -1 );
+			GeneratorBasePtr m_generator;
+
+			GeneratorTracker( TestCaseTracking::NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
+				:   TrackerBase( nameAndLocation, ctx, parent )
+			{}
+			~GeneratorTracker();
+
+			static GeneratorTracker& acquire( TrackerContext& ctx, TestCaseTracking::NameAndLocation const& nameAndLocation ) {
+				std::shared_ptr<GeneratorTracker> tracker;
+
+				ITracker& currentTracker = ctx.currentTracker();
+				if( TestCaseTracking::ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
+					assert( childTracker );
+					assert( childTracker->isIndexTracker() );
+					tracker = std::static_pointer_cast<GeneratorTracker>( childTracker );
+				}
+				else {
+					tracker = std::make_shared<GeneratorTracker>( nameAndLocation, ctx, &currentTracker );
+					currentTracker.addChild( tracker );
+				}
+
+				if( !ctx.completedCycle() && !tracker->isComplete() ) {
+					if( tracker->m_runState != ExecutingChildren && tracker->m_runState != NeedsAnotherRun )
+						tracker->moveNext();
+					tracker->open();
+				}
+
+				return *tracker;
+			}
+
+			void moveNext() {
+				m_index++;
+				m_children.clear();
+			}
+
+			// TrackerBase interface
+			bool isIndexTracker() const override { return true; }
+			auto hasGenerator() const -> bool override {
+				return !!m_generator;
+			}
+			void close() override {
+				TrackerBase::close();
+				if( m_runState == CompletedSuccessfully && m_index < m_generator->size()-1 )
+					m_runState = Executing;
+			}
+
+			// IGeneratorTracker interface
+			auto getGenerator() const -> GeneratorBasePtr const& override {
+				return m_generator;
+			}
+			void setGenerator( GeneratorBasePtr&& generator ) override {
+				m_generator = std::move( generator );
+			}
+			auto getIndex() const -> size_t override {
+				return m_index;
+			}
+		};
+		GeneratorTracker::~GeneratorTracker() {}
+	}
+
+	RunContext::RunContext(IConfigPtr const& _config, IStreamingReporterPtr&& reporter)
+		:   m_runInfo(_config->name()),
+		m_context(getCurrentMutableContext()),
+		m_config(_config),
+		m_reporter(std::move(reporter)),
+		m_lastAssertionInfo{ StringRef(), SourceLineInfo("",0), StringRef(), ResultDisposition::Normal },
+		m_includeSuccessfulResults( m_config->includeSuccessfulResults() || m_reporter->getPreferences().shouldReportAllAssertions )
+	{
+		m_context.setRunner(this);
+		m_context.setConfig(m_config);
+		m_context.setResultCapture(this);
+		m_reporter->testRunStarting(m_runInfo);
+	}
+
+	RunContext::~RunContext() {
+		m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting()));
+	}
+
+	void RunContext::testGroupStarting(std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount) {
+		m_reporter->testGroupStarting(GroupInfo(testSpec, groupIndex, groupsCount));
+	}
+
+	void RunContext::testGroupEnded(std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount) {
+		m_reporter->testGroupEnded(TestGroupStats(GroupInfo(testSpec, groupIndex, groupsCount), totals, aborting()));
+	}
+
+	Totals RunContext::runTest(TestCase const& testCase) {
+		Totals prevTotals = m_totals;
+
+		std::string redirectedCout;
+		std::string redirectedCerr;
+
+		auto const& testInfo = testCase.getTestCaseInfo();
+
+		m_reporter->testCaseStarting(testInfo);
+
+		m_activeTestCase = &testCase;
+
+		ITracker& rootTracker = m_trackerContext.startRun();
+		assert(rootTracker.isSectionTracker());
+		static_cast<SectionTracker&>(rootTracker).addInitialFilters(m_config->getSectionsToRun());
+		do {
+			m_trackerContext.startCycle();
+			m_testCaseTracker = &SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(testInfo.name, testInfo.lineInfo));
+			runCurrentTest(redirectedCout, redirectedCerr);
+		} while (!m_testCaseTracker->isSuccessfullyCompleted() && !aborting());
+
+		Totals deltaTotals = m_totals.delta(prevTotals);
+		if (testInfo.expectedToFail() && deltaTotals.testCases.passed > 0) {
+			deltaTotals.assertions.failed++;
+			deltaTotals.testCases.passed--;
+			deltaTotals.testCases.failed++;
+		}
+		m_totals.testCases += deltaTotals.testCases;
+		m_reporter->testCaseEnded(TestCaseStats(testInfo,
+			deltaTotals,
+			redirectedCout,
+			redirectedCerr,
+			aborting()));
+
+		m_activeTestCase = nullptr;
+		m_testCaseTracker = nullptr;
+
+		return deltaTotals;
+	}
+
+	IConfigPtr RunContext::config() const {
+		return m_config;
+	}
+
+	IStreamingReporter& RunContext::reporter() const {
+		return *m_reporter;
+	}
+
+	void RunContext::assertionEnded(AssertionResult const & result) {
+		if (result.getResultType() == ResultWas::Ok) {
+			m_totals.assertions.passed++;
+			m_lastAssertionPassed = true;
+		} else if (!result.isOk()) {
+			m_lastAssertionPassed = false;
+			if( m_activeTestCase->getTestCaseInfo().okToFail() )
+				m_totals.assertions.failedButOk++;
+			else
+				m_totals.assertions.failed++;
+		}
+		else {
+			m_lastAssertionPassed = true;
+		}
+
+		// We have no use for the return value (whether messages should be cleared), because messages were made scoped
+		// and should be let to clear themselves out.
+		static_cast<void>(m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals)));
+
+		// Reset working state
+		resetAssertionInfo();
+		m_lastResult = result;
+	}
+	void RunContext::resetAssertionInfo() {
+		m_lastAssertionInfo.macroName = StringRef();
+		m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}"_sr;
+	}
+
+	bool RunContext::sectionStarted(SectionInfo const & sectionInfo, Counts & assertions) {
+		ITracker& sectionTracker = SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(sectionInfo.name, sectionInfo.lineInfo));
+		if (!sectionTracker.isOpen())
+			return false;
+		m_activeSections.push_back(&sectionTracker);
+
+		m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
+
+		m_reporter->sectionStarting(sectionInfo);
+
+		assertions = m_totals.assertions;
+
+		return true;
+	}
+	auto RunContext::acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
+		using namespace Generators;
+		GeneratorTracker& tracker = GeneratorTracker::acquire( m_trackerContext, TestCaseTracking::NameAndLocation( "generator", lineInfo ) );
+		assert( tracker.isOpen() );
+		m_lastAssertionInfo.lineInfo = lineInfo;
+		return tracker;
+	}
+
+	bool RunContext::testForMissingAssertions(Counts& assertions) {
+		if (assertions.total() != 0)
+			return false;
+		if (!m_config->warnAboutMissingAssertions())
+			return false;
+		if (m_trackerContext.currentTracker().hasChildren())
+			return false;
+		m_totals.assertions.failed++;
+		assertions.failed++;
+		return true;
+	}
+
+	void RunContext::sectionEnded(SectionEndInfo const & endInfo) {
+		Counts assertions = m_totals.assertions - endInfo.prevAssertions;
+		bool missingAssertions = testForMissingAssertions(assertions);
+
+		if (!m_activeSections.empty()) {
+			m_activeSections.back()->close();
+			m_activeSections.pop_back();
+		}
+
+		m_reporter->sectionEnded(SectionStats(endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions));
+		m_messages.clear();
+	}
+
+	void RunContext::sectionEndedEarly(SectionEndInfo const & endInfo) {
+		if (m_unfinishedSections.empty())
+			m_activeSections.back()->fail();
+		else
+			m_activeSections.back()->close();
+		m_activeSections.pop_back();
+
+		m_unfinishedSections.push_back(endInfo);
+	}
+	void RunContext::benchmarkStarting( BenchmarkInfo const& info ) {
+		m_reporter->benchmarkStarting( info );
+	}
+	void RunContext::benchmarkEnded( BenchmarkStats const& stats ) {
+		m_reporter->benchmarkEnded( stats );
+	}
+
+	void RunContext::pushScopedMessage(MessageInfo const & message) {
+		m_messages.push_back(message);
+	}
+
+	void RunContext::popScopedMessage(MessageInfo const & message) {
+		m_messages.erase(std::remove(m_messages.begin(), m_messages.end(), message), m_messages.end());
+	}
+
+	std::string RunContext::getCurrentTestName() const {
+		return m_activeTestCase
+			? m_activeTestCase->getTestCaseInfo().name
+			: std::string();
+	}
+
+	const AssertionResult * RunContext::getLastResult() const {
+		return &(*m_lastResult);
+	}
+
+	void RunContext::exceptionEarlyReported() {
+		m_shouldReportUnexpected = false;
+	}
+
+	void RunContext::handleFatalErrorCondition( StringRef message ) {
+		// First notify reporter that bad things happened
+		m_reporter->fatalErrorEncountered(message);
+
+		// Don't rebuild the result -- the stringification itself can cause more fatal errors
+		// Instead, fake a result data.
+		AssertionResultData tempResult( ResultWas::FatalErrorCondition, { false } );
+		tempResult.message = message;
+		AssertionResult result(m_lastAssertionInfo, tempResult);
+
+		assertionEnded(result);
+
+		handleUnfinishedSections();
+
+		// Recreate section for test case (as we will lose the one that was in scope)
+		auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
+		SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
+
+		Counts assertions;
+		assertions.failed = 1;
+		SectionStats testCaseSectionStats(testCaseSection, assertions, 0, false);
+		m_reporter->sectionEnded(testCaseSectionStats);
+
+		auto const& testInfo = m_activeTestCase->getTestCaseInfo();
+
+		Totals deltaTotals;
+		deltaTotals.testCases.failed = 1;
+		deltaTotals.assertions.failed = 1;
+		m_reporter->testCaseEnded(TestCaseStats(testInfo,
+			deltaTotals,
+			std::string(),
+			std::string(),
+			false));
+		m_totals.testCases.failed++;
+		testGroupEnded(std::string(), m_totals, 1, 1);
+		m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, false));
+	}
+
+	bool RunContext::lastAssertionPassed() {
+		return m_lastAssertionPassed;
+	}
+
+	void RunContext::assertionPassed() {
+		m_lastAssertionPassed = true;
+		++m_totals.assertions.passed;
+		resetAssertionInfo();
+	}
+
+	bool RunContext::aborting() const {
+		return m_totals.assertions.failed >= static_cast<std::size_t>(m_config->abortAfter());
+	}
+
+	void RunContext::runCurrentTest(std::string & redirectedCout, std::string & redirectedCerr) {
+		auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
+		SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
+		m_reporter->sectionStarting(testCaseSection);
+		Counts prevAssertions = m_totals.assertions;
+		double duration = 0;
+		m_shouldReportUnexpected = true;
+		m_lastAssertionInfo = { "TEST_CASE"_sr, testCaseInfo.lineInfo, StringRef(), ResultDisposition::Normal };
+
+		seedRng(*m_config);
+
+		Timer timer;
+		CATCH_TRY {
+			if (m_reporter->getPreferences().shouldRedirectStdOut) {
+#if !defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
+				RedirectedStdOut redirectedStdOut;
+				RedirectedStdErr redirectedStdErr;
+
+				timer.start();
+				invokeActiveTestCase();
+				redirectedCout += redirectedStdOut.str();
+				redirectedCerr += redirectedStdErr.str();
+#else
+				OutputRedirect r(redirectedCout, redirectedCerr);
+				timer.start();
+				invokeActiveTestCase();
+#endif
+			} else {
+				timer.start();
+				invokeActiveTestCase();
+			}
+		duration = timer.getElapsedSeconds();
+		} CATCH_CATCH_ANON (TestFailureException&) {
+			// This just means the test was aborted due to failure
+		} CATCH_CATCH_ALL {
+			// Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions
+			// are reported without translation at the point of origin.
+			if( m_shouldReportUnexpected ) {
+				AssertionReaction dummyReaction;
+				handleUnexpectedInflightException( m_lastAssertionInfo, translateActiveException(), dummyReaction );
+			}
+		}
+		Counts assertions = m_totals.assertions - prevAssertions;
+		bool missingAssertions = testForMissingAssertions(assertions);
+
+		m_testCaseTracker->close();
+		handleUnfinishedSections();
+		m_messages.clear();
+
+		SectionStats testCaseSectionStats(testCaseSection, assertions, duration, missingAssertions);
+		m_reporter->sectionEnded(testCaseSectionStats);
+	}
+
+	void RunContext::invokeActiveTestCase() {
+		FatalConditionHandler fatalConditionHandler; // Handle signals
+		m_activeTestCase->invoke();
+		fatalConditionHandler.reset();
+	}
+
+	void RunContext::handleUnfinishedSections() {
+		// If sections ended prematurely due to an exception we stored their
+		// infos here so we can tear them down outside the unwind process.
+		for (auto it = m_unfinishedSections.rbegin(),
+			itEnd = m_unfinishedSections.rend();
+			it != itEnd;
+			++it)
+			sectionEnded(*it);
+		m_unfinishedSections.clear();
+	}
+
+	void RunContext::handleExpr(
+		AssertionInfo const& info,
+		ITransientExpression const& expr,
+		AssertionReaction& reaction
+	) {
+		m_reporter->assertionStarting( info );
+
+		bool negated = isFalseTest( info.resultDisposition );
+		bool result = expr.getResult() != negated;
+
+		if( result ) {
+			if (!m_includeSuccessfulResults) {
+				assertionPassed();
+			}
+			else {
+				reportExpr(info, ResultWas::Ok, &expr, negated);
+			}
+		}
+		else {
+			reportExpr(info, ResultWas::ExpressionFailed, &expr, negated );
+			populateReaction( reaction );
+		}
+	}
+	void RunContext::reportExpr(
+		AssertionInfo const &info,
+		ResultWas::OfType resultType,
+		ITransientExpression const *expr,
+		bool negated ) {
+
+		m_lastAssertionInfo = info;
+		AssertionResultData data( resultType, LazyExpression( negated ) );
+
+		AssertionResult assertionResult{ info, data };
+		assertionResult.m_resultData.lazyExpression.m_transientExpression = expr;
+
+		assertionEnded( assertionResult );
+	}
+
+	void RunContext::handleMessage(
+		AssertionInfo const& info,
+		ResultWas::OfType resultType,
+		StringRef const& message,
+		AssertionReaction& reaction
+	) {
+		m_reporter->assertionStarting( info );
+
+		m_lastAssertionInfo = info;
+
+		AssertionResultData data( resultType, LazyExpression( false ) );
+		data.message = message;
+		AssertionResult assertionResult{ m_lastAssertionInfo, data };
+		assertionEnded( assertionResult );
+		if( !assertionResult.isOk() )
+			populateReaction( reaction );
+	}
+	void RunContext::handleUnexpectedExceptionNotThrown(
+		AssertionInfo const& info,
+		AssertionReaction& reaction
+	) {
+		handleNonExpr(info, Catch::ResultWas::DidntThrowException, reaction);
+	}
+
+	void RunContext::handleUnexpectedInflightException(
+		AssertionInfo const& info,
+		std::string const& message,
+		AssertionReaction& reaction
+	) {
+		m_lastAssertionInfo = info;
+
+		AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
+		data.message = message;
+		AssertionResult assertionResult{ info, data };
+		assertionEnded( assertionResult );
+		populateReaction( reaction );
+	}
+
+	void RunContext::populateReaction( AssertionReaction& reaction ) {
+		reaction.shouldDebugBreak = m_config->shouldDebugBreak();
+		reaction.shouldThrow = aborting() || (m_lastAssertionInfo.resultDisposition & ResultDisposition::Normal);
+	}
+
+	void RunContext::handleIncomplete(
+		AssertionInfo const& info
+	) {
+		m_lastAssertionInfo = info;
+
+		AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
+		data.message = "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE";
+		AssertionResult assertionResult{ info, data };
+		assertionEnded( assertionResult );
+	}
+	void RunContext::handleNonExpr(
+		AssertionInfo const &info,
+		ResultWas::OfType resultType,
+		AssertionReaction &reaction
+	) {
+		m_lastAssertionInfo = info;
+
+		AssertionResultData data( resultType, LazyExpression( false ) );
+		AssertionResult assertionResult{ info, data };
+		assertionEnded( assertionResult );
+
+		if( !assertionResult.isOk() )
+			populateReaction( reaction );
+	}
+
+	IResultCapture& getResultCapture() {
+		if (auto* capture = getCurrentContext().getResultCapture())
+			return *capture;
+		else
+			CATCH_INTERNAL_ERROR("No result capture instance");
+	}
+}
+// end catch_run_context.cpp
+// start catch_section.cpp
+
+namespace Catch {
+
+	Section::Section( SectionInfo const& info )
+		:   m_info( info ),
+		m_sectionIncluded( getResultCapture().sectionStarted( m_info, m_assertions ) )
+	{
+		m_timer.start();
+	}
+
+	Section::~Section() {
+		if( m_sectionIncluded ) {
+			SectionEndInfo endInfo{ m_info, m_assertions, m_timer.getElapsedSeconds() };
+			if( uncaught_exceptions() )
+				getResultCapture().sectionEndedEarly( endInfo );
+			else
+				getResultCapture().sectionEnded( endInfo );
+		}
+	}
+
+	// This indicates whether the section should be executed or not
+	Section::operator bool() const {
+		return m_sectionIncluded;
+	}
+
+} // end namespace Catch
+  // end catch_section.cpp
+  // start catch_section_info.cpp
+
+namespace Catch {
+
+	SectionInfo::SectionInfo
+	(   SourceLineInfo const& _lineInfo,
+		std::string const& _name )
+		:   name( _name ),
+		lineInfo( _lineInfo )
+	{}
+
+} // end namespace Catch
+  // end catch_section_info.cpp
+  // start catch_session.cpp
+
+  // start catch_session.h
+
+#include <memory>
+
+namespace Catch {
+
+	class Session : NonCopyable {
+	public:
+
+		Session();
+		~Session() override;
+
+		void showHelp() const;
+		void libIdentify();
+
+		int applyCommandLine( int argc, char const * const * argv );
+#if defined(CATCH_CONFIG_WCHAR) && defined(WIN32) && defined(UNICODE)
+		int applyCommandLine( int argc, wchar_t const * const * argv );
+#endif
+
+		void useConfigData( ConfigData const& configData );
+
+		template<typename CharT>
+		int run(int argc, CharT const * const argv[]) {
+			if (m_startupExceptions)
+				return 1;
+			int returnCode = applyCommandLine(argc, argv);
+			if (returnCode == 0)
+				returnCode = run();
+			return returnCode;
+		}
+
+		int run();
+
+		clara::Parser const& cli() const;
+		void cli( clara::Parser const& newParser );
+		ConfigData& configData();
+		Config& config();
+	private:
+		int runInternal();
+
+		clara::Parser m_cli;
+		ConfigData m_configData;
+		std::shared_ptr<Config> m_config;
+		bool m_startupExceptions = false;
+	};
+
+} // end namespace Catch
+
+  // end catch_session.h
+  // start catch_version.h
+
+#include <iosfwd>
+
+namespace Catch {
+
+	// Versioning information
+	struct Version {
+		Version( Version const& ) = delete;
+		Version& operator=( Version const& ) = delete;
+		Version(    unsigned int _majorVersion,
+			unsigned int _minorVersion,
+			unsigned int _patchNumber,
+			char const * const _branchName,
+			unsigned int _buildNumber );
+
+		unsigned int const majorVersion;
+		unsigned int const minorVersion;
+		unsigned int const patchNumber;
+
+		// buildNumber is only used if branchName is not null
+		char const * const branchName;
+		unsigned int const buildNumber;
+
+		friend std::ostream& operator << ( std::ostream& os, Version const& version );
+	};
+
+	Version const& libraryVersion();
+}
+
+// end catch_version.h
+#include <cstdlib>
+#include <iomanip>
+
+namespace Catch {
+
+	namespace {
+		const int MaxExitCode = 255;
+
+		IStreamingReporterPtr createReporter(std::string const& reporterName, IConfigPtr const& config) {
+			auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, config);
+			CATCH_ENFORCE(reporter, "No reporter registered with name: '" << reporterName << "'");
+
+			return reporter;
+		}
+
+		IStreamingReporterPtr makeReporter(std::shared_ptr<Config> const& config) {
+			if (Catch::getRegistryHub().getReporterRegistry().getListeners().empty()) {
+				return createReporter(config->getReporterName(), config);
+			}
+
+			auto multi = std::unique_ptr<ListeningReporter>(new ListeningReporter);
+
+			auto const& listeners = Catch::getRegistryHub().getReporterRegistry().getListeners();
+			for (auto const& listener : listeners) {
+				multi->addListener(listener->create(Catch::ReporterConfig(config)));
+			}
+			multi->addReporter(createReporter(config->getReporterName(), config));
+			return std::move(multi);
+		}
+
+		Catch::Totals runTests(std::shared_ptr<Config> const& config) {
+			auto reporter = makeReporter(config);
+
+			RunContext context(config, std::move(reporter));
+
+			Totals totals;
+
+			context.testGroupStarting(config->name(), 1, 1);
+
+			TestSpec testSpec = config->testSpec();
+
+			auto const& allTestCases = getAllTestCasesSorted(*config);
+			for (auto const& testCase : allTestCases) {
+				if (!context.aborting() && matchTest(testCase, testSpec, *config))
+					totals += context.runTest(testCase);
+				else
+					context.reporter().skipTest(testCase);
+			}
+
+			if (config->warnAboutNoTests() && totals.testCases.total() == 0) {
+				ReusableStringStream testConfig;
+
+				bool first = true;
+				for (const auto& input : config->getTestsOrTags()) {
+					if (!first) { testConfig << ' '; }
+					first = false;
+					testConfig << input;
+				}
+
+				context.reporter().noMatchingTestCases(testConfig.str());
+				totals.error = -1;
+			}
+
+			context.testGroupEnded(config->name(), totals, 1, 1);
+			return totals;
+		}
+
+		void applyFilenamesAsTags(Catch::IConfig const& config) {
+			auto& tests = const_cast<std::vector<TestCase>&>(getAllTestCasesSorted(config));
+			for (auto& testCase : tests) {
+				auto tags = testCase.tags;
+
+				std::string filename = testCase.lineInfo.file;
+				auto lastSlash = filename.find_last_of("\\/");
+				if (lastSlash != std::string::npos) {
+					filename.erase(0, lastSlash);
+					filename[0] = '#';
+				}
+
+				auto lastDot = filename.find_last_of('.');
+				if (lastDot != std::string::npos) {
+					filename.erase(lastDot);
+				}
+
+				tags.push_back(std::move(filename));
+				setTags(testCase, tags);
+			}
+		}
+
+	} // anon namespace
+
+	Session::Session() {
+		static bool alreadyInstantiated = false;
+		if( alreadyInstantiated ) {
+			CATCH_TRY { CATCH_INTERNAL_ERROR( "Only one instance of Catch::Session can ever be used" ); }
+			CATCH_CATCH_ALL { getMutableRegistryHub().registerStartupException(); }
+		}
+
+		// There cannot be exceptions at startup in no-exception mode.
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+		const auto& exceptions = getRegistryHub().getStartupExceptionRegistry().getExceptions();
+		if ( !exceptions.empty() ) {
+			m_startupExceptions = true;
+			Colour colourGuard( Colour::Red );
+			Catch::cerr() << "Errors occurred during startup!" << '\n';
+			// iterate over all exceptions and notify user
+			for ( const auto& ex_ptr : exceptions ) {
+				try {
+					std::rethrow_exception(ex_ptr);
+				} catch ( std::exception const& ex ) {
+					Catch::cerr() << Column( ex.what() ).indent(2) << '\n';
+				}
+			}
+		}
+#endif
+
+		alreadyInstantiated = true;
+		m_cli = makeCommandLineParser( m_configData );
+	}
+	Session::~Session() {
+		Catch::cleanUp();
+	}
+
+	void Session::showHelp() const {
+		Catch::cout()
+			<< "\nCatch v" << libraryVersion() << "\n"
+			<< m_cli << std::endl
+			<< "For more detailed usage please see the project docs\n" << std::endl;
+	}
+	void Session::libIdentify() {
+		Catch::cout()
+			<< std::left << std::setw(16) << "description: " << "A Catch test executable\n"
+			<< std::left << std::setw(16) << "category: " << "testframework\n"
+			<< std::left << std::setw(16) << "framework: " << "Catch Test\n"
+			<< std::left << std::setw(16) << "version: " << libraryVersion() << std::endl;
+	}
+
+	int Session::applyCommandLine( int argc, char const * const * argv ) {
+		if( m_startupExceptions )
+			return 1;
+
+		auto result = m_cli.parse( clara::Args( argc, argv ) );
+		if( !result ) {
+			Catch::cerr()
+				<< Colour( Colour::Red )
+				<< "\nError(s) in input:\n"
+				<< Column( result.errorMessage() ).indent( 2 )
+				<< "\n\n";
+			Catch::cerr() << "Run with -? for usage\n" << std::endl;
+			return MaxExitCode;
+		}
+
+		if( m_configData.showHelp )
+			showHelp();
+		if( m_configData.libIdentify )
+			libIdentify();
+		m_config.reset();
+		return 0;
+	}
+
+#if defined(CATCH_CONFIG_WCHAR) && defined(WIN32) && defined(UNICODE)
+	int Session::applyCommandLine( int argc, wchar_t const * const * argv ) {
+
+		char **utf8Argv = new char *[ argc ];
+
+		for ( int i = 0; i < argc; ++i ) {
+			int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, NULL, 0, NULL, NULL );
+
+			utf8Argv[ i ] = new char[ bufSize ];
+
+			WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, NULL, NULL );
+		}
+
+		int returnCode = applyCommandLine( argc, utf8Argv );
+
+		for ( int i = 0; i < argc; ++i )
+			delete [] utf8Argv[ i ];
+
+		delete [] utf8Argv;
+
+		return returnCode;
+	}
+#endif
+
+	void Session::useConfigData( ConfigData const& configData ) {
+		m_configData = configData;
+		m_config.reset();
+	}
+
+	int Session::run() {
+		if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
+			Catch::cout() << "...waiting for enter/ return before starting" << std::endl;
+			static_cast<void>(std::getchar());
+		}
+		int exitCode = runInternal();
+		if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeExit ) != 0 ) {
+			Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode << std::endl;
+			static_cast<void>(std::getchar());
+		}
+		return exitCode;
+	}
+
+	clara::Parser const& Session::cli() const {
+		return m_cli;
+	}
+	void Session::cli( clara::Parser const& newParser ) {
+		m_cli = newParser;
+	}
+	ConfigData& Session::configData() {
+		return m_configData;
+	}
+	Config& Session::config() {
+		if( !m_config )
+			m_config = std::make_shared<Config>( m_configData );
+		return *m_config;
+	}
+
+	int Session::runInternal() {
+		if( m_startupExceptions )
+			return 1;
+
+		if (m_configData.showHelp || m_configData.libIdentify) {
+			return 0;
+		}
+
+		CATCH_TRY {
+			config(); // Force config to be constructed
+
+		seedRng( *m_config );
+
+		if( m_configData.filenamesAsTags )
+			applyFilenamesAsTags( *m_config );
+
+		// Handle list request
+		if( Option<std::size_t> listed = list( config() ) )
+			return static_cast<int>( *listed );
+
+		auto totals = runTests( m_config );
+		// Note that on unices only the lower 8 bits are usually used, clamping
+		// the return value to 255 prevents false negative when some multiple
+		// of 256 tests has failed
+		return (std::min) (MaxExitCode, (std::max) (totals.error, static_cast<int>(totals.assertions.failed)));
+		}
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+			catch( std::exception& ex ) {
+			Catch::cerr() << ex.what() << std::endl;
+			return MaxExitCode;
+		}
+#endif
+	}
+
+} // end namespace Catch
+  // end catch_session.cpp
+  // start catch_singletons.cpp
+
+#include <vector>
+
+namespace Catch {
+
+	namespace {
+		static auto getSingletons() -> std::vector<ISingleton*>*& {
+			static std::vector<ISingleton*>* g_singletons = nullptr;
+			if( !g_singletons )
+				g_singletons = new std::vector<ISingleton*>();
+			return g_singletons;
+		}
+	}
+
+	ISingleton::~ISingleton() {}
+
+	void addSingleton(ISingleton* singleton ) {
+		getSingletons()->push_back( singleton );
+	}
+	void cleanupSingletons() {
+		auto& singletons = getSingletons();
+		for( auto singleton : *singletons )
+			delete singleton;
+		delete singletons;
+		singletons = nullptr;
+	}
+
+} // namespace Catch
+  // end catch_singletons.cpp
+  // start catch_startup_exception_registry.cpp
+
+namespace Catch {
+	void StartupExceptionRegistry::add( std::exception_ptr const& exception ) noexcept {
+		CATCH_TRY {
+			m_exceptions.push_back(exception);
+		} CATCH_CATCH_ALL {
+			// If we run out of memory during start-up there's really not a lot more we can do about it
+			std::terminate();
+		}
+	}
+
+	std::vector<std::exception_ptr> const& StartupExceptionRegistry::getExceptions() const noexcept {
+		return m_exceptions;
+	}
+
+} // end namespace Catch
+  // end catch_startup_exception_registry.cpp
+  // start catch_stream.cpp
+
+#include <cstdio>
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <vector>
+#include <memory>
+
+namespace Catch {
+
+	Catch::IStream::~IStream() = default;
+
+	namespace detail { namespace {
+		template<typename WriterF, std::size_t bufferSize=256>
+		class StreamBufImpl : public std::streambuf {
+			char data[bufferSize];
+			WriterF m_writer;
+
+		public:
+			StreamBufImpl() {
+				setp( data, data + sizeof(data) );
+			}
+
+			~StreamBufImpl() noexcept {
+				StreamBufImpl::sync();
+			}
+
+		private:
+			int overflow( int c ) override {
+				sync();
+
+				if( c != EOF ) {
+					if( pbase() == epptr() )
+						m_writer( std::string( 1, static_cast<char>( c ) ) );
+					else
+						sputc( static_cast<char>( c ) );
+				}
+				return 0;
+			}
+
+			int sync() override {
+				if( pbase() != pptr() ) {
+					m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
+					setp( pbase(), epptr() );
+				}
+				return 0;
+			}
+		};
+
+		///////////////////////////////////////////////////////////////////////////
+
+		struct OutputDebugWriter {
+
+			void operator()( std::string const&str ) {
+				writeToDebugConsole( str );
+			}
+		};
+
+		///////////////////////////////////////////////////////////////////////////
+
+		class FileStream : public IStream {
+			mutable std::ofstream m_ofs;
+		public:
+			FileStream( StringRef filename ) {
+				m_ofs.open( filename.c_str() );
+				CATCH_ENFORCE( !m_ofs.fail(), "Unable to open file: '" << filename << "'" );
+			}
+			~FileStream() override = default;
+		public: // IStream
+			std::ostream& stream() const override {
+				return m_ofs;
+			}
+		};
+
+		///////////////////////////////////////////////////////////////////////////
+
+		class CoutStream : public IStream {
+			mutable std::ostream m_os;
+		public:
+			// Store the streambuf from cout up-front because
+			// cout may get redirected when running tests
+			CoutStream() : m_os( Catch::cout().rdbuf() ) {}
+			~CoutStream() override = default;
+
+		public: // IStream
+			std::ostream& stream() const override { return m_os; }
+		};
+
+		///////////////////////////////////////////////////////////////////////////
+
+		class DebugOutStream : public IStream {
+			std::unique_ptr<StreamBufImpl<OutputDebugWriter>> m_streamBuf;
+			mutable std::ostream m_os;
+		public:
+			DebugOutStream()
+				:   m_streamBuf( new StreamBufImpl<OutputDebugWriter>() ),
+				m_os( m_streamBuf.get() )
+			{}
+
+			~DebugOutStream() override = default;
+
+		public: // IStream
+			std::ostream& stream() const override { return m_os; }
+		};
+
+	}} // namespace anon::detail
+
+	   ///////////////////////////////////////////////////////////////////////////
+
+	auto makeStream( StringRef const &filename ) -> IStream const* {
+		if( filename.empty() )
+			return new detail::CoutStream();
+		else if( filename[0] == '%' ) {
+			if( filename == "%debug" )
+				return new detail::DebugOutStream();
+			else
+				CATCH_ERROR( "Unrecognised stream: '" << filename << "'" );
+		}
+		else
+			return new detail::FileStream( filename );
+	}
+
+	// This class encapsulates the idea of a pool of ostringstreams that can be reused.
+	struct StringStreams {
+		std::vector<std::unique_ptr<std::ostringstream>> m_streams;
+		std::vector<std::size_t> m_unused;
+		std::ostringstream m_referenceStream; // Used for copy state/ flags from
+
+		auto add() -> std::size_t {
+			if( m_unused.empty() ) {
+				m_streams.push_back( std::unique_ptr<std::ostringstream>( new std::ostringstream ) );
+				return m_streams.size()-1;
+			}
+			else {
+				auto index = m_unused.back();
+				m_unused.pop_back();
+				return index;
+			}
+		}
+
+		void release( std::size_t index ) {
+			m_streams[index]->copyfmt( m_referenceStream ); // Restore initial flags and other state
+			m_unused.push_back(index);
+		}
+	};
+
+	ReusableStringStream::ReusableStringStream()
+		:   m_index( Singleton<StringStreams>::getMutable().add() ),
+		m_oss( Singleton<StringStreams>::getMutable().m_streams[m_index].get() )
+	{}
+
+	ReusableStringStream::~ReusableStringStream() {
+		static_cast<std::ostringstream*>( m_oss )->str("");
+		m_oss->clear();
+		Singleton<StringStreams>::getMutable().release( m_index );
+	}
+
+	auto ReusableStringStream::str() const -> std::string {
+		return static_cast<std::ostringstream*>( m_oss )->str();
+	}
+
+	///////////////////////////////////////////////////////////////////////////
+
+#ifndef CATCH_CONFIG_NOSTDOUT // If you #define this you must implement these functions
+	std::ostream& cout() { return std::cout; }
+	std::ostream& cerr() { return std::cerr; }
+	std::ostream& clog() { return std::clog; }
+#endif
+}
+// end catch_stream.cpp
+// start catch_string_manip.cpp
+
+#include <algorithm>
+#include <ostream>
+#include <cstring>
+#include <cctype>
+
+namespace Catch {
+
+	namespace {
+		char toLowerCh(char c) {
+			return static_cast<char>( std::tolower( c ) );
+		}
+	}
+
+	bool startsWith( std::string const& s, std::string const& prefix ) {
+		return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin());
+	}
+	bool startsWith( std::string const& s, char prefix ) {
+		return !s.empty() && s[0] == prefix;
+	}
+	bool endsWith( std::string const& s, std::string const& suffix ) {
+		return s.size() >= suffix.size() && std::equal(suffix.rbegin(), suffix.rend(), s.rbegin());
+	}
+	bool endsWith( std::string const& s, char suffix ) {
+		return !s.empty() && s[s.size()-1] == suffix;
+	}
+	bool contains( std::string const& s, std::string const& infix ) {
+		return s.find( infix ) != std::string::npos;
+	}
+	void toLowerInPlace( std::string& s ) {
+		std::transform( s.begin(), s.end(), s.begin(), toLowerCh );
+	}
+	std::string toLower( std::string const& s ) {
+		std::string lc = s;
+		toLowerInPlace( lc );
+		return lc;
+	}
+	std::string trim( std::string const& str ) {
+		static char const* whitespaceChars = "\n\r\t ";
+		std::string::size_type start = str.find_first_not_of( whitespaceChars );
+		std::string::size_type end = str.find_last_not_of( whitespaceChars );
+
+		return start != std::string::npos ? str.substr( start, 1+end-start ) : std::string();
+	}
+
+	bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
+		bool replaced = false;
+		std::size_t i = str.find( replaceThis );
+		while( i != std::string::npos ) {
+			replaced = true;
+			str = str.substr( 0, i ) + withThis + str.substr( i+replaceThis.size() );
+			if( i < str.size()-withThis.size() )
+				i = str.find( replaceThis, i+withThis.size() );
+			else
+				i = std::string::npos;
+		}
+		return replaced;
+	}
+
+	pluralise::pluralise( std::size_t count, std::string const& label )
+		:   m_count( count ),
+		m_label( label )
+	{}
+
+	std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
+		os << pluraliser.m_count << ' ' << pluraliser.m_label;
+		if( pluraliser.m_count != 1 )
+			os << 's';
+		return os;
+	}
+
+}
+// end catch_string_manip.cpp
+// start catch_stringref.cpp
+
+#if defined(__clang__)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wexit-time-destructors"
+#endif
+
+#include <ostream>
+#include <cstring>
+#include <cstdint>
+
+namespace {
+	const uint32_t byte_2_lead = 0xC0;
+	const uint32_t byte_3_lead = 0xE0;
+	const uint32_t byte_4_lead = 0xF0;
+}
+
+namespace Catch {
+	StringRef::StringRef( char const* rawChars ) noexcept
+		: StringRef( rawChars, static_cast<StringRef::size_type>(std::strlen(rawChars) ) )
+	{}
+
+	StringRef::operator std::string() const {
+		return std::string( m_start, m_size );
+	}
+
+	void StringRef::swap( StringRef& other ) noexcept {
+		std::swap( m_start, other.m_start );
+		std::swap( m_size, other.m_size );
+		std::swap( m_data, other.m_data );
+	}
+
+	auto StringRef::c_str() const -> char const* {
+		if( isSubstring() )
+			const_cast<StringRef*>( this )->takeOwnership();
+		return m_start;
+	}
+	auto StringRef::currentData() const noexcept -> char const* {
+		return m_start;
+	}
+
+	auto StringRef::isOwned() const noexcept -> bool {
+		return m_data != nullptr;
+	}
+	auto StringRef::isSubstring() const noexcept -> bool {
+		return m_start[m_size] != '\0';
+	}
+
+	void StringRef::takeOwnership() {
+		if( !isOwned() ) {
+			m_data = new char[m_size+1];
+			memcpy( m_data, m_start, m_size );
+			m_data[m_size] = '\0';
+			m_start = m_data;
+		}
+	}
+	auto StringRef::substr( size_type start, size_type size ) const noexcept -> StringRef {
+		if( start < m_size )
+			return StringRef( m_start+start, size );
+		else
+			return StringRef();
+	}
+	auto StringRef::operator == ( StringRef const& other ) const noexcept -> bool {
+		return
+			size() == other.size() &&
+			(std::strncmp( m_start, other.m_start, size() ) == 0);
+	}
+	auto StringRef::operator != ( StringRef const& other ) const noexcept -> bool {
+		return !operator==( other );
+	}
+
+	auto StringRef::operator[](size_type index) const noexcept -> char {
+		return m_start[index];
+	}
+
+	auto StringRef::numberOfCharacters() const noexcept -> size_type {
+		size_type noChars = m_size;
+		// Make adjustments for uft encodings
+		for( size_type i=0; i < m_size; ++i ) {
+			char c = m_start[i];
+			if( ( c & byte_2_lead ) == byte_2_lead ) {
+				noChars--;
+				if (( c & byte_3_lead ) == byte_3_lead )
+					noChars--;
+				if( ( c & byte_4_lead ) == byte_4_lead )
+					noChars--;
+			}
+		}
+		return noChars;
+	}
+
+	auto operator + ( StringRef const& lhs, StringRef const& rhs ) -> std::string {
+		std::string str;
+		str.reserve( lhs.size() + rhs.size() );
+		str += lhs;
+		str += rhs;
+		return str;
+	}
+	auto operator + ( StringRef const& lhs, const char* rhs ) -> std::string {
+		return std::string( lhs ) + std::string( rhs );
+	}
+	auto operator + ( char const* lhs, StringRef const& rhs ) -> std::string {
+		return std::string( lhs ) + std::string( rhs );
+	}
+
+	auto operator << ( std::ostream& os, StringRef const& str ) -> std::ostream& {
+		return os.write(str.currentData(), str.size());
+	}
+
+	auto operator+=( std::string& lhs, StringRef const& rhs ) -> std::string& {
+		lhs.append(rhs.currentData(), rhs.size());
+		return lhs;
+	}
+
+} // namespace Catch
+
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#endif
+  // end catch_stringref.cpp
+  // start catch_tag_alias.cpp
+
+namespace Catch {
+	TagAlias::TagAlias(std::string const & _tag, SourceLineInfo _lineInfo): tag(_tag), lineInfo(_lineInfo) {}
+}
+// end catch_tag_alias.cpp
+// start catch_tag_alias_autoregistrar.cpp
+
+namespace Catch {
+
+	RegistrarForTagAliases::RegistrarForTagAliases(char const* alias, char const* tag, SourceLineInfo const& lineInfo) {
+		CATCH_TRY {
+			getMutableRegistryHub().registerTagAlias(alias, tag, lineInfo);
+		} CATCH_CATCH_ALL {
+			// Do not throw when constructing global objects, instead register the exception to be processed later
+			getMutableRegistryHub().registerStartupException();
+		}
+	}
+
+}
+// end catch_tag_alias_autoregistrar.cpp
+// start catch_tag_alias_registry.cpp
+
+#include <sstream>
+
+namespace Catch {
+
+	TagAliasRegistry::~TagAliasRegistry() {}
+
+	TagAlias const* TagAliasRegistry::find( std::string const& alias ) const {
+		auto it = m_registry.find( alias );
+		if( it != m_registry.end() )
+			return &(it->second);
+		else
+			return nullptr;
+	}
+
+	std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
+		std::string expandedTestSpec = unexpandedTestSpec;
+		for( auto const& registryKvp : m_registry ) {
+			std::size_t pos = expandedTestSpec.find( registryKvp.first );
+			if( pos != std::string::npos ) {
+				expandedTestSpec =  expandedTestSpec.substr( 0, pos ) +
+					registryKvp.second.tag +
+					expandedTestSpec.substr( pos + registryKvp.first.size() );
+			}
+		}
+		return expandedTestSpec;
+	}
+
+	void TagAliasRegistry::add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) {
+		CATCH_ENFORCE( startsWith(alias, "[@") && endsWith(alias, ']'),
+			"error: tag alias, '" << alias << "' is not of the form [@alias name].\n" << lineInfo );
+
+		CATCH_ENFORCE( m_registry.insert(std::make_pair(alias, TagAlias(tag, lineInfo))).second,
+			"error: tag alias, '" << alias << "' already registered.\n"
+			<< "\tFirst seen at: " << find(alias)->lineInfo << "\n"
+			<< "\tRedefined at: " << lineInfo );
+	}
+
+	ITagAliasRegistry::~ITagAliasRegistry() {}
+
+	ITagAliasRegistry const& ITagAliasRegistry::get() {
+		return getRegistryHub().getTagAliasRegistry();
+	}
+
+} // end namespace Catch
+  // end catch_tag_alias_registry.cpp
+  // start catch_test_case_info.cpp
+
+#include <cctype>
+#include <exception>
+#include <algorithm>
+#include <sstream>
+
+namespace Catch {
+
+	namespace {
+		TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
+			if( startsWith( tag, '.' ) ||
+				tag == "!hide" )
+				return TestCaseInfo::IsHidden;
+			else if( tag == "!throws" )
+				return TestCaseInfo::Throws;
+			else if( tag == "!shouldfail" )
+				return TestCaseInfo::ShouldFail;
+			else if( tag == "!mayfail" )
+				return TestCaseInfo::MayFail;
+			else if( tag == "!nonportable" )
+				return TestCaseInfo::NonPortable;
+			else if( tag == "!benchmark" )
+				return static_cast<TestCaseInfo::SpecialProperties>( TestCaseInfo::Benchmark | TestCaseInfo::IsHidden );
+			else
+				return TestCaseInfo::None;
+		}
+		bool isReservedTag( std::string const& tag ) {
+			return parseSpecialTag( tag ) == TestCaseInfo::None && tag.size() > 0 && !std::isalnum( static_cast<unsigned char>(tag[0]) );
+		}
+		void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
+			CATCH_ENFORCE( !isReservedTag(tag),
+				"Tag name: [" << tag << "] is not allowed.\n"
+				<< "Tag names starting with non alpha-numeric characters are reserved\n"
+				<< _lineInfo );
+		}
+	}
+
+	TestCase makeTestCase(  ITestInvoker* _testCase,
+		std::string const& _className,
+		NameAndTags const& nameAndTags,
+		SourceLineInfo const& _lineInfo )
+	{
+		bool isHidden = false;
+
+		// Parse out tags
+		std::vector<std::string> tags;
+		std::string desc, tag;
+		bool inTag = false;
+		std::string _descOrTags = nameAndTags.tags;
+		for (char c : _descOrTags) {
+			if( !inTag ) {
+				if( c == '[' )
+					inTag = true;
+				else
+					desc += c;
+			}
+			else {
+				if( c == ']' ) {
+					TestCaseInfo::SpecialProperties prop = parseSpecialTag( tag );
+					if( ( prop & TestCaseInfo::IsHidden ) != 0 )
+						isHidden = true;
+					else if( prop == TestCaseInfo::None )
+						enforceNotReservedTag( tag, _lineInfo );
+
+					tags.push_back( tag );
+					tag.clear();
+					inTag = false;
+				}
+				else
+					tag += c;
+			}
+		}
+		if( isHidden ) {
+			tags.push_back( "." );
+		}
+
+		TestCaseInfo info( nameAndTags.name, _className, desc, tags, _lineInfo );
+		return TestCase( _testCase, std::move(info) );
+	}
+
+	void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags ) {
+		std::sort(begin(tags), end(tags));
+		tags.erase(std::unique(begin(tags), end(tags)), end(tags));
+		testCaseInfo.lcaseTags.clear();
+
+		for( auto const& tag : tags ) {
+			std::string lcaseTag = toLower( tag );
+			testCaseInfo.properties = static_cast<TestCaseInfo::SpecialProperties>( testCaseInfo.properties | parseSpecialTag( lcaseTag ) );
+			testCaseInfo.lcaseTags.push_back( lcaseTag );
+		}
+		testCaseInfo.tags = std::move(tags);
+	}
+
+	TestCaseInfo::TestCaseInfo( std::string const& _name,
+		std::string const& _className,
+		std::string const& _description,
+		std::vector<std::string> const& _tags,
+		SourceLineInfo const& _lineInfo )
+		:   name( _name ),
+		className( _className ),
+		description( _description ),
+		lineInfo( _lineInfo ),
+		properties( None )
+	{
+		setTags( *this, _tags );
+	}
+
+	bool TestCaseInfo::isHidden() const {
+		return ( properties & IsHidden ) != 0;
+	}
+	bool TestCaseInfo::throws() const {
+		return ( properties & Throws ) != 0;
+	}
+	bool TestCaseInfo::okToFail() const {
+		return ( properties & (ShouldFail | MayFail ) ) != 0;
+	}
+	bool TestCaseInfo::expectedToFail() const {
+		return ( properties & (ShouldFail ) ) != 0;
+	}
+
+	std::string TestCaseInfo::tagsAsString() const {
+		std::string ret;
+		// '[' and ']' per tag
+		std::size_t full_size = 2 * tags.size();
+		for (const auto& tag : tags) {
+			full_size += tag.size();
+		}
+		ret.reserve(full_size);
+		for (const auto& tag : tags) {
+			ret.push_back('[');
+			ret.append(tag);
+			ret.push_back(']');
+		}
+
+		return ret;
+	}
+
+	TestCase::TestCase( ITestInvoker* testCase, TestCaseInfo&& info ) : TestCaseInfo( std::move(info) ), test( testCase ) {}
+
+	TestCase TestCase::withName( std::string const& _newName ) const {
+		TestCase other( *this );
+		other.name = _newName;
+		return other;
+	}
+
+	void TestCase::invoke() const {
+		test->invoke();
+	}
+
+	bool TestCase::operator == ( TestCase const& other ) const {
+		return  test.get() == other.test.get() &&
+			name == other.name &&
+			className == other.className;
+	}
+
+	bool TestCase::operator < ( TestCase const& other ) const {
+		return name < other.name;
+	}
+
+	TestCaseInfo const& TestCase::getTestCaseInfo() const
+	{
+		return *this;
+	}
+
+} // end namespace Catch
+  // end catch_test_case_info.cpp
+  // start catch_test_case_registry_impl.cpp
+
+#include <sstream>
+
+namespace Catch {
+
+	std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases ) {
+
+		std::vector<TestCase> sorted = unsortedTestCases;
+
+		switch( config.runOrder() ) {
+		case RunTests::InLexicographicalOrder:
+			std::sort( sorted.begin(), sorted.end() );
+			break;
+		case RunTests::InRandomOrder:
+			seedRng( config );
+			std::shuffle( sorted.begin(), sorted.end(), rng() );
+			break;
+		case RunTests::InDeclarationOrder:
+			// already in declaration order
+			break;
+		}
+		return sorted;
+	}
+	bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config ) {
+		return testSpec.matches( testCase ) && ( config.allowThrows() || !testCase.throws() );
+	}
+
+	void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions ) {
+		std::set<TestCase> seenFunctions;
+		for( auto const& function : functions ) {
+			auto prev = seenFunctions.insert( function );
+			CATCH_ENFORCE( prev.second,
+				"error: TEST_CASE( \"" << function.name << "\" ) already defined.\n"
+				<< "\tFirst seen at " << prev.first->getTestCaseInfo().lineInfo << "\n"
+				<< "\tRedefined at " << function.getTestCaseInfo().lineInfo );
+		}
+	}
+
+	std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
+		std::vector<TestCase> filtered;
+		filtered.reserve( testCases.size() );
+		for( auto const& testCase : testCases )
+			if( matchTest( testCase, testSpec, config ) )
+				filtered.push_back( testCase );
+		return filtered;
+	}
+	std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config ) {
+		return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config );
+	}
+
+	void TestRegistry::registerTest( TestCase const& testCase ) {
+		std::string name = testCase.getTestCaseInfo().name;
+		if( name.empty() ) {
+			ReusableStringStream rss;
+			rss << "Anonymous test case " << ++m_unnamedCount;
+			return registerTest( testCase.withName( rss.str() ) );
+		}
+		m_functions.push_back( testCase );
+	}
+
+	std::vector<TestCase> const& TestRegistry::getAllTests() const {
+		return m_functions;
+	}
+	std::vector<TestCase> const& TestRegistry::getAllTestsSorted( IConfig const& config ) const {
+		if( m_sortedFunctions.empty() )
+			enforceNoDuplicateTestCases( m_functions );
+
+		if(  m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) {
+			m_sortedFunctions = sortTests( config, m_functions );
+			m_currentSortOrder = config.runOrder();
+		}
+		return m_sortedFunctions;
+	}
+
+	///////////////////////////////////////////////////////////////////////////
+	TestInvokerAsFunction::TestInvokerAsFunction( void(*testAsFunction)() ) noexcept : m_testAsFunction( testAsFunction ) {}
+
+	void TestInvokerAsFunction::invoke() const {
+		m_testAsFunction();
+	}
+
+	std::string extractClassName( StringRef const& classOrQualifiedMethodName ) {
+		std::string className = classOrQualifiedMethodName;
+		if( startsWith( className, '&' ) )
+		{
+			std::size_t lastColons = className.rfind( "::" );
+			std::size_t penultimateColons = className.rfind( "::", lastColons-1 );
+			if( penultimateColons == std::string::npos )
+				penultimateColons = 1;
+			className = className.substr( penultimateColons, lastColons-penultimateColons );
+		}
+		return className;
+	}
+
+} // end namespace Catch
+  // end catch_test_case_registry_impl.cpp
+  // start catch_test_case_tracker.cpp
+
+#include <algorithm>
+#include <cassert>
+#include <stdexcept>
+#include <memory>
+#include <sstream>
+
+#if defined(__clang__)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wexit-time-destructors"
+#endif
+
+namespace Catch {
+	namespace TestCaseTracking {
+
+		NameAndLocation::NameAndLocation( std::string const& _name, SourceLineInfo const& _location )
+			:   name( _name ),
+			location( _location )
+		{}
+
+		ITracker::~ITracker() = default;
+
+		TrackerContext& TrackerContext::instance() {
+			static TrackerContext s_instance;
+			return s_instance;
+		}
+
+		ITracker& TrackerContext::startRun() {
+			m_rootTracker = std::make_shared<SectionTracker>( NameAndLocation( "{root}", CATCH_INTERNAL_LINEINFO ), *this, nullptr );
+			m_currentTracker = nullptr;
+			m_runState = Executing;
+			return *m_rootTracker;
+		}
+
+		void TrackerContext::endRun() {
+			m_rootTracker.reset();
+			m_currentTracker = nullptr;
+			m_runState = NotStarted;
+		}
+
+		void TrackerContext::startCycle() {
+			m_currentTracker = m_rootTracker.get();
+			m_runState = Executing;
+		}
+		void TrackerContext::completeCycle() {
+			m_runState = CompletedCycle;
+		}
+
+		bool TrackerContext::completedCycle() const {
+			return m_runState == CompletedCycle;
+		}
+		ITracker& TrackerContext::currentTracker() {
+			return *m_currentTracker;
+		}
+		void TrackerContext::setCurrentTracker( ITracker* tracker ) {
+			m_currentTracker = tracker;
+		}
+
+		TrackerBase::TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
+			:   m_nameAndLocation( nameAndLocation ),
+			m_ctx( ctx ),
+			m_parent( parent )
+		{}
+
+		NameAndLocation const& TrackerBase::nameAndLocation() const {
+			return m_nameAndLocation;
+		}
+		bool TrackerBase::isComplete() const {
+			return m_runState == CompletedSuccessfully || m_runState == Failed;
+		}
+		bool TrackerBase::isSuccessfullyCompleted() const {
+			return m_runState == CompletedSuccessfully;
+		}
+		bool TrackerBase::isOpen() const {
+			return m_runState != NotStarted && !isComplete();
+		}
+		bool TrackerBase::hasChildren() const {
+			return !m_children.empty();
+		}
+
+		void TrackerBase::addChild( ITrackerPtr const& child ) {
+			m_children.push_back( child );
+		}
+
+		ITrackerPtr TrackerBase::findChild( NameAndLocation const& nameAndLocation ) {
+			auto it = std::find_if( m_children.begin(), m_children.end(),
+				[&nameAndLocation]( ITrackerPtr const& tracker ){
+				return
+					tracker->nameAndLocation().location == nameAndLocation.location &&
+					tracker->nameAndLocation().name == nameAndLocation.name;
+			} );
+			return( it != m_children.end() )
+				? *it
+				: nullptr;
+		}
+		ITracker& TrackerBase::parent() {
+			assert( m_parent ); // Should always be non-null except for root
+			return *m_parent;
+		}
+
+		void TrackerBase::openChild() {
+			if( m_runState != ExecutingChildren ) {
+				m_runState = ExecutingChildren;
+				if( m_parent )
+					m_parent->openChild();
+			}
+		}
+
+		bool TrackerBase::isSectionTracker() const { return false; }
+		bool TrackerBase::isIndexTracker() const { return false; }
+
+		void TrackerBase::open() {
+			m_runState = Executing;
+			moveToThis();
+			if( m_parent )
+				m_parent->openChild();
+		}
+
+		void TrackerBase::close() {
+
+			// Close any still open children (e.g. generators)
+			while( &m_ctx.currentTracker() != this )
+				m_ctx.currentTracker().close();
+
+			switch( m_runState ) {
+			case NeedsAnotherRun:
+				break;
+
+			case Executing:
+				m_runState = CompletedSuccessfully;
+				break;
+			case ExecutingChildren:
+				if( m_children.empty() || m_children.back()->isComplete() )
+					m_runState = CompletedSuccessfully;
+				break;
+
+			case NotStarted:
+			case CompletedSuccessfully:
+			case Failed:
+				CATCH_INTERNAL_ERROR( "Illogical state: " << m_runState );
+
+			default:
+				CATCH_INTERNAL_ERROR( "Unknown state: " << m_runState );
+			}
+			moveToParent();
+			m_ctx.completeCycle();
+		}
+		void TrackerBase::fail() {
+			m_runState = Failed;
+			if( m_parent )
+				m_parent->markAsNeedingAnotherRun();
+			moveToParent();
+			m_ctx.completeCycle();
+		}
+		void TrackerBase::markAsNeedingAnotherRun() {
+			m_runState = NeedsAnotherRun;
+		}
+
+		void TrackerBase::moveToParent() {
+			assert( m_parent );
+			m_ctx.setCurrentTracker( m_parent );
+		}
+		void TrackerBase::moveToThis() {
+			m_ctx.setCurrentTracker( this );
+		}
+
+		SectionTracker::SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
+			:   TrackerBase( nameAndLocation, ctx, parent )
+		{
+			if( parent ) {
+				while( !parent->isSectionTracker() )
+					parent = &parent->parent();
+
+				SectionTracker& parentSection = static_cast<SectionTracker&>( *parent );
+				addNextFilters( parentSection.m_filters );
+			}
+		}
+
+		bool SectionTracker::isSectionTracker() const { return true; }
+
+		SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation ) {
+			std::shared_ptr<SectionTracker> section;
+
+			ITracker& currentTracker = ctx.currentTracker();
+			if( ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
+				assert( childTracker );
+				assert( childTracker->isSectionTracker() );
+				section = std::static_pointer_cast<SectionTracker>( childTracker );
+			}
+			else {
+				section = std::make_shared<SectionTracker>( nameAndLocation, ctx, &currentTracker );
+				currentTracker.addChild( section );
+			}
+			if( !ctx.completedCycle() )
+				section->tryOpen();
+			return *section;
+		}
+
+		void SectionTracker::tryOpen() {
+			if( !isComplete() && (m_filters.empty() || m_filters[0].empty() ||  m_filters[0] == m_nameAndLocation.name ) )
+				open();
+		}
+
+		void SectionTracker::addInitialFilters( std::vector<std::string> const& filters ) {
+			if( !filters.empty() ) {
+				m_filters.push_back(""); // Root - should never be consulted
+				m_filters.push_back(""); // Test Case - not a section filter
+				m_filters.insert( m_filters.end(), filters.begin(), filters.end() );
+			}
+		}
+		void SectionTracker::addNextFilters( std::vector<std::string> const& filters ) {
+			if( filters.size() > 1 )
+				m_filters.insert( m_filters.end(), ++filters.begin(), filters.end() );
+		}
+
+		IndexTracker::IndexTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent, int size )
+			:   TrackerBase( nameAndLocation, ctx, parent ),
+			m_size( size )
+		{}
+
+		bool IndexTracker::isIndexTracker() const { return true; }
+
+		IndexTracker& IndexTracker::acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation, int size ) {
+			std::shared_ptr<IndexTracker> tracker;
+
+			ITracker& currentTracker = ctx.currentTracker();
+			if( ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
+				assert( childTracker );
+				assert( childTracker->isIndexTracker() );
+				tracker = std::static_pointer_cast<IndexTracker>( childTracker );
+			}
+			else {
+				tracker = std::make_shared<IndexTracker>( nameAndLocation, ctx, &currentTracker, size );
+				currentTracker.addChild( tracker );
+			}
+
+			if( !ctx.completedCycle() && !tracker->isComplete() ) {
+				if( tracker->m_runState != ExecutingChildren && tracker->m_runState != NeedsAnotherRun )
+					tracker->moveNext();
+				tracker->open();
+			}
+
+			return *tracker;
+		}
+
+		int IndexTracker::index() const { return m_index; }
+
+		void IndexTracker::moveNext() {
+			m_index++;
+			m_children.clear();
+		}
+
+		void IndexTracker::close() {
+			TrackerBase::close();
+			if( m_runState == CompletedSuccessfully && m_index < m_size-1 )
+				m_runState = Executing;
+		}
+
+	} // namespace TestCaseTracking
+
+	using TestCaseTracking::ITracker;
+	using TestCaseTracking::TrackerContext;
+	using TestCaseTracking::SectionTracker;
+	using TestCaseTracking::IndexTracker;
+
+} // namespace Catch
+
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#endif
+  // end catch_test_case_tracker.cpp
+  // start catch_test_registry.cpp
+
+namespace Catch {
+
+	auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker* {
+		return new(std::nothrow) TestInvokerAsFunction( testAsFunction );
+	}
+
+	NameAndTags::NameAndTags( StringRef const& name_ , StringRef const& tags_ ) noexcept : name( name_ ), tags( tags_ ) {}
+
+	AutoReg::AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept {
+		CATCH_TRY {
+			getMutableRegistryHub()
+			.registerTest(
+				makeTestCase(
+					invoker,
+					extractClassName( classOrMethod ),
+					nameAndTags,
+					lineInfo));
+		} CATCH_CATCH_ALL {
+			// Do not throw when constructing global objects, instead register the exception to be processed later
+			getMutableRegistryHub().registerStartupException();
+		}
+	}
+
+	AutoReg::~AutoReg() = default;
+}
+// end catch_test_registry.cpp
+// start catch_test_spec.cpp
+
+#include <algorithm>
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace Catch {
+
+	TestSpec::Pattern::~Pattern() = default;
+	TestSpec::NamePattern::~NamePattern() = default;
+	TestSpec::TagPattern::~TagPattern() = default;
+	TestSpec::ExcludedPattern::~ExcludedPattern() = default;
+
+	TestSpec::NamePattern::NamePattern( std::string const& name )
+		: m_wildcardPattern( toLower( name ), CaseSensitive::No )
+	{}
+	bool TestSpec::NamePattern::matches( TestCaseInfo const& testCase ) const {
+		return m_wildcardPattern.matches( toLower( testCase.name ) );
+	}
+
+	TestSpec::TagPattern::TagPattern( std::string const& tag ) : m_tag( toLower( tag ) ) {}
+	bool TestSpec::TagPattern::matches( TestCaseInfo const& testCase ) const {
+		return std::find(begin(testCase.lcaseTags),
+			end(testCase.lcaseTags),
+			m_tag) != end(testCase.lcaseTags);
+	}
+
+	TestSpec::ExcludedPattern::ExcludedPattern( PatternPtr const& underlyingPattern ) : m_underlyingPattern( underlyingPattern ) {}
+	bool TestSpec::ExcludedPattern::matches( TestCaseInfo const& testCase ) const { return !m_underlyingPattern->matches( testCase ); }
+
+	bool TestSpec::Filter::matches( TestCaseInfo const& testCase ) const {
+		// All patterns in a filter must match for the filter to be a match
+		for( auto const& pattern : m_patterns ) {
+			if( !pattern->matches( testCase ) )
+				return false;
+		}
+		return true;
+	}
+
+	bool TestSpec::hasFilters() const {
+		return !m_filters.empty();
+	}
+	bool TestSpec::matches( TestCaseInfo const& testCase ) const {
+		// A TestSpec matches if any filter matches
+		for( auto const& filter : m_filters )
+			if( filter.matches( testCase ) )
+				return true;
+		return false;
+	}
+}
+// end catch_test_spec.cpp
+// start catch_test_spec_parser.cpp
+
+namespace Catch {
+
+	TestSpecParser::TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {}
+
+	TestSpecParser& TestSpecParser::parse( std::string const& arg ) {
+		m_mode = None;
+		m_exclusion = false;
+		m_start = std::string::npos;
+		m_arg = m_tagAliases->expandAliases( arg );
+		m_escapeChars.clear();
+		for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
+			visitChar( m_arg[m_pos] );
+		if( m_mode == Name )
+			addPattern<TestSpec::NamePattern>();
+		return *this;
+	}
+	TestSpec TestSpecParser::testSpec() {
+		addFilter();
+		return m_testSpec;
+	}
+
+	void TestSpecParser::visitChar( char c ) {
+		if( m_mode == None ) {
+			switch( c ) {
+			case ' ': return;
+			case '~': m_exclusion = true; return;
+			case '[': return startNewMode( Tag, ++m_pos );
+			case '"': return startNewMode( QuotedName, ++m_pos );
+			case '\\': return escape();
+			default: startNewMode( Name, m_pos ); break;
+			}
+		}
+		if( m_mode == Name ) {
+			if( c == ',' ) {
+				addPattern<TestSpec::NamePattern>();
+				addFilter();
+			}
+			else if( c == '[' ) {
+				if( subString() == "exclude:" )
+					m_exclusion = true;
+				else
+					addPattern<TestSpec::NamePattern>();
+				startNewMode( Tag, ++m_pos );
+			}
+			else if( c == '\\' )
+				escape();
+		}
+		else if( m_mode == EscapedName )
+			m_mode = Name;
+		else if( m_mode == QuotedName && c == '"' )
+			addPattern<TestSpec::NamePattern>();
+		else if( m_mode == Tag && c == ']' )
+			addPattern<TestSpec::TagPattern>();
+	}
+	void TestSpecParser::startNewMode( Mode mode, std::size_t start ) {
+		m_mode = mode;
+		m_start = start;
+	}
+	void TestSpecParser::escape() {
+		if( m_mode == None )
+			m_start = m_pos;
+		m_mode = EscapedName;
+		m_escapeChars.push_back( m_pos );
+	}
+	std::string TestSpecParser::subString() const { return m_arg.substr( m_start, m_pos - m_start ); }
+
+	void TestSpecParser::addFilter() {
+		if( !m_currentFilter.m_patterns.empty() ) {
+			m_testSpec.m_filters.push_back( m_currentFilter );
+			m_currentFilter = TestSpec::Filter();
+		}
+	}
+
+	TestSpec parseTestSpec( std::string const& arg ) {
+		return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec();
+	}
+
+} // namespace Catch
+  // end catch_test_spec_parser.cpp
+  // start catch_timer.cpp
+
+#include <chrono>
+
+static const uint64_t nanosecondsInSecond = 1000000000;
+
+namespace Catch {
+
+	auto getCurrentNanosecondsSinceEpoch() -> uint64_t {
+		return std::chrono::duration_cast<std::chrono::nanoseconds>( std::chrono::high_resolution_clock::now().time_since_epoch() ).count();
+	}
+
+	namespace {
+		auto estimateClockResolution() -> uint64_t {
+			uint64_t sum = 0;
+			static const uint64_t iterations = 1000000;
+
+			auto startTime = getCurrentNanosecondsSinceEpoch();
+
+			for( std::size_t i = 0; i < iterations; ++i ) {
+
+				uint64_t ticks;
+				uint64_t baseTicks = getCurrentNanosecondsSinceEpoch();
+				do {
+					ticks = getCurrentNanosecondsSinceEpoch();
+				} while( ticks == baseTicks );
+
+				auto delta = ticks - baseTicks;
+				sum += delta;
+
+				// If we have been calibrating for over 3 seconds -- the clock
+				// is terrible and we should move on.
+				// TBD: How to signal that the measured resolution is probably wrong?
+				if (ticks > startTime + 3 * nanosecondsInSecond) {
+					return sum / i;
+				}
+			}
+
+			// We're just taking the mean, here. To do better we could take the std. dev and exclude outliers
+			// - and potentially do more iterations if there's a high variance.
+			return sum/iterations;
+		}
+	}
+	auto getEstimatedClockResolution() -> uint64_t {
+		static auto s_resolution = estimateClockResolution();
+		return s_resolution;
+	}
+
+	void Timer::start() {
+		m_nanoseconds = getCurrentNanosecondsSinceEpoch();
+	}
+	auto Timer::getElapsedNanoseconds() const -> uint64_t {
+		return getCurrentNanosecondsSinceEpoch() - m_nanoseconds;
+	}
+	auto Timer::getElapsedMicroseconds() const -> uint64_t {
+		return getElapsedNanoseconds()/1000;
+	}
+	auto Timer::getElapsedMilliseconds() const -> unsigned int {
+		return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
+	}
+	auto Timer::getElapsedSeconds() const -> double {
+		return getElapsedMicroseconds()/1000000.0;
+	}
+
+} // namespace Catch
+  // end catch_timer.cpp
+  // start catch_tostring.cpp
+
+#if defined(__clang__)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wexit-time-destructors"
+#    pragma clang diagnostic ignored "-Wglobal-constructors"
+#endif
+
+  // Enable specific decls locally
+#if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
+#define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
+#endif
+
+#include <cmath>
+#include <iomanip>
+
+namespace Catch {
+
+	namespace Detail {
+
+		const std::string unprintableString = "{?}";
+
+		namespace {
+			const int hexThreshold = 255;
+
+			struct Endianness {
+				enum Arch { Big, Little };
+
+				static Arch which() {
+					union _{
+						int asInt;
+						char asChar[sizeof (int)];
+					} u;
+
+					u.asInt = 1;
+					return ( u.asChar[sizeof(int)-1] == 1 ) ? Big : Little;
+				}
+			};
+		}
+
+		std::string rawMemoryToString( const void *object, std::size_t size ) {
+			// Reverse order for little endian architectures
+			int i = 0, end = static_cast<int>( size ), inc = 1;
+			if( Endianness::which() == Endianness::Little ) {
+				i = end-1;
+				end = inc = -1;
+			}
+
+			unsigned char const *bytes = static_cast<unsigned char const *>(object);
+			ReusableStringStream rss;
+			rss << "0x" << std::setfill('0') << std::hex;
+			for( ; i != end; i += inc )
+				rss << std::setw(2) << static_cast<unsigned>(bytes[i]);
+			return rss.str();
+		}
+	}
+
+	template<typename T>
+	std::string fpToString( T value, int precision ) {
+		if (Catch::isnan(value)) {
+			return "nan";
+		}
+
+		ReusableStringStream rss;
+		rss << std::setprecision( precision )
+			<< std::fixed
+			<< value;
+		std::string d = rss.str();
+		std::size_t i = d.find_last_not_of( '0' );
+		if( i != std::string::npos && i != d.size()-1 ) {
+			if( d[i] == '.' )
+				i++;
+			d = d.substr( 0, i+1 );
+		}
+		return d;
+	}
+
+	//// ======================================================= ////
+	//
+	//   Out-of-line defs for full specialization of StringMaker
+	//
+	//// ======================================================= ////
+
+	std::string StringMaker<std::string>::convert(const std::string& str) {
+		if (!getCurrentContext().getConfig()->showInvisibles()) {
+			return '"' + str + '"';
+		}
+
+		std::string s("\"");
+		for (char c : str) {
+			switch (c) {
+			case '\n':
+				s.append("\\n");
+				break;
+			case '\t':
+				s.append("\\t");
+				break;
+			default:
+				s.push_back(c);
+				break;
+			}
+		}
+		s.append("\"");
+		return s;
+	}
+
+#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+	std::string StringMaker<std::string_view>::convert(std::string_view str) {
+		return ::Catch::Detail::stringify(std::string{ str });
+	}
+#endif
+
+	std::string StringMaker<char const*>::convert(char const* str) {
+		if (str) {
+			return ::Catch::Detail::stringify(std::string{ str });
+		} else {
+			return{ "{null string}" };
+		}
+	}
+	std::string StringMaker<char*>::convert(char* str) {
+		if (str) {
+			return ::Catch::Detail::stringify(std::string{ str });
+		} else {
+			return{ "{null string}" };
+		}
+	}
+
+#ifdef CATCH_CONFIG_WCHAR
+	std::string StringMaker<std::wstring>::convert(const std::wstring& wstr) {
+		std::string s;
+		s.reserve(wstr.size());
+		for (auto c : wstr) {
+			s += (c <= 0xff) ? static_cast<char>(c) : '?';
+		}
+		return ::Catch::Detail::stringify(s);
+	}
+
+# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+	std::string StringMaker<std::wstring_view>::convert(std::wstring_view str) {
+		return StringMaker<std::wstring>::convert(std::wstring(str));
+	}
+# endif
+
+	std::string StringMaker<wchar_t const*>::convert(wchar_t const * str) {
+		if (str) {
+			return ::Catch::Detail::stringify(std::wstring{ str });
+		} else {
+			return{ "{null string}" };
+		}
+	}
+	std::string StringMaker<wchar_t *>::convert(wchar_t * str) {
+		if (str) {
+			return ::Catch::Detail::stringify(std::wstring{ str });
+		} else {
+			return{ "{null string}" };
+		}
+	}
+#endif
+
+	std::string StringMaker<int>::convert(int value) {
+		return ::Catch::Detail::stringify(static_cast<long long>(value));
+	}
+	std::string StringMaker<long>::convert(long value) {
+		return ::Catch::Detail::stringify(static_cast<long long>(value));
+	}
+	std::string StringMaker<long long>::convert(long long value) {
+		ReusableStringStream rss;
+		rss << value;
+		if (value > Detail::hexThreshold) {
+			rss << " (0x" << std::hex << value << ')';
+		}
+		return rss.str();
+	}
+
+	std::string StringMaker<unsigned int>::convert(unsigned int value) {
+		return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
+	}
+	std::string StringMaker<unsigned long>::convert(unsigned long value) {
+		return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
+	}
+	std::string StringMaker<unsigned long long>::convert(unsigned long long value) {
+		ReusableStringStream rss;
+		rss << value;
+		if (value > Detail::hexThreshold) {
+			rss << " (0x" << std::hex << value << ')';
+		}
+		return rss.str();
+	}
+
+	std::string StringMaker<bool>::convert(bool b) {
+		return b ? "true" : "false";
+	}
+
+	std::string StringMaker<signed char>::convert(signed char value) {
+		if (value == '\r') {
+			return "'\\r'";
+		} else if (value == '\f') {
+			return "'\\f'";
+		} else if (value == '\n') {
+			return "'\\n'";
+		} else if (value == '\t') {
+			return "'\\t'";
+		} else if ('\0' <= value && value < ' ') {
+			return ::Catch::Detail::stringify(static_cast<unsigned int>(value));
+		} else {
+			char chstr[] = "' '";
+			chstr[1] = value;
+			return chstr;
+		}
+	}
+	std::string StringMaker<char>::convert(char c) {
+		return ::Catch::Detail::stringify(static_cast<signed char>(c));
+	}
+	std::string StringMaker<unsigned char>::convert(unsigned char c) {
+		return ::Catch::Detail::stringify(static_cast<char>(c));
+	}
+
+	std::string StringMaker<std::nullptr_t>::convert(std::nullptr_t) {
+		return "nullptr";
+	}
+
+	std::string StringMaker<float>::convert(float value) {
+		return fpToString(value, 5) + 'f';
+	}
+	std::string StringMaker<double>::convert(double value) {
+		return fpToString(value, 10);
+	}
+
+	std::string ratio_string<std::atto>::symbol() { return "a"; }
+	std::string ratio_string<std::femto>::symbol() { return "f"; }
+	std::string ratio_string<std::pico>::symbol() { return "p"; }
+	std::string ratio_string<std::nano>::symbol() { return "n"; }
+	std::string ratio_string<std::micro>::symbol() { return "u"; }
+	std::string ratio_string<std::milli>::symbol() { return "m"; }
+
+} // end namespace Catch
+
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#endif
+
+  // end catch_tostring.cpp
+  // start catch_totals.cpp
+
+namespace Catch {
+
+	Counts Counts::operator - ( Counts const& other ) const {
+		Counts diff;
+		diff.passed = passed - other.passed;
+		diff.failed = failed - other.failed;
+		diff.failedButOk = failedButOk - other.failedButOk;
+		return diff;
+	}
+
+	Counts& Counts::operator += ( Counts const& other ) {
+		passed += other.passed;
+		failed += other.failed;
+		failedButOk += other.failedButOk;
+		return *this;
+	}
+
+	std::size_t Counts::total() const {
+		return passed + failed + failedButOk;
+	}
+	bool Counts::allPassed() const {
+		return failed == 0 && failedButOk == 0;
+	}
+	bool Counts::allOk() const {
+		return failed == 0;
+	}
+
+	Totals Totals::operator - ( Totals const& other ) const {
+		Totals diff;
+		diff.assertions = assertions - other.assertions;
+		diff.testCases = testCases - other.testCases;
+		return diff;
+	}
+
+	Totals& Totals::operator += ( Totals const& other ) {
+		assertions += other.assertions;
+		testCases += other.testCases;
+		return *this;
+	}
+
+	Totals Totals::delta( Totals const& prevTotals ) const {
+		Totals diff = *this - prevTotals;
+		if( diff.assertions.failed > 0 )
+			++diff.testCases.failed;
+		else if( diff.assertions.failedButOk > 0 )
+			++diff.testCases.failedButOk;
+		else
+			++diff.testCases.passed;
+		return diff;
+	}
+
+}
+// end catch_totals.cpp
+// start catch_uncaught_exceptions.cpp
+
+#include <exception>
+
+namespace Catch {
+	bool uncaught_exceptions() {
+#if defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
+		return std::uncaught_exceptions() > 0;
+#else
+		return std::uncaught_exception();
+#endif
+	}
+} // end namespace Catch
+  // end catch_uncaught_exceptions.cpp
+  // start catch_version.cpp
+
+#include <ostream>
+
+namespace Catch {
+
+	Version::Version
+	(   unsigned int _majorVersion,
+		unsigned int _minorVersion,
+		unsigned int _patchNumber,
+		char const * const _branchName,
+		unsigned int _buildNumber )
+		:   majorVersion( _majorVersion ),
+		minorVersion( _minorVersion ),
+		patchNumber( _patchNumber ),
+		branchName( _branchName ),
+		buildNumber( _buildNumber )
+	{}
+
+	std::ostream& operator << ( std::ostream& os, Version const& version ) {
+		os  << version.majorVersion << '.'
+			<< version.minorVersion << '.'
+			<< version.patchNumber;
+		// branchName is never null -> 0th char is \0 if it is empty
+		if (version.branchName[0]) {
+			os << '-' << version.branchName
+				<< '.' << version.buildNumber;
+		}
+		return os;
+	}
+
+	Version const& libraryVersion() {
+		static Version version( 2, 5, 0, "", 0 );
+		return version;
+	}
+
+}
+// end catch_version.cpp
+// start catch_wildcard_pattern.cpp
+
+#include <sstream>
+
+namespace Catch {
+
+	WildcardPattern::WildcardPattern( std::string const& pattern,
+		CaseSensitive::Choice caseSensitivity )
+		:   m_caseSensitivity( caseSensitivity ),
+		m_pattern( adjustCase( pattern ) )
+	{
+		if( startsWith( m_pattern, '*' ) ) {
+			m_pattern = m_pattern.substr( 1 );
+			m_wildcard = WildcardAtStart;
+		}
+		if( endsWith( m_pattern, '*' ) ) {
+			m_pattern = m_pattern.substr( 0, m_pattern.size()-1 );
+			m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
+		}
+	}
+
+	bool WildcardPattern::matches( std::string const& str ) const {
+		switch( m_wildcard ) {
+		case NoWildcard:
+			return m_pattern == adjustCase( str );
+		case WildcardAtStart:
+			return endsWith( adjustCase( str ), m_pattern );
+		case WildcardAtEnd:
+			return startsWith( adjustCase( str ), m_pattern );
+		case WildcardAtBothEnds:
+			return contains( adjustCase( str ), m_pattern );
+		default:
+			CATCH_INTERNAL_ERROR( "Unknown enum" );
+		}
+	}
+
+	std::string WildcardPattern::adjustCase( std::string const& str ) const {
+		return m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str;
+	}
+}
+// end catch_wildcard_pattern.cpp
+// start catch_xmlwriter.cpp
+
+#include <iomanip>
+
+using uchar = unsigned char;
+
+namespace Catch {
+
+	namespace {
+
+		size_t trailingBytes(unsigned char c) {
+			if ((c & 0xE0) == 0xC0) {
+				return 2;
+			}
+			if ((c & 0xF0) == 0xE0) {
+				return 3;
+			}
+			if ((c & 0xF8) == 0xF0) {
+				return 4;
+			}
+			CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
+		}
+
+		uint32_t headerValue(unsigned char c) {
+			if ((c & 0xE0) == 0xC0) {
+				return c & 0x1F;
+			}
+			if ((c & 0xF0) == 0xE0) {
+				return c & 0x0F;
+			}
+			if ((c & 0xF8) == 0xF0) {
+				return c & 0x07;
+			}
+			CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
+		}
+
+		void hexEscapeChar(std::ostream& os, unsigned char c) {
+			os << "\\x"
+				<< std::uppercase << std::hex << std::setfill('0') << std::setw(2)
+				<< static_cast<int>(c);
+		}
+
+	} // anonymous namespace
+
+	XmlEncode::XmlEncode( std::string const& str, ForWhat forWhat )
+		:   m_str( str ),
+		m_forWhat( forWhat )
+	{}
+
+	void XmlEncode::encodeTo( std::ostream& os ) const {
+		// Apostrophe escaping not necessary if we always use " to write attributes
+		// (see: http://www.w3.org/TR/xml/#syntax)
+
+		for( std::size_t idx = 0; idx < m_str.size(); ++ idx ) {
+			uchar c = m_str[idx];
+			switch (c) {
+			case '<':   os << "&lt;"; break;
+			case '&':   os << "&amp;"; break;
+
+			case '>':
+				// See: http://www.w3.org/TR/xml/#syntax
+				if (idx > 2 && m_str[idx - 1] == ']' && m_str[idx - 2] == ']')
+					os << "&gt;";
+				else
+					os << c;
+				break;
+
+			case '\"':
+				if (m_forWhat == ForAttributes)
+					os << "&quot;";
+				else
+					os << c;
+				break;
+
+			default:
+				// Check for control characters and invalid utf-8
+
+				// Escape control characters in standard ascii
+				// see http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
+				if (c < 0x09 || (c > 0x0D && c < 0x20) || c == 0x7F) {
+					hexEscapeChar(os, c);
+					break;
+				}
+
+				// Plain ASCII: Write it to stream
+				if (c < 0x7F) {
+					os << c;
+					break;
+				}
+
+				// UTF-8 territory
+				// Check if the encoding is valid and if it is not, hex escape bytes.
+				// Important: We do not check the exact decoded values for validity, only the encoding format
+				// First check that this bytes is a valid lead byte:
+				// This means that it is not encoded as 1111 1XXX
+				// Or as 10XX XXXX
+				if (c <  0xC0 ||
+					c >= 0xF8) {
+					hexEscapeChar(os, c);
+					break;
+				}
+
+				auto encBytes = trailingBytes(c);
+				// Are there enough bytes left to avoid accessing out-of-bounds memory?
+				if (idx + encBytes - 1 >= m_str.size()) {
+					hexEscapeChar(os, c);
+					break;
+				}
+				// The header is valid, check data
+				// The next encBytes bytes must together be a valid utf-8
+				// This means: bitpattern 10XX XXXX and the extracted value is sane (ish)
+				bool valid = true;
+				uint32_t value = headerValue(c);
+				for (std::size_t n = 1; n < encBytes; ++n) {
+					uchar nc = m_str[idx + n];
+					valid &= ((nc & 0xC0) == 0x80);
+					value = (value << 6) | (nc & 0x3F);
+				}
+
+				if (
+					// Wrong bit pattern of following bytes
+					(!valid) ||
+					// Overlong encodings
+					(value < 0x80) ||
+					(0x80 <= value && value < 0x800   && encBytes > 2) ||
+					(0x800 < value && value < 0x10000 && encBytes > 3) ||
+					// Encoded value out of range
+					(value >= 0x110000)
+					) {
+					hexEscapeChar(os, c);
+					break;
+				}
+
+				// If we got here, this is in fact a valid(ish) utf-8 sequence
+				for (std::size_t n = 0; n < encBytes; ++n) {
+					os << m_str[idx + n];
+				}
+				idx += encBytes - 1;
+				break;
+			}
+		}
+	}
+
+	std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
+		xmlEncode.encodeTo( os );
+		return os;
+	}
+
+	XmlWriter::ScopedElement::ScopedElement( XmlWriter* writer )
+		:   m_writer( writer )
+	{}
+
+	XmlWriter::ScopedElement::ScopedElement( ScopedElement&& other ) noexcept
+		:   m_writer( other.m_writer ){
+		other.m_writer = nullptr;
+	}
+	XmlWriter::ScopedElement& XmlWriter::ScopedElement::operator=( ScopedElement&& other ) noexcept {
+		if ( m_writer ) {
+			m_writer->endElement();
+		}
+		m_writer = other.m_writer;
+		other.m_writer = nullptr;
+		return *this;
+	}
+
+	XmlWriter::ScopedElement::~ScopedElement() {
+		if( m_writer )
+			m_writer->endElement();
+	}
+
+	XmlWriter::ScopedElement& XmlWriter::ScopedElement::writeText( std::string const& text, bool indent ) {
+		m_writer->writeText( text, indent );
+		return *this;
+	}
+
+	XmlWriter::XmlWriter( std::ostream& os ) : m_os( os )
+	{
+		writeDeclaration();
+	}
+
+	XmlWriter::~XmlWriter() {
+		while( !m_tags.empty() )
+			endElement();
+	}
+
+	XmlWriter& XmlWriter::startElement( std::string const& name ) {
+		ensureTagClosed();
+		newlineIfNecessary();
+		m_os << m_indent << '<' << name;
+		m_tags.push_back( name );
+		m_indent += "  ";
+		m_tagIsOpen = true;
+		return *this;
+	}
+
+	XmlWriter::ScopedElement XmlWriter::scopedElement( std::string const& name ) {
+		ScopedElement scoped( this );
+		startElement( name );
+		return scoped;
+	}
+
+	XmlWriter& XmlWriter::endElement() {
+		newlineIfNecessary();
+		m_indent = m_indent.substr( 0, m_indent.size()-2 );
+		if( m_tagIsOpen ) {
+			m_os << "/>";
+			m_tagIsOpen = false;
+		}
+		else {
+			m_os << m_indent << "</" << m_tags.back() << ">";
+		}
+		m_os << std::endl;
+		m_tags.pop_back();
+		return *this;
+	}
+
+	XmlWriter& XmlWriter::writeAttribute( std::string const& name, std::string const& attribute ) {
+		if( !name.empty() && !attribute.empty() )
+			m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
+		return *this;
+	}
+
+	XmlWriter& XmlWriter::writeAttribute( std::string const& name, bool attribute ) {
+		m_os << ' ' << name << "=\"" << ( attribute ? "true" : "false" ) << '"';
+		return *this;
+	}
+
+	XmlWriter& XmlWriter::writeText( std::string const& text, bool indent ) {
+		if( !text.empty() ){
+			bool tagWasOpen = m_tagIsOpen;
+			ensureTagClosed();
+			if( tagWasOpen && indent )
+				m_os << m_indent;
+			m_os << XmlEncode( text );
+			m_needsNewline = true;
+		}
+		return *this;
+	}
+
+	XmlWriter& XmlWriter::writeComment( std::string const& text ) {
+		ensureTagClosed();
+		m_os << m_indent << "<!--" << text << "-->";
+		m_needsNewline = true;
+		return *this;
+	}
+
+	void XmlWriter::writeStylesheetRef( std::string const& url ) {
+		m_os << "<?xml-stylesheet type=\"text/xsl\" href=\"" << url << "\"?>\n";
+	}
+
+	XmlWriter& XmlWriter::writeBlankLine() {
+		ensureTagClosed();
+		m_os << '\n';
+		return *this;
+	}
+
+	void XmlWriter::ensureTagClosed() {
+		if( m_tagIsOpen ) {
+			m_os << ">" << std::endl;
+			m_tagIsOpen = false;
+		}
+	}
+
+	void XmlWriter::writeDeclaration() {
+		m_os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+	}
+
+	void XmlWriter::newlineIfNecessary() {
+		if( m_needsNewline ) {
+			m_os << std::endl;
+			m_needsNewline = false;
+		}
+	}
+}
+// end catch_xmlwriter.cpp
+// start catch_reporter_bases.cpp
+
+#include <cstring>
+#include <cfloat>
+#include <cstdio>
+#include <cassert>
+#include <memory>
+
+namespace Catch {
+	void prepareExpandedExpression(AssertionResult& result) {
+		result.getExpandedExpression();
+	}
+
+	// Because formatting using c++ streams is stateful, drop down to C is required
+	// Alternatively we could use stringstream, but its performance is... not good.
+	std::string getFormattedDuration( double duration ) {
+		// Max exponent + 1 is required to represent the whole part
+		// + 1 for decimal point
+		// + 3 for the 3 decimal places
+		// + 1 for null terminator
+		const std::size_t maxDoubleSize = DBL_MAX_10_EXP + 1 + 1 + 3 + 1;
+		char buffer[maxDoubleSize];
+
+		// Save previous errno, to prevent sprintf from overwriting it
+		ErrnoGuard guard;
+#ifdef _MSC_VER
+		sprintf_s(buffer, "%.3f", duration);
+#else
+		sprintf(buffer, "%.3f", duration);
+#endif
+		return std::string(buffer);
+	}
+
+	TestEventListenerBase::TestEventListenerBase(ReporterConfig const & _config)
+		:StreamingReporterBase(_config) {}
+
+	std::set<Verbosity> TestEventListenerBase::getSupportedVerbosities() {
+		return { Verbosity::Quiet, Verbosity::Normal, Verbosity::High };
+	}
+
+	void TestEventListenerBase::assertionStarting(AssertionInfo const &) {}
+
+	bool TestEventListenerBase::assertionEnded(AssertionStats const &) {
+		return false;
+	}
+
+} // end namespace Catch
+  // end catch_reporter_bases.cpp
+  // start catch_reporter_compact.cpp
+
+namespace {
+
+#ifdef CATCH_PLATFORM_MAC
+	const char* failedString() { return "FAILED"; }
+	const char* passedString() { return "PASSED"; }
+#else
+	const char* failedString() { return "failed"; }
+	const char* passedString() { return "passed"; }
+#endif
 
-} // end namespace Catch
-// end catch_test_case_info.cpp
-// start catch_test_case_registry_impl.cpp
+	// Colour::LightGrey
+	Catch::Colour::Code dimColour() { return Catch::Colour::FileName; }
 
-#include <sstream>
+	std::string bothOrAll( std::size_t count ) {
+		return count == 1 ? std::string() :
+			count == 2 ? "both " : "all " ;
+	}
 
-namespace Catch {
+} // anon namespace
+
+namespace Catch {
+	namespace {
+		// Colour, message variants:
+		// - white: No tests ran.
+		// -   red: Failed [both/all] N test cases, failed [both/all] M assertions.
+		// - white: Passed [both/all] N test cases (no assertions).
+		// -   red: Failed N tests cases, failed M assertions.
+		// - green: Passed [both/all] N tests cases with M assertions.
+		void printTotals(std::ostream& out, const Totals& totals) {
+			if (totals.testCases.total() == 0) {
+				out << "No tests ran.";
+			} else if (totals.testCases.failed == totals.testCases.total()) {
+				Colour colour(Colour::ResultError);
+				const std::string qualify_assertions_failed =
+					totals.assertions.failed == totals.assertions.total() ?
+					bothOrAll(totals.assertions.failed) : std::string();
+				out <<
+					"Failed " << bothOrAll(totals.testCases.failed)
+					<< pluralise(totals.testCases.failed, "test case") << ", "
+					"failed " << qualify_assertions_failed <<
+					pluralise(totals.assertions.failed, "assertion") << '.';
+			} else if (totals.assertions.total() == 0) {
+				out <<
+					"Passed " << bothOrAll(totals.testCases.total())
+					<< pluralise(totals.testCases.total(), "test case")
+					<< " (no assertions).";
+			} else if (totals.assertions.failed) {
+				Colour colour(Colour::ResultError);
+				out <<
+					"Failed " << pluralise(totals.testCases.failed, "test case") << ", "
+					"failed " << pluralise(totals.assertions.failed, "assertion") << '.';
+			} else {
+				Colour colour(Colour::ResultSuccess);
+				out <<
+					"Passed " << bothOrAll(totals.testCases.passed)
+					<< pluralise(totals.testCases.passed, "test case") <<
+					" with " << pluralise(totals.assertions.passed, "assertion") << '.';
+			}
+		}
+
+		// Implementation of CompactReporter formatting
+		class AssertionPrinter {
+		public:
+			AssertionPrinter& operator= (AssertionPrinter const&) = delete;
+			AssertionPrinter(AssertionPrinter const&) = delete;
+			AssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages)
+				: stream(_stream)
+				, result(_stats.assertionResult)
+				, messages(_stats.infoMessages)
+				, itMessage(_stats.infoMessages.begin())
+				, printInfoMessages(_printInfoMessages) {}
+
+			void print() {
+				printSourceInfo();
+
+				itMessage = messages.begin();
+
+				switch (result.getResultType()) {
+				case ResultWas::Ok:
+					printResultType(Colour::ResultSuccess, passedString());
+					printOriginalExpression();
+					printReconstructedExpression();
+					if (!result.hasExpression())
+						printRemainingMessages(Colour::None);
+					else
+						printRemainingMessages();
+					break;
+				case ResultWas::ExpressionFailed:
+					if (result.isOk())
+						printResultType(Colour::ResultSuccess, failedString() + std::string(" - but was ok"));
+					else
+						printResultType(Colour::Error, failedString());
+					printOriginalExpression();
+					printReconstructedExpression();
+					printRemainingMessages();
+					break;
+				case ResultWas::ThrewException:
+					printResultType(Colour::Error, failedString());
+					printIssue("unexpected exception with message:");
+					printMessage();
+					printExpressionWas();
+					printRemainingMessages();
+					break;
+				case ResultWas::FatalErrorCondition:
+					printResultType(Colour::Error, failedString());
+					printIssue("fatal error condition with message:");
+					printMessage();
+					printExpressionWas();
+					printRemainingMessages();
+					break;
+				case ResultWas::DidntThrowException:
+					printResultType(Colour::Error, failedString());
+					printIssue("expected exception, got none");
+					printExpressionWas();
+					printRemainingMessages();
+					break;
+				case ResultWas::Info:
+					printResultType(Colour::None, "info");
+					printMessage();
+					printRemainingMessages();
+					break;
+				case ResultWas::Warning:
+					printResultType(Colour::None, "warning");
+					printMessage();
+					printRemainingMessages();
+					break;
+				case ResultWas::ExplicitFailure:
+					printResultType(Colour::Error, failedString());
+					printIssue("explicitly");
+					printRemainingMessages(Colour::None);
+					break;
+					// These cases are here to prevent compiler warnings
+				case ResultWas::Unknown:
+				case ResultWas::FailureBit:
+				case ResultWas::Exception:
+					printResultType(Colour::Error, "** internal error **");
+					break;
+				}
+			}
+
+		private:
+			void printSourceInfo() const {
+				Colour colourGuard(Colour::FileName);
+				stream << result.getSourceInfo() << ':';
+			}
+
+			void printResultType(Colour::Code colour, std::string const& passOrFail) const {
+				if (!passOrFail.empty()) {
+					{
+						Colour colourGuard(colour);
+						stream << ' ' << passOrFail;
+					}
+					stream << ':';
+				}
+			}
+
+			void printIssue(std::string const& issue) const {
+				stream << ' ' << issue;
+			}
+
+			void printExpressionWas() {
+				if (result.hasExpression()) {
+					stream << ';';
+					{
+						Colour colour(dimColour());
+						stream << " expression was:";
+					}
+					printOriginalExpression();
+				}
+			}
+
+			void printOriginalExpression() const {
+				if (result.hasExpression()) {
+					stream << ' ' << result.getExpression();
+				}
+			}
+
+			void printReconstructedExpression() const {
+				if (result.hasExpandedExpression()) {
+					{
+						Colour colour(dimColour());
+						stream << " for: ";
+					}
+					stream << result.getExpandedExpression();
+				}
+			}
+
+			void printMessage() {
+				if (itMessage != messages.end()) {
+					stream << " '" << itMessage->message << '\'';
+					++itMessage;
+				}
+			}
+
+			void printRemainingMessages(Colour::Code colour = dimColour()) {
+				if (itMessage == messages.end())
+					return;
+
+				// using messages.end() directly yields (or auto) compilation error:
+				std::vector<MessageInfo>::const_iterator itEnd = messages.end();
+				const std::size_t N = static_cast<std::size_t>(std::distance(itMessage, itEnd));
+
+				{
+					Colour colourGuard(colour);
+					stream << " with " << pluralise(N, "message") << ':';
+				}
+
+				for (; itMessage != itEnd; ) {
+					// If this assertion is a warning ignore any INFO messages
+					if (printInfoMessages || itMessage->type != ResultWas::Info) {
+						stream << " '" << itMessage->message << '\'';
+						if (++itMessage != itEnd) {
+							Colour colourGuard(dimColour());
+							stream << " and";
+						}
+					}
+				}
+			}
+
+		private:
+			std::ostream& stream;
+			AssertionResult const& result;
+			std::vector<MessageInfo> messages;
+			std::vector<MessageInfo>::const_iterator itMessage;
+			bool printInfoMessages;
+		};
+
+	} // anon namespace
+
+	std::string CompactReporter::getDescription() {
+		return "Reports test results on a single line, suitable for IDEs";
+	}
 
-    std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases ) {
-
-        std::vector<TestCase> sorted = unsortedTestCases;
-
-        switch( config.runOrder() ) {
-            case RunTests::InLexicographicalOrder:
-                std::sort( sorted.begin(), sorted.end() );
-                break;
-            case RunTests::InRandomOrder:
-                seedRng( config );
-                RandomNumberGenerator::shuffle( sorted );
-                break;
-            case RunTests::InDeclarationOrder:
-                // already in declaration order
-                break;
-        }
-        return sorted;
-    }
-    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config ) {
-        return testSpec.matches( testCase ) && ( config.allowThrows() || !testCase.throws() );
-    }
-
-    void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions ) {
-        std::set<TestCase> seenFunctions;
-        for( auto const& function : functions ) {
-            auto prev = seenFunctions.insert( function );
-            CATCH_ENFORCE( prev.second,
-                    "error: TEST_CASE( \"" << function.name << "\" ) already defined.\n"
-                    << "\tFirst seen at " << prev.first->getTestCaseInfo().lineInfo << "\n"
-                    << "\tRedefined at " << function.getTestCaseInfo().lineInfo );
-        }
-    }
-
-    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
-        std::vector<TestCase> filtered;
-        filtered.reserve( testCases.size() );
-        for( auto const& testCase : testCases )
-            if( matchTest( testCase, testSpec, config ) )
-                filtered.push_back( testCase );
-        return filtered;
-    }
-    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config ) {
-        return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config );
-    }
-
-    void TestRegistry::registerTest( TestCase const& testCase ) {
-        std::string name = testCase.getTestCaseInfo().name;
-        if( name.empty() ) {
-            std::ostringstream oss;
-            oss << "Anonymous test case " << ++m_unnamedCount;
-            return registerTest( testCase.withName( oss.str() ) );
-        }
-        m_functions.push_back( testCase );
-    }
-
-    std::vector<TestCase> const& TestRegistry::getAllTests() const {
-        return m_functions;
-    }
-    std::vector<TestCase> const& TestRegistry::getAllTestsSorted( IConfig const& config ) const {
-        if( m_sortedFunctions.empty() )
-            enforceNoDuplicateTestCases( m_functions );
-
-        if(  m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) {
-            m_sortedFunctions = sortTests( config, m_functions );
-            m_currentSortOrder = config.runOrder();
-        }
-        return m_sortedFunctions;
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    TestInvokerAsFunction::TestInvokerAsFunction( void(*testAsFunction)() ) noexcept : m_testAsFunction( testAsFunction ) {}
-
-    void TestInvokerAsFunction::invoke() const {
-        m_testAsFunction();
-    }
-
-    std::string extractClassName( std::string const& classOrQualifiedMethodName ) {
-        std::string className = classOrQualifiedMethodName;
-        if( startsWith( className, '&' ) )
-        {
-            std::size_t lastColons = className.rfind( "::" );
-            std::size_t penultimateColons = className.rfind( "::", lastColons-1 );
-            if( penultimateColons == std::string::npos )
-                penultimateColons = 1;
-            className = className.substr( penultimateColons, lastColons-penultimateColons );
-        }
-        return className;
-    }
+	ReporterPreferences CompactReporter::getPreferences() const {
+		return m_reporterPrefs;
+	}
 
-} // end namespace Catch
-// end catch_test_case_registry_impl.cpp
-// start catch_test_case_tracker.cpp
+	void CompactReporter::noMatchingTestCases( std::string const& spec ) {
+		stream << "No test cases matched '" << spec << '\'' << std::endl;
+	}
 
-#include <algorithm>
-#include <assert.h>
-#include <stdexcept>
-#include <memory>
+	void CompactReporter::assertionStarting( AssertionInfo const& ) {}
 
-#if defined(__clang__)
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wexit-time-destructors"
-#endif
+	bool CompactReporter::assertionEnded( AssertionStats const& _assertionStats ) {
+		AssertionResult const& result = _assertionStats.assertionResult;
 
-namespace Catch {
-namespace TestCaseTracking {
-
-    NameAndLocation::NameAndLocation( std::string const& _name, SourceLineInfo const& _location )
-    :   name( _name ),
-        location( _location )
-    {}
-
-    ITracker::~ITracker() = default;
-
-    TrackerContext& TrackerContext::instance() {
-        static TrackerContext s_instance;
-        return s_instance;
-    }
-
-    ITracker& TrackerContext::startRun() {
-        m_rootTracker = std::make_shared<SectionTracker>( NameAndLocation( "{root}", CATCH_INTERNAL_LINEINFO ), *this, nullptr );
-        m_currentTracker = nullptr;
-        m_runState = Executing;
-        return *m_rootTracker;
-    }
-
-    void TrackerContext::endRun() {
-        m_rootTracker.reset();
-        m_currentTracker = nullptr;
-        m_runState = NotStarted;
-    }
-
-    void TrackerContext::startCycle() {
-        m_currentTracker = m_rootTracker.get();
-        m_runState = Executing;
-    }
-    void TrackerContext::completeCycle() {
-        m_runState = CompletedCycle;
-    }
-
-    bool TrackerContext::completedCycle() const {
-        return m_runState == CompletedCycle;
-    }
-    ITracker& TrackerContext::currentTracker() {
-        return *m_currentTracker;
-    }
-    void TrackerContext::setCurrentTracker( ITracker* tracker ) {
-        m_currentTracker = tracker;
-    }
-
-    TrackerBase::TrackerHasName::TrackerHasName( NameAndLocation const& nameAndLocation ) : m_nameAndLocation( nameAndLocation ) {}
-    bool TrackerBase::TrackerHasName::operator ()( ITrackerPtr const& tracker ) const {
-        return
-            tracker->nameAndLocation().name == m_nameAndLocation.name &&
-            tracker->nameAndLocation().location == m_nameAndLocation.location;
-    }
-
-    TrackerBase::TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
-    :   m_nameAndLocation( nameAndLocation ),
-        m_ctx( ctx ),
-        m_parent( parent )
-    {}
-
-    NameAndLocation const& TrackerBase::nameAndLocation() const {
-        return m_nameAndLocation;
-    }
-    bool TrackerBase::isComplete() const {
-        return m_runState == CompletedSuccessfully || m_runState == Failed;
-    }
-    bool TrackerBase::isSuccessfullyCompleted() const {
-        return m_runState == CompletedSuccessfully;
-    }
-    bool TrackerBase::isOpen() const {
-        return m_runState != NotStarted && !isComplete();
-    }
-    bool TrackerBase::hasChildren() const {
-        return !m_children.empty();
-    }
-
-    void TrackerBase::addChild( ITrackerPtr const& child ) {
-        m_children.push_back( child );
-    }
-
-    ITrackerPtr TrackerBase::findChild( NameAndLocation const& nameAndLocation ) {
-        auto it = std::find_if( m_children.begin(), m_children.end(), TrackerHasName( nameAndLocation ) );
-        return( it != m_children.end() )
-            ? *it
-            : nullptr;
-    }
-    ITracker& TrackerBase::parent() {
-        assert( m_parent ); // Should always be non-null except for root
-        return *m_parent;
-    }
-
-    void TrackerBase::openChild() {
-        if( m_runState != ExecutingChildren ) {
-            m_runState = ExecutingChildren;
-            if( m_parent )
-                m_parent->openChild();
-        }
-    }
-
-    bool TrackerBase::isSectionTracker() const { return false; }
-    bool TrackerBase::isIndexTracker() const { return false; }
-
-    void TrackerBase::open() {
-        m_runState = Executing;
-        moveToThis();
-        if( m_parent )
-            m_parent->openChild();
-    }
-
-    void TrackerBase::close() {
-
-        // Close any still open children (e.g. generators)
-        while( &m_ctx.currentTracker() != this )
-            m_ctx.currentTracker().close();
-
-        switch( m_runState ) {
-            case NeedsAnotherRun:
-                break;
-
-            case Executing:
-                m_runState = CompletedSuccessfully;
-                break;
-            case ExecutingChildren:
-                if( m_children.empty() || m_children.back()->isComplete() )
-                    m_runState = CompletedSuccessfully;
-                break;
-
-            case NotStarted:
-            case CompletedSuccessfully:
-            case Failed:
-                CATCH_INTERNAL_ERROR( "Illogical state: " << m_runState );
-
-            default:
-                CATCH_INTERNAL_ERROR( "Unknown state: " << m_runState );
-        }
-        moveToParent();
-        m_ctx.completeCycle();
-    }
-    void TrackerBase::fail() {
-        m_runState = Failed;
-        if( m_parent )
-            m_parent->markAsNeedingAnotherRun();
-        moveToParent();
-        m_ctx.completeCycle();
-    }
-    void TrackerBase::markAsNeedingAnotherRun() {
-        m_runState = NeedsAnotherRun;
-    }
-
-    void TrackerBase::moveToParent() {
-        assert( m_parent );
-        m_ctx.setCurrentTracker( m_parent );
-    }
-    void TrackerBase::moveToThis() {
-        m_ctx.setCurrentTracker( this );
-    }
-
-    SectionTracker::SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
-    :   TrackerBase( nameAndLocation, ctx, parent )
-    {
-        if( parent ) {
-            while( !parent->isSectionTracker() )
-                parent = &parent->parent();
-
-            SectionTracker& parentSection = static_cast<SectionTracker&>( *parent );
-            addNextFilters( parentSection.m_filters );
-        }
-    }
-
-    bool SectionTracker::isSectionTracker() const { return true; }
-
-    SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation ) {
-        std::shared_ptr<SectionTracker> section;
-
-        ITracker& currentTracker = ctx.currentTracker();
-        if( ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
-            assert( childTracker );
-            assert( childTracker->isSectionTracker() );
-            section = std::static_pointer_cast<SectionTracker>( childTracker );
-        }
-        else {
-            section = std::make_shared<SectionTracker>( nameAndLocation, ctx, &currentTracker );
-            currentTracker.addChild( section );
-        }
-        if( !ctx.completedCycle() )
-            section->tryOpen();
-        return *section;
-    }
-
-    void SectionTracker::tryOpen() {
-        if( !isComplete() && (m_filters.empty() || m_filters[0].empty() ||  m_filters[0] == m_nameAndLocation.name ) )
-            open();
-    }
-
-    void SectionTracker::addInitialFilters( std::vector<std::string> const& filters ) {
-        if( !filters.empty() ) {
-            m_filters.push_back(""); // Root - should never be consulted
-            m_filters.push_back(""); // Test Case - not a section filter
-            m_filters.insert( m_filters.end(), filters.begin(), filters.end() );
-        }
-    }
-    void SectionTracker::addNextFilters( std::vector<std::string> const& filters ) {
-        if( filters.size() > 1 )
-            m_filters.insert( m_filters.end(), ++filters.begin(), filters.end() );
-    }
-
-    IndexTracker::IndexTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent, int size )
-    :   TrackerBase( nameAndLocation, ctx, parent ),
-        m_size( size )
-    {}
-
-    bool IndexTracker::isIndexTracker() const { return true; }
-
-    IndexTracker& IndexTracker::acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation, int size ) {
-        std::shared_ptr<IndexTracker> tracker;
-
-        ITracker& currentTracker = ctx.currentTracker();
-        if( ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
-            assert( childTracker );
-            assert( childTracker->isIndexTracker() );
-            tracker = std::static_pointer_cast<IndexTracker>( childTracker );
-        }
-        else {
-            tracker = std::make_shared<IndexTracker>( nameAndLocation, ctx, &currentTracker, size );
-            currentTracker.addChild( tracker );
-        }
-
-        if( !ctx.completedCycle() && !tracker->isComplete() ) {
-            if( tracker->m_runState != ExecutingChildren && tracker->m_runState != NeedsAnotherRun )
-                tracker->moveNext();
-            tracker->open();
-        }
-
-        return *tracker;
-    }
-
-    int IndexTracker::index() const { return m_index; }
-
-    void IndexTracker::moveNext() {
-        m_index++;
-        m_children.clear();
-    }
-
-    void IndexTracker::close() {
-        TrackerBase::close();
-        if( m_runState == CompletedSuccessfully && m_index < m_size-1 )
-            m_runState = Executing;
-    }
-
-} // namespace TestCaseTracking
-
-using TestCaseTracking::ITracker;
-using TestCaseTracking::TrackerContext;
-using TestCaseTracking::SectionTracker;
-using TestCaseTracking::IndexTracker;
+		bool printInfoMessages = true;
 
-} // namespace Catch
+		// Drop out if result was successful and we're not printing those
+		if( !m_config->includeSuccessfulResults() && result.isOk() ) {
+			if( result.getResultType() != ResultWas::Warning )
+				return false;
+			printInfoMessages = false;
+		}
 
-#if defined(__clang__)
-#    pragma clang diagnostic pop
-#endif
-// end catch_test_case_tracker.cpp
-// start catch_test_registry.cpp
+		AssertionPrinter printer( stream, _assertionStats, printInfoMessages );
+		printer.print();
 
-namespace Catch {
+		stream << std::endl;
+		return true;
+	}
 
-    auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker* {
-        return new(std::nothrow) TestInvokerAsFunction( testAsFunction );
-    }
+	void CompactReporter::sectionEnded(SectionStats const& _sectionStats) {
+		if (m_config->showDurations() == ShowDurations::Always) {
+			stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
+		}
+	}
 
-    NameAndTags::NameAndTags( StringRef name_ , StringRef tags_ ) noexcept : name( name_ ), tags( tags_ ) {}
+	void CompactReporter::testRunEnded( TestRunStats const& _testRunStats ) {
+		printTotals( stream, _testRunStats.totals );
+		stream << '\n' << std::endl;
+		StreamingReporterBase::testRunEnded( _testRunStats );
+	}
 
-    AutoReg::AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef classOrMethod, NameAndTags const& nameAndTags ) noexcept {
-        try {
-            getMutableRegistryHub()
-                    .registerTest(
-                        makeTestCase(
-                            invoker,
-                            extractClassName( classOrMethod ),
-                            nameAndTags.name,
-                            nameAndTags.tags,
-                            lineInfo));
-        } catch (...) {
-            // Do not throw when constructing global objects, instead register the exception to be processed later
-            getMutableRegistryHub().registerStartupException();
-        }
-    }
+	CompactReporter::~CompactReporter() {}
 
-    AutoReg::~AutoReg() = default;
-}
-// end catch_test_registry.cpp
-// start catch_test_spec.cpp
+	CATCH_REGISTER_REPORTER( "compact", CompactReporter )
 
-#include <algorithm>
-#include <string>
-#include <vector>
-#include <memory>
+} // end namespace Catch
+  // end catch_reporter_compact.cpp
+  // start catch_reporter_console.cpp
 
-namespace Catch {
+#include <cfloat>
+#include <cstdio>
 
-    TestSpec::Pattern::~Pattern() = default;
-    TestSpec::NamePattern::~NamePattern() = default;
-    TestSpec::TagPattern::~TagPattern() = default;
-    TestSpec::ExcludedPattern::~ExcludedPattern() = default;
-
-    TestSpec::NamePattern::NamePattern( std::string const& name )
-    : m_wildcardPattern( toLower( name ), CaseSensitive::No )
-    {}
-    bool TestSpec::NamePattern::matches( TestCaseInfo const& testCase ) const {
-        return m_wildcardPattern.matches( toLower( testCase.name ) );
-    }
-
-    TestSpec::TagPattern::TagPattern( std::string const& tag ) : m_tag( toLower( tag ) ) {}
-    bool TestSpec::TagPattern::matches( TestCaseInfo const& testCase ) const {
-        return std::find(begin(testCase.lcaseTags),
-                         end(testCase.lcaseTags),
-                         m_tag) != end(testCase.lcaseTags);
-    }
-
-    TestSpec::ExcludedPattern::ExcludedPattern( PatternPtr const& underlyingPattern ) : m_underlyingPattern( underlyingPattern ) {}
-    bool TestSpec::ExcludedPattern::matches( TestCaseInfo const& testCase ) const { return !m_underlyingPattern->matches( testCase ); }
-
-    bool TestSpec::Filter::matches( TestCaseInfo const& testCase ) const {
-        // All patterns in a filter must match for the filter to be a match
-        for( auto const& pattern : m_patterns ) {
-            if( !pattern->matches( testCase ) )
-                return false;
-        }
-        return true;
-    }
-
-    bool TestSpec::hasFilters() const {
-        return !m_filters.empty();
-    }
-    bool TestSpec::matches( TestCaseInfo const& testCase ) const {
-        // A TestSpec matches if any filter matches
-        for( auto const& filter : m_filters )
-            if( filter.matches( testCase ) )
-                return true;
-        return false;
-    }
-}
-// end catch_test_spec.cpp
-// start catch_test_spec_parser.cpp
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
+  // Note that 4062 (not all labels are handled
+  // and default is missing) is enabled
+#endif
 
 namespace Catch {
 
-    TestSpecParser::TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {}
-
-    TestSpecParser& TestSpecParser::parse( std::string const& arg ) {
-        m_mode = None;
-        m_exclusion = false;
-        m_start = std::string::npos;
-        m_arg = m_tagAliases->expandAliases( arg );
-        m_escapeChars.clear();
-        for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
-            visitChar( m_arg[m_pos] );
-        if( m_mode == Name )
-            addPattern<TestSpec::NamePattern>();
-        return *this;
-    }
-    TestSpec TestSpecParser::testSpec() {
-        addFilter();
-        return m_testSpec;
-    }
-
-    void TestSpecParser::visitChar( char c ) {
-        if( m_mode == None ) {
-            switch( c ) {
-            case ' ': return;
-            case '~': m_exclusion = true; return;
-            case '[': return startNewMode( Tag, ++m_pos );
-            case '"': return startNewMode( QuotedName, ++m_pos );
-            case '\\': return escape();
-            default: startNewMode( Name, m_pos ); break;
-            }
-        }
-        if( m_mode == Name ) {
-            if( c == ',' ) {
-                addPattern<TestSpec::NamePattern>();
-                addFilter();
-            }
-            else if( c == '[' ) {
-                if( subString() == "exclude:" )
-                    m_exclusion = true;
-                else
-                    addPattern<TestSpec::NamePattern>();
-                startNewMode( Tag, ++m_pos );
-            }
-            else if( c == '\\' )
-                escape();
-        }
-        else if( m_mode == EscapedName )
-            m_mode = Name;
-        else if( m_mode == QuotedName && c == '"' )
-            addPattern<TestSpec::NamePattern>();
-        else if( m_mode == Tag && c == ']' )
-            addPattern<TestSpec::TagPattern>();
-    }
-    void TestSpecParser::startNewMode( Mode mode, std::size_t start ) {
-        m_mode = mode;
-        m_start = start;
-    }
-    void TestSpecParser::escape() {
-        if( m_mode == None )
-            m_start = m_pos;
-        m_mode = EscapedName;
-        m_escapeChars.push_back( m_pos );
-    }
-    std::string TestSpecParser::subString() const { return m_arg.substr( m_start, m_pos - m_start ); }
-
-    void TestSpecParser::addFilter() {
-        if( !m_currentFilter.m_patterns.empty() ) {
-            m_testSpec.m_filters.push_back( m_currentFilter );
-            m_currentFilter = TestSpec::Filter();
-        }
-    }
-
-    TestSpec parseTestSpec( std::string const& arg ) {
-        return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec();
-    }
-
-} // namespace Catch
-// end catch_test_spec_parser.cpp
-// start catch_timer.cpp
+	namespace {
+
+		// Formatter impl for ConsoleReporter
+		class ConsoleAssertionPrinter {
+		public:
+			ConsoleAssertionPrinter& operator= (ConsoleAssertionPrinter const&) = delete;
+			ConsoleAssertionPrinter(ConsoleAssertionPrinter const&) = delete;
+			ConsoleAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages)
+				: stream(_stream),
+				stats(_stats),
+				result(_stats.assertionResult),
+				colour(Colour::None),
+				message(result.getMessage()),
+				messages(_stats.infoMessages),
+				printInfoMessages(_printInfoMessages) {
+				switch (result.getResultType()) {
+				case ResultWas::Ok:
+					colour = Colour::Success;
+					passOrFail = "PASSED";
+					//if( result.hasMessage() )
+					if (_stats.infoMessages.size() == 1)
+						messageLabel = "with message";
+					if (_stats.infoMessages.size() > 1)
+						messageLabel = "with messages";
+					break;
+				case ResultWas::ExpressionFailed:
+					if (result.isOk()) {
+						colour = Colour::Success;
+						passOrFail = "FAILED - but was ok";
+					} else {
+						colour = Colour::Error;
+						passOrFail = "FAILED";
+					}
+					if (_stats.infoMessages.size() == 1)
+						messageLabel = "with message";
+					if (_stats.infoMessages.size() > 1)
+						messageLabel = "with messages";
+					break;
+				case ResultWas::ThrewException:
+					colour = Colour::Error;
+					passOrFail = "FAILED";
+					messageLabel = "due to unexpected exception with ";
+					if (_stats.infoMessages.size() == 1)
+						messageLabel += "message";
+					if (_stats.infoMessages.size() > 1)
+						messageLabel += "messages";
+					break;
+				case ResultWas::FatalErrorCondition:
+					colour = Colour::Error;
+					passOrFail = "FAILED";
+					messageLabel = "due to a fatal error condition";
+					break;
+				case ResultWas::DidntThrowException:
+					colour = Colour::Error;
+					passOrFail = "FAILED";
+					messageLabel = "because no exception was thrown where one was expected";
+					break;
+				case ResultWas::Info:
+					messageLabel = "info";
+					break;
+				case ResultWas::Warning:
+					messageLabel = "warning";
+					break;
+				case ResultWas::ExplicitFailure:
+					passOrFail = "FAILED";
+					colour = Colour::Error;
+					if (_stats.infoMessages.size() == 1)
+						messageLabel = "explicitly with message";
+					if (_stats.infoMessages.size() > 1)
+						messageLabel = "explicitly with messages";
+					break;
+					// These cases are here to prevent compiler warnings
+				case ResultWas::Unknown:
+				case ResultWas::FailureBit:
+				case ResultWas::Exception:
+					passOrFail = "** internal error **";
+					colour = Colour::Error;
+					break;
+				}
+			}
+
+			void print() const {
+				printSourceInfo();
+				if (stats.totals.assertions.total() > 0) {
+					printResultType();
+					printOriginalExpression();
+					printReconstructedExpression();
+				} else {
+					stream << '\n';
+				}
+				printMessage();
+			}
+
+		private:
+			void printResultType() const {
+				if (!passOrFail.empty()) {
+					Colour colourGuard(colour);
+					stream << passOrFail << ":\n";
+				}
+			}
+			void printOriginalExpression() const {
+				if (result.hasExpression()) {
+					Colour colourGuard(Colour::OriginalExpression);
+					stream << "  ";
+					stream << result.getExpressionInMacro();
+					stream << '\n';
+				}
+			}
+			void printReconstructedExpression() const {
+				if (result.hasExpandedExpression()) {
+					stream << "with expansion:\n";
+					Colour colourGuard(Colour::ReconstructedExpression);
+					stream << Column(result.getExpandedExpression()).indent(2) << '\n';
+				}
+			}
+			void printMessage() const {
+				if (!messageLabel.empty())
+					stream << messageLabel << ':' << '\n';
+				for (auto const& msg : messages) {
+					// If this assertion is a warning ignore any INFO messages
+					if (printInfoMessages || msg.type != ResultWas::Info)
+						stream << Column(msg.message).indent(2) << '\n';
+				}
+			}
+			void printSourceInfo() const {
+				Colour colourGuard(Colour::FileName);
+				stream << result.getSourceInfo() << ": ";
+			}
+
+			std::ostream& stream;
+			AssertionStats const& stats;
+			AssertionResult const& result;
+			Colour::Code colour;
+			std::string passOrFail;
+			std::string messageLabel;
+			std::string message;
+			std::vector<MessageInfo> messages;
+			bool printInfoMessages;
+		};
+
+		std::size_t makeRatio(std::size_t number, std::size_t total) {
+			std::size_t ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number / total : 0;
+			return (ratio == 0 && number > 0) ? 1 : ratio;
+		}
+
+		std::size_t& findMax(std::size_t& i, std::size_t& j, std::size_t& k) {
+			if (i > j && i > k)
+				return i;
+			else if (j > k)
+				return j;
+			else
+				return k;
+		}
+
+		struct ColumnInfo {
+			enum Justification { Left, Right };
+			std::string name;
+			int width;
+			Justification justification;
+		};
+		struct ColumnBreak {};
+		struct RowBreak {};
+
+		class Duration {
+			enum class Unit {
+				Auto,
+				Nanoseconds,
+				Microseconds,
+				Milliseconds,
+				Seconds,
+				Minutes
+			};
+			static const uint64_t s_nanosecondsInAMicrosecond = 1000;
+			static const uint64_t s_nanosecondsInAMillisecond = 1000 * s_nanosecondsInAMicrosecond;
+			static const uint64_t s_nanosecondsInASecond = 1000 * s_nanosecondsInAMillisecond;
+			static const uint64_t s_nanosecondsInAMinute = 60 * s_nanosecondsInASecond;
+
+			uint64_t m_inNanoseconds;
+			Unit m_units;
+
+		public:
+			explicit Duration(uint64_t inNanoseconds, Unit units = Unit::Auto)
+				: m_inNanoseconds(inNanoseconds),
+				m_units(units) {
+				if (m_units == Unit::Auto) {
+					if (m_inNanoseconds < s_nanosecondsInAMicrosecond)
+						m_units = Unit::Nanoseconds;
+					else if (m_inNanoseconds < s_nanosecondsInAMillisecond)
+						m_units = Unit::Microseconds;
+					else if (m_inNanoseconds < s_nanosecondsInASecond)
+						m_units = Unit::Milliseconds;
+					else if (m_inNanoseconds < s_nanosecondsInAMinute)
+						m_units = Unit::Seconds;
+					else
+						m_units = Unit::Minutes;
+				}
+
+			}
+
+			auto value() const -> double {
+				switch (m_units) {
+				case Unit::Microseconds:
+					return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMicrosecond);
+				case Unit::Milliseconds:
+					return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMillisecond);
+				case Unit::Seconds:
+					return m_inNanoseconds / static_cast<double>(s_nanosecondsInASecond);
+				case Unit::Minutes:
+					return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMinute);
+				default:
+					return static_cast<double>(m_inNanoseconds);
+				}
+			}
+			auto unitsAsString() const -> std::string {
+				switch (m_units) {
+				case Unit::Nanoseconds:
+					return "ns";
+				case Unit::Microseconds:
+					return "us";
+				case Unit::Milliseconds:
+					return "ms";
+				case Unit::Seconds:
+					return "s";
+				case Unit::Minutes:
+					return "m";
+				default:
+					return "** internal error **";
+				}
+
+			}
+			friend auto operator << (std::ostream& os, Duration const& duration) -> std::ostream& {
+				return os << duration.value() << " " << duration.unitsAsString();
+			}
+		};
+	} // end anon namespace
+
+	class TablePrinter {
+		std::ostream& m_os;
+		std::vector<ColumnInfo> m_columnInfos;
+		std::ostringstream m_oss;
+		int m_currentColumn = -1;
+		bool m_isOpen = false;
+
+	public:
+		TablePrinter( std::ostream& os, std::vector<ColumnInfo> columnInfos )
+			:   m_os( os ),
+			m_columnInfos( std::move( columnInfos ) ) {}
+
+		auto columnInfos() const -> std::vector<ColumnInfo> const& {
+			return m_columnInfos;
+		}
+
+		void open() {
+			if (!m_isOpen) {
+				m_isOpen = true;
+				*this << RowBreak();
+				for (auto const& info : m_columnInfos)
+					*this << info.name << ColumnBreak();
+				*this << RowBreak();
+				m_os << Catch::getLineOfChars<'-'>() << "\n";
+			}
+		}
+		void close() {
+			if (m_isOpen) {
+				*this << RowBreak();
+				m_os << std::endl;
+				m_isOpen = false;
+			}
+		}
+
+		template<typename T>
+		friend TablePrinter& operator << (TablePrinter& tp, T const& value) {
+			tp.m_oss << value;
+			return tp;
+		}
+
+		friend TablePrinter& operator << (TablePrinter& tp, ColumnBreak) {
+			auto colStr = tp.m_oss.str();
+			// This takes account of utf8 encodings
+			auto strSize = Catch::StringRef(colStr).numberOfCharacters();
+			tp.m_oss.str("");
+			tp.open();
+			if (tp.m_currentColumn == static_cast<int>(tp.m_columnInfos.size() - 1)) {
+				tp.m_currentColumn = -1;
+				tp.m_os << "\n";
+			}
+			tp.m_currentColumn++;
+
+			auto colInfo = tp.m_columnInfos[tp.m_currentColumn];
+			auto padding = (strSize + 2 < static_cast<std::size_t>(colInfo.width))
+				? std::string(colInfo.width - (strSize + 2), ' ')
+				: std::string();
+			if (colInfo.justification == ColumnInfo::Left)
+				tp.m_os << colStr << padding << " ";
+			else
+				tp.m_os << padding << colStr << " ";
+			return tp;
+		}
+
+		friend TablePrinter& operator << (TablePrinter& tp, RowBreak) {
+			if (tp.m_currentColumn > 0) {
+				tp.m_os << "\n";
+				tp.m_currentColumn = -1;
+			}
+			return tp;
+		}
+	};
+
+	ConsoleReporter::ConsoleReporter(ReporterConfig const& config)
+		: StreamingReporterBase(config),
+		m_tablePrinter(new TablePrinter(config.stream(),
+			{
+				{ "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 32, ColumnInfo::Left },
+			{ "iters", 8, ColumnInfo::Right },
+			{ "elapsed ns", 14, ColumnInfo::Right },
+			{ "average", 14, ColumnInfo::Right }
+			})) {}
+	ConsoleReporter::~ConsoleReporter() = default;
+
+	std::string ConsoleReporter::getDescription() {
+		return "Reports test results as plain lines of text";
+	}
 
-#include <chrono>
+	void ConsoleReporter::noMatchingTestCases(std::string const& spec) {
+		stream << "No test cases matched '" << spec << '\'' << std::endl;
+	}
 
-namespace Catch {
+	void ConsoleReporter::assertionStarting(AssertionInfo const&) {}
 
-    auto getCurrentNanosecondsSinceEpoch() -> uint64_t {
-        return std::chrono::duration_cast<std::chrono::nanoseconds>( std::chrono::high_resolution_clock::now().time_since_epoch() ).count();
-    }
-
-    auto estimateClockResolution() -> uint64_t {
-        uint64_t sum = 0;
-        static const uint64_t iterations = 1000000;
-
-        for( std::size_t i = 0; i < iterations; ++i ) {
-
-            uint64_t ticks;
-            uint64_t baseTicks = getCurrentNanosecondsSinceEpoch();
-            do {
-                ticks = getCurrentNanosecondsSinceEpoch();
-            }
-            while( ticks == baseTicks );
-
-            auto delta = ticks - baseTicks;
-            sum += delta;
-        }
-
-        // We're just taking the mean, here. To do better we could take the std. dev and exclude outliers
-        // - and potentially do more iterations if there's a high variance.
-        return sum/iterations;
-    }
-    auto getEstimatedClockResolution() -> uint64_t {
-        static auto s_resolution = estimateClockResolution();
-        return s_resolution;
-    }
-
-    void Timer::start() {
-       m_nanoseconds = getCurrentNanosecondsSinceEpoch();
-    }
-    auto Timer::getElapsedNanoseconds() const -> unsigned int {
-        return static_cast<unsigned int>(getCurrentNanosecondsSinceEpoch() - m_nanoseconds);
-    }
-    auto Timer::getElapsedMicroseconds() const -> unsigned int {
-        return static_cast<unsigned int>(getElapsedNanoseconds()/1000);
-    }
-    auto Timer::getElapsedMilliseconds() const -> unsigned int {
-        return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
-    }
-    auto Timer::getElapsedSeconds() const -> double {
-        return getElapsedMicroseconds()/1000000.0;
-    }
+	bool ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) {
+		AssertionResult const& result = _assertionStats.assertionResult;
 
-} // namespace Catch
-// end catch_timer.cpp
-// start catch_tostring.cpp
+		bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
 
-#if defined(__clang__)
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wexit-time-destructors"
-#    pragma clang diagnostic ignored "-Wglobal-constructors"
-#endif
+		// Drop out if result was successful but we're not printing them.
+		if (!includeResults && result.getResultType() != ResultWas::Warning)
+			return false;
 
-#include <iomanip>
+		lazyPrint();
 
-namespace Catch {
+		ConsoleAssertionPrinter printer(stream, _assertionStats, includeResults);
+		printer.print();
+		stream << std::endl;
+		return true;
+	}
 
-namespace Detail {
+	void ConsoleReporter::sectionStarting(SectionInfo const& _sectionInfo) {
+		m_headerPrinted = false;
+		StreamingReporterBase::sectionStarting(_sectionInfo);
+	}
+	void ConsoleReporter::sectionEnded(SectionStats const& _sectionStats) {
+		m_tablePrinter->close();
+		if (_sectionStats.missingAssertions) {
+			lazyPrint();
+			Colour colour(Colour::ResultError);
+			if (m_sectionStack.size() > 1)
+				stream << "\nNo assertions in section";
+			else
+				stream << "\nNo assertions in test case";
+			stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl;
+		}
+		if (m_config->showDurations() == ShowDurations::Always) {
+			stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
+		}
+		if (m_headerPrinted) {
+			m_headerPrinted = false;
+		}
+		StreamingReporterBase::sectionEnded(_sectionStats);
+	}
 
-    const std::string unprintableString = "{?}";
+	void ConsoleReporter::benchmarkStarting(BenchmarkInfo const& info) {
+		lazyPrintWithoutClosingBenchmarkTable();
 
-    namespace {
-        const int hexThreshold = 255;
+		auto nameCol = Column( info.name ).width( static_cast<std::size_t>( m_tablePrinter->columnInfos()[0].width - 2 ) );
 
-        struct Endianness {
-            enum Arch { Big, Little };
+		bool firstLine = true;
+		for (auto line : nameCol) {
+			if (!firstLine)
+				(*m_tablePrinter) << ColumnBreak() << ColumnBreak() << ColumnBreak();
+			else
+				firstLine = false;
 
-            static Arch which() {
-                union _{
-                    int asInt;
-                    char asChar[sizeof (int)];
-                } u;
+			(*m_tablePrinter) << line << ColumnBreak();
+		}
+	}
+	void ConsoleReporter::benchmarkEnded(BenchmarkStats const& stats) {
+		Duration average(stats.elapsedTimeInNanoseconds / stats.iterations);
+		(*m_tablePrinter)
+			<< stats.iterations << ColumnBreak()
+			<< stats.elapsedTimeInNanoseconds << ColumnBreak()
+			<< average << ColumnBreak();
+	}
 
-                u.asInt = 1;
-                return ( u.asChar[sizeof(int)-1] == 1 ) ? Big : Little;
-            }
-        };
-    }
+	void ConsoleReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
+		m_tablePrinter->close();
+		StreamingReporterBase::testCaseEnded(_testCaseStats);
+		m_headerPrinted = false;
+	}
+	void ConsoleReporter::testGroupEnded(TestGroupStats const& _testGroupStats) {
+		if (currentGroupInfo.used) {
+			printSummaryDivider();
+			stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
+			printTotals(_testGroupStats.totals);
+			stream << '\n' << std::endl;
+		}
+		StreamingReporterBase::testGroupEnded(_testGroupStats);
+	}
+	void ConsoleReporter::testRunEnded(TestRunStats const& _testRunStats) {
+		printTotalsDivider(_testRunStats.totals);
+		printTotals(_testRunStats.totals);
+		stream << std::endl;
+		StreamingReporterBase::testRunEnded(_testRunStats);
+	}
 
-    std::string rawMemoryToString( const void *object, std::size_t size ) {
-        // Reverse order for little endian architectures
-        int i = 0, end = static_cast<int>( size ), inc = 1;
-        if( Endianness::which() == Endianness::Little ) {
-            i = end-1;
-            end = inc = -1;
-        }
+	void ConsoleReporter::lazyPrint() {
 
-        unsigned char const *bytes = static_cast<unsigned char const *>(object);
-        std::ostringstream os;
-        os << "0x" << std::setfill('0') << std::hex;
-        for( ; i != end; i += inc )
-             os << std::setw(2) << static_cast<unsigned>(bytes[i]);
-       return os.str();
-    }
-}
+		m_tablePrinter->close();
+		lazyPrintWithoutClosingBenchmarkTable();
+	}
 
-template<typename T>
-std::string fpToString( T value, int precision ) {
-    std::ostringstream oss;
-    oss << std::setprecision( precision )
-        << std::fixed
-        << value;
-    std::string d = oss.str();
-    std::size_t i = d.find_last_not_of( '0' );
-    if( i != std::string::npos && i != d.size()-1 ) {
-        if( d[i] == '.' )
-            i++;
-        d = d.substr( 0, i+1 );
-    }
-    return d;
-}
+	void ConsoleReporter::lazyPrintWithoutClosingBenchmarkTable() {
 
-//// ======================================================= ////
-//
-//   Out-of-line defs for full specialization of StringMaker
-//
-//// ======================================================= ////
-
-std::string StringMaker<std::string>::convert(const std::string& str) {
-    if (!getCurrentContext().getConfig()->showInvisibles()) {
-        return '"' + str + '"';
-    }
-
-    std::string s("\"");
-    for (char c : str) {
-        switch (c) {
-        case '\n':
-            s.append("\\n");
-            break;
-        case '\t':
-            s.append("\\t");
-            break;
-        default:
-            s.push_back(c);
-            break;
-        }
-    }
-    s.append("\"");
-    return s;
-}
+		if (!currentTestRunInfo.used)
+			lazyPrintRunInfo();
+		if (!currentGroupInfo.used)
+			lazyPrintGroupInfo();
 
-std::string StringMaker<std::wstring>::convert(const std::wstring& wstr) {
-    std::string s;
-    s.reserve(wstr.size());
-    for (auto c : wstr) {
-        s += (c <= 0xff) ? static_cast<char>(c) : '?';
-    }
-    return ::Catch::Detail::stringify(s);
-}
+		if (!m_headerPrinted) {
+			printTestCaseAndSectionHeader();
+			m_headerPrinted = true;
+		}
+	}
+	void ConsoleReporter::lazyPrintRunInfo() {
+		stream << '\n' << getLineOfChars<'~'>() << '\n';
+		Colour colour(Colour::SecondaryText);
+		stream << currentTestRunInfo->name
+			<< " is a Catch v" << libraryVersion() << " host application.\n"
+			<< "Run with -? for options\n\n";
 
-std::string StringMaker<char const*>::convert(char const* str) {
-    if (str) {
-        return ::Catch::Detail::stringify(std::string{ str });
-    } else {
-        return{ "{null string}" };
-    }
-}
-std::string StringMaker<char*>::convert(char* str) {
-    if (str) {
-        return ::Catch::Detail::stringify(std::string{ str });
-    } else {
-        return{ "{null string}" };
-    }
-}
-std::string StringMaker<wchar_t const*>::convert(wchar_t const * str) {
-    if (str) {
-        return ::Catch::Detail::stringify(std::wstring{ str });
-    } else {
-        return{ "{null string}" };
-    }
-}
-std::string StringMaker<wchar_t *>::convert(wchar_t * str) {
-    if (str) {
-        return ::Catch::Detail::stringify(std::wstring{ str });
-    } else {
-        return{ "{null string}" };
-    }
-}
+		if (m_config->rngSeed() != 0)
+			stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n";
 
-std::string StringMaker<int>::convert(int value) {
-    return ::Catch::Detail::stringify(static_cast<long long>(value));
-}
-std::string StringMaker<long>::convert(long value) {
-    return ::Catch::Detail::stringify(static_cast<long long>(value));
-}
-std::string StringMaker<long long>::convert(long long value) {
-    std::ostringstream oss;
-    oss << value;
-    if (value > Detail::hexThreshold) {
-        oss << " (0x" << std::hex << value << ')';
-    }
-    return oss.str();
-}
+		currentTestRunInfo.used = true;
+	}
+	void ConsoleReporter::lazyPrintGroupInfo() {
+		if (!currentGroupInfo->name.empty() && currentGroupInfo->groupsCounts > 1) {
+			printClosedHeader("Group: " + currentGroupInfo->name);
+			currentGroupInfo.used = true;
+		}
+	}
+	void ConsoleReporter::printTestCaseAndSectionHeader() {
+		assert(!m_sectionStack.empty());
+		printOpenHeader(currentTestCaseInfo->name);
+
+		if (m_sectionStack.size() > 1) {
+			Colour colourGuard(Colour::Headers);
+
+			auto
+				it = m_sectionStack.begin() + 1, // Skip first section (test case)
+				itEnd = m_sectionStack.end();
+			for (; it != itEnd; ++it)
+				printHeaderString(it->name, 2);
+		}
+
+		SourceLineInfo lineInfo = m_sectionStack.back().lineInfo;
+
+		if (!lineInfo.empty()) {
+			stream << getLineOfChars<'-'>() << '\n';
+			Colour colourGuard(Colour::FileName);
+			stream << lineInfo << '\n';
+		}
+		stream << getLineOfChars<'.'>() << '\n' << std::endl;
+	}
 
-std::string StringMaker<unsigned int>::convert(unsigned int value) {
-    return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
-}
-std::string StringMaker<unsigned long>::convert(unsigned long value) {
-    return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
-}
-std::string StringMaker<unsigned long long>::convert(unsigned long long value) {
-    std::ostringstream oss;
-    oss << value;
-    if (value > Detail::hexThreshold) {
-        oss << " (0x" << std::hex << value << ')';
-    }
-    return oss.str();
-}
+	void ConsoleReporter::printClosedHeader(std::string const& _name) {
+		printOpenHeader(_name);
+		stream << getLineOfChars<'.'>() << '\n';
+	}
+	void ConsoleReporter::printOpenHeader(std::string const& _name) {
+		stream << getLineOfChars<'-'>() << '\n';
+		{
+			Colour colourGuard(Colour::Headers);
+			printHeaderString(_name);
+		}
+	}
 
-std::string StringMaker<bool>::convert(bool b) {
-    return b ? "true" : "false";
-}
+	// if string has a : in first line will set indent to follow it on
+	// subsequent lines
+	void ConsoleReporter::printHeaderString(std::string const& _string, std::size_t indent) {
+		std::size_t i = _string.find(": ");
+		if (i != std::string::npos)
+			i += 2;
+		else
+			i = 0;
+		stream << Column(_string).indent(indent + i).initialIndent(indent) << '\n';
+	}
 
-std::string StringMaker<char>::convert(char value) {
-    if (value == '\r') {
-        return "'\\r'";
-    } else if (value == '\f') {
-        return "'\\f'";
-    } else if (value == '\n') {
-        return "'\\n'";
-    } else if (value == '\t') {
-        return "'\\t'";
-    } else if ('\0' <= value && value < ' ') {
-        return ::Catch::Detail::stringify(static_cast<unsigned int>(value));
-    } else {
-        char chstr[] = "' '";
-        chstr[1] = value;
-        return chstr;
-    }
-}
-std::string StringMaker<signed char>::convert(signed char c) {
-    return ::Catch::Detail::stringify(static_cast<char>(c));
-}
-std::string StringMaker<unsigned char>::convert(unsigned char c) {
-    return ::Catch::Detail::stringify(static_cast<char>(c));
-}
+	struct SummaryColumn {
+
+		SummaryColumn( std::string _label, Colour::Code _colour )
+			:   label( std::move( _label ) ),
+			colour( _colour ) {}
+		SummaryColumn addRow( std::size_t count ) {
+			ReusableStringStream rss;
+			rss << count;
+			std::string row = rss.str();
+			for (auto& oldRow : rows) {
+				while (oldRow.size() < row.size())
+					oldRow = ' ' + oldRow;
+				while (oldRow.size() > row.size())
+					row = ' ' + row;
+			}
+			rows.push_back(row);
+			return *this;
+		}
+
+		std::string label;
+		Colour::Code colour;
+		std::vector<std::string> rows;
+
+	};
+
+	void ConsoleReporter::printTotals( Totals const& totals ) {
+		if (totals.testCases.total() == 0) {
+			stream << Colour(Colour::Warning) << "No tests ran\n";
+		} else if (totals.assertions.total() > 0 && totals.testCases.allPassed()) {
+			stream << Colour(Colour::ResultSuccess) << "All tests passed";
+			stream << " ("
+				<< pluralise(totals.assertions.passed, "assertion") << " in "
+				<< pluralise(totals.testCases.passed, "test case") << ')'
+				<< '\n';
+		} else {
+
+			std::vector<SummaryColumn> columns;
+			columns.push_back(SummaryColumn("", Colour::None)
+				.addRow(totals.testCases.total())
+				.addRow(totals.assertions.total()));
+			columns.push_back(SummaryColumn("passed", Colour::Success)
+				.addRow(totals.testCases.passed)
+				.addRow(totals.assertions.passed));
+			columns.push_back(SummaryColumn("failed", Colour::ResultError)
+				.addRow(totals.testCases.failed)
+				.addRow(totals.assertions.failed));
+			columns.push_back(SummaryColumn("failed as expected", Colour::ResultExpectedFailure)
+				.addRow(totals.testCases.failedButOk)
+				.addRow(totals.assertions.failedButOk));
+
+			printSummaryRow("test cases", columns, 0);
+			printSummaryRow("assertions", columns, 1);
+		}
+	}
+	void ConsoleReporter::printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row) {
+		for (auto col : cols) {
+			std::string value = col.rows[row];
+			if (col.label.empty()) {
+				stream << label << ": ";
+				if (value != "0")
+					stream << value;
+				else
+					stream << Colour(Colour::Warning) << "- none -";
+			} else if (value != "0") {
+				stream << Colour(Colour::LightGrey) << " | ";
+				stream << Colour(col.colour)
+					<< value << ' ' << col.label;
+			}
+		}
+		stream << '\n';
+	}
 
-std::string StringMaker<std::nullptr_t>::convert(std::nullptr_t) {
-    return "nullptr";
-}
+	void ConsoleReporter::printTotalsDivider(Totals const& totals) {
+		if (totals.testCases.total() > 0) {
+			std::size_t failedRatio = makeRatio(totals.testCases.failed, totals.testCases.total());
+			std::size_t failedButOkRatio = makeRatio(totals.testCases.failedButOk, totals.testCases.total());
+			std::size_t passedRatio = makeRatio(totals.testCases.passed, totals.testCases.total());
+			while (failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH - 1)
+				findMax(failedRatio, failedButOkRatio, passedRatio)++;
+			while (failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH - 1)
+				findMax(failedRatio, failedButOkRatio, passedRatio)--;
+
+			stream << Colour(Colour::Error) << std::string(failedRatio, '=');
+			stream << Colour(Colour::ResultExpectedFailure) << std::string(failedButOkRatio, '=');
+			if (totals.testCases.allPassed())
+				stream << Colour(Colour::ResultSuccess) << std::string(passedRatio, '=');
+			else
+				stream << Colour(Colour::Success) << std::string(passedRatio, '=');
+		} else {
+			stream << Colour(Colour::Warning) << std::string(CATCH_CONFIG_CONSOLE_WIDTH - 1, '=');
+		}
+		stream << '\n';
+	}
+	void ConsoleReporter::printSummaryDivider() {
+		stream << getLineOfChars<'-'>() << '\n';
+	}
 
-std::string StringMaker<float>::convert(float value) {
-    return fpToString(value, 5) + 'f';
-}
-std::string StringMaker<double>::convert(double value) {
-    return fpToString(value, 10);
-}
+	CATCH_REGISTER_REPORTER("console", ConsoleReporter)
 
 } // end namespace Catch
 
-#if defined(__clang__)
-#    pragma clang diagnostic pop
+#if defined(_MSC_VER)
+#pragma warning(pop)
 #endif
+  // end catch_reporter_console.cpp
+  // start catch_reporter_junit.cpp
 
-// end catch_tostring.cpp
-// start catch_totals.cpp
-
-namespace Catch {
-
-    Counts Counts::operator - ( Counts const& other ) const {
-        Counts diff;
-        diff.passed = passed - other.passed;
-        diff.failed = failed - other.failed;
-        diff.failedButOk = failedButOk - other.failedButOk;
-        return diff;
-    }
-
-    Counts& Counts::operator += ( Counts const& other ) {
-        passed += other.passed;
-        failed += other.failed;
-        failedButOk += other.failedButOk;
-        return *this;
-    }
-
-    std::size_t Counts::total() const {
-        return passed + failed + failedButOk;
-    }
-    bool Counts::allPassed() const {
-        return failed == 0 && failedButOk == 0;
-    }
-    bool Counts::allOk() const {
-        return failed == 0;
-    }
-
-    Totals Totals::operator - ( Totals const& other ) const {
-        Totals diff;
-        diff.assertions = assertions - other.assertions;
-        diff.testCases = testCases - other.testCases;
-        return diff;
-    }
-
-    Totals& Totals::operator += ( Totals const& other ) {
-        assertions += other.assertions;
-        testCases += other.testCases;
-        return *this;
-    }
-
-    Totals Totals::delta( Totals const& prevTotals ) const {
-        Totals diff = *this - prevTotals;
-        if( diff.assertions.failed > 0 )
-            ++diff.testCases.failed;
-        else if( diff.assertions.failedButOk > 0 )
-            ++diff.testCases.failedButOk;
-        else
-            ++diff.testCases.passed;
-        return diff;
-    }
-
-}
-// end catch_totals.cpp
-// start catch_version.cpp
-
-#include <ostream>
+#include <cassert>
+#include <sstream>
+#include <ctime>
+#include <algorithm>
 
 namespace Catch {
 
-    Version::Version
-        (   unsigned int _majorVersion,
-            unsigned int _minorVersion,
-            unsigned int _patchNumber,
-            char const * const _branchName,
-            unsigned int _buildNumber )
-    :   majorVersion( _majorVersion ),
-        minorVersion( _minorVersion ),
-        patchNumber( _patchNumber ),
-        branchName( _branchName ),
-        buildNumber( _buildNumber )
-    {}
-
-    std::ostream& operator << ( std::ostream& os, Version const& version ) {
-        os  << version.majorVersion << '.'
-            << version.minorVersion << '.'
-            << version.patchNumber;
-        // branchName is never null -> 0th char is \0 if it is empty
-        if (version.branchName[0]) {
-            os << '-' << version.branchName
-               << '.' << version.buildNumber;
-        }
-        return os;
-    }
-
-    Version const& libraryVersion() {
-        static Version version( 2, 0, 1, "", 0 );
-        return version;
-    }
+	namespace {
+		std::string getCurrentTimestamp() {
+			// Beware, this is not reentrant because of backward compatibility issues
+			// Also, UTC only, again because of backward compatibility (%z is C++11)
+			time_t rawtime;
+			std::time(&rawtime);
+			auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
 
-}
-// end catch_version.cpp
-// start catch_wildcard_pattern.cpp
+#ifdef _MSC_VER
+			std::tm timeInfo = {};
+			gmtime_s(&timeInfo, &rawtime);
+#else
+			std::tm* timeInfo;
+			timeInfo = std::gmtime(&rawtime);
+#endif
 
-namespace Catch {
+			char timeStamp[timeStampSize];
+			const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
 
-    WildcardPattern::WildcardPattern( std::string const& pattern,
-                                      CaseSensitive::Choice caseSensitivity )
-    :   m_caseSensitivity( caseSensitivity ),
-        m_pattern( adjustCase( pattern ) )
-    {
-        if( startsWith( m_pattern, '*' ) ) {
-            m_pattern = m_pattern.substr( 1 );
-            m_wildcard = WildcardAtStart;
-        }
-        if( endsWith( m_pattern, '*' ) ) {
-            m_pattern = m_pattern.substr( 0, m_pattern.size()-1 );
-            m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
-        }
-    }
-
-    bool WildcardPattern::matches( std::string const& str ) const {
-        switch( m_wildcard ) {
-            case NoWildcard:
-                return m_pattern == adjustCase( str );
-            case WildcardAtStart:
-                return endsWith( adjustCase( str ), m_pattern );
-            case WildcardAtEnd:
-                return startsWith( adjustCase( str ), m_pattern );
-            case WildcardAtBothEnds:
-                return contains( adjustCase( str ), m_pattern );
-            default:
-                CATCH_INTERNAL_ERROR( "Unknown enum" );
-        }
-    }
-
-    std::string WildcardPattern::adjustCase( std::string const& str ) const {
-        return m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str;
-    }
-}
-// end catch_wildcard_pattern.cpp
-// start catch_xmlwriter.cpp
+#ifdef _MSC_VER
+			std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
+#else
+			std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
+#endif
+			return std::string(timeStamp);
+		}
+
+		std::string fileNameTag(const std::vector<std::string> &tags) {
+			auto it = std::find_if(begin(tags),
+				end(tags),
+				[] (std::string const& tag) {return tag.front() == '#'; });
+			if (it != tags.end())
+				return it->substr(1);
+			return std::string();
+		}
+	} // anonymous namespace
+
+	JunitReporter::JunitReporter( ReporterConfig const& _config )
+		:   CumulativeReporterBase( _config ),
+		xml( _config.stream() )
+	{
+		m_reporterPrefs.shouldRedirectStdOut = true;
+		m_reporterPrefs.shouldReportAllAssertions = true;
+	}
 
-// start catch_xmlwriter.h
+	JunitReporter::~JunitReporter() {}
 
-#include <sstream>
-#include <vector>
+	std::string JunitReporter::getDescription() {
+		return "Reports test results in an XML format that looks like Ant's junitreport target";
+	}
 
-namespace Catch {
+	void JunitReporter::noMatchingTestCases( std::string const& /*spec*/ ) {}
 
-    class XmlEncode {
-    public:
-        enum ForWhat { ForTextNodes, ForAttributes };
+	void JunitReporter::testRunStarting( TestRunInfo const& runInfo )  {
+		CumulativeReporterBase::testRunStarting( runInfo );
+		xml.startElement( "testsuites" );
+	}
 
-        XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes );
+	void JunitReporter::testGroupStarting( GroupInfo const& groupInfo ) {
+		suiteTimer.start();
+		stdOutForSuite.clear();
+		stdErrForSuite.clear();
+		unexpectedExceptions = 0;
+		CumulativeReporterBase::testGroupStarting( groupInfo );
+	}
 
-        void encodeTo( std::ostream& os ) const;
+	void JunitReporter::testCaseStarting( TestCaseInfo const& testCaseInfo ) {
+		m_okToFail = testCaseInfo.okToFail();
+	}
 
-        friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode );
+	bool JunitReporter::assertionEnded( AssertionStats const& assertionStats ) {
+		if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException && !m_okToFail )
+			unexpectedExceptions++;
+		return CumulativeReporterBase::assertionEnded( assertionStats );
+	}
 
-    private:
-        std::string m_str;
-        ForWhat m_forWhat;
-    };
+	void JunitReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+		stdOutForSuite += testCaseStats.stdOut;
+		stdErrForSuite += testCaseStats.stdErr;
+		CumulativeReporterBase::testCaseEnded( testCaseStats );
+	}
 
-    class XmlWriter {
-    public:
+	void JunitReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
+		double suiteTime = suiteTimer.getElapsedSeconds();
+		CumulativeReporterBase::testGroupEnded( testGroupStats );
+		writeGroup( *m_testGroups.back(), suiteTime );
+	}
 
-        class ScopedElement {
-        public:
-            ScopedElement( XmlWriter* writer );
+	void JunitReporter::testRunEndedCumulative() {
+		xml.endElement();
+	}
 
-            ScopedElement( ScopedElement&& other ) noexcept;
-            ScopedElement& operator=( ScopedElement&& other ) noexcept;
+	void JunitReporter::writeGroup( TestGroupNode const& groupNode, double suiteTime ) {
+		XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
+		TestGroupStats const& stats = groupNode.value;
+		xml.writeAttribute( "name", stats.groupInfo.name );
+		xml.writeAttribute( "errors", unexpectedExceptions );
+		xml.writeAttribute( "failures", stats.totals.assertions.failed-unexpectedExceptions );
+		xml.writeAttribute( "tests", stats.totals.assertions.total() );
+		xml.writeAttribute( "hostname", "tbd" ); // !TBD
+		if( m_config->showDurations() == ShowDurations::Never )
+			xml.writeAttribute( "time", "" );
+		else
+			xml.writeAttribute( "time", suiteTime );
+		xml.writeAttribute( "timestamp", getCurrentTimestamp() );
+
+		// Write test cases
+		for( auto const& child : groupNode.children )
+			writeTestCase( *child );
+
+		xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite ), false );
+		xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite ), false );
+	}
 
-            ~ScopedElement();
+	void JunitReporter::writeTestCase( TestCaseNode const& testCaseNode ) {
+		TestCaseStats const& stats = testCaseNode.value;
 
-            ScopedElement& writeText( std::string const& text, bool indent = true );
+		// All test cases have exactly one section - which represents the
+		// test case itself. That section may have 0-n nested sections
+		assert( testCaseNode.children.size() == 1 );
+		SectionNode const& rootSection = *testCaseNode.children.front();
 
-            template<typename T>
-            ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
-                m_writer->writeAttribute( name, attribute );
-                return *this;
-            }
+		std::string className = stats.testInfo.className;
 
-        private:
-            mutable XmlWriter* m_writer = nullptr;
-        };
+		if( className.empty() ) {
+			className = fileNameTag(stats.testInfo.tags);
+			if ( className.empty() )
+				className = "global";
+		}
 
-        XmlWriter( std::ostream& os = Catch::cout() );
-        ~XmlWriter();
+		if ( !m_config->name().empty() )
+			className = m_config->name() + "." + className;
 
-        XmlWriter( XmlWriter const& ) = delete;
-        XmlWriter& operator=( XmlWriter const& ) = delete;
+		writeSection( className, "", rootSection );
+	}
 
-        XmlWriter& startElement( std::string const& name );
+	void JunitReporter::writeSection(  std::string const& className,
+		std::string const& rootName,
+		SectionNode const& sectionNode ) {
+		std::string name = trim( sectionNode.stats.sectionInfo.name );
+		if( !rootName.empty() )
+			name = rootName + '/' + name;
+
+		if( !sectionNode.assertions.empty() ||
+			!sectionNode.stdOut.empty() ||
+			!sectionNode.stdErr.empty() ) {
+			XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
+			if( className.empty() ) {
+				xml.writeAttribute( "classname", name );
+				xml.writeAttribute( "name", "root" );
+			}
+			else {
+				xml.writeAttribute( "classname", className );
+				xml.writeAttribute( "name", name );
+			}
+			xml.writeAttribute( "time", ::Catch::Detail::stringify( sectionNode.stats.durationInSeconds ) );
+
+			writeAssertions( sectionNode );
+
+			if( !sectionNode.stdOut.empty() )
+				xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), false );
+			if( !sectionNode.stdErr.empty() )
+				xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), false );
+		}
+		for( auto const& childNode : sectionNode.childSections )
+			if( className.empty() )
+				writeSection( name, "", *childNode );
+			else
+				writeSection( className, name, *childNode );
+	}
 
-        ScopedElement scopedElement( std::string const& name );
+	void JunitReporter::writeAssertions( SectionNode const& sectionNode ) {
+		for( auto const& assertion : sectionNode.assertions )
+			writeAssertion( assertion );
+	}
 
-        XmlWriter& endElement();
+	void JunitReporter::writeAssertion( AssertionStats const& stats ) {
+		AssertionResult const& result = stats.assertionResult;
+		if( !result.isOk() ) {
+			std::string elementName;
+			switch( result.getResultType() ) {
+			case ResultWas::ThrewException:
+			case ResultWas::FatalErrorCondition:
+				elementName = "error";
+				break;
+			case ResultWas::ExplicitFailure:
+				elementName = "failure";
+				break;
+			case ResultWas::ExpressionFailed:
+				elementName = "failure";
+				break;
+			case ResultWas::DidntThrowException:
+				elementName = "failure";
+				break;
+
+				// We should never see these here:
+			case ResultWas::Info:
+			case ResultWas::Warning:
+			case ResultWas::Ok:
+			case ResultWas::Unknown:
+			case ResultWas::FailureBit:
+			case ResultWas::Exception:
+				elementName = "internalError";
+				break;
+			}
+
+			XmlWriter::ScopedElement e = xml.scopedElement( elementName );
+
+			xml.writeAttribute( "message", result.getExpandedExpression() );
+			xml.writeAttribute( "type", result.getTestMacroName() );
+
+			ReusableStringStream rss;
+			if( !result.getMessage().empty() )
+				rss << result.getMessage() << '\n';
+			for( auto const& msg : stats.infoMessages )
+				if( msg.type == ResultWas::Info )
+					rss << msg.message << '\n';
+
+			rss << "at " << result.getSourceInfo();
+			xml.writeText( rss.str(), false );
+		}
+	}
 
-        XmlWriter& writeAttribute( std::string const& name, std::string const& attribute );
+	CATCH_REGISTER_REPORTER( "junit", JunitReporter )
 
-        XmlWriter& writeAttribute( std::string const& name, bool attribute );
+} // end namespace Catch
+  // end catch_reporter_junit.cpp
+  // start catch_reporter_listening.cpp
 
-        template<typename T>
-        XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
-            m_oss.clear();
-            m_oss.str(std::string());
-            m_oss << attribute;
-            return writeAttribute( name, m_oss.str() );
-        }
+#include <cassert>
 
-        XmlWriter& writeText( std::string const& text, bool indent = true );
+namespace Catch {
 
-        XmlWriter& writeComment( std::string const& text );
+	ListeningReporter::ListeningReporter() {
+		// We will assume that listeners will always want all assertions
+		m_preferences.shouldReportAllAssertions = true;
+	}
 
-        void writeStylesheetRef( std::string const& url );
+	void ListeningReporter::addListener( IStreamingReporterPtr&& listener ) {
+		m_listeners.push_back( std::move( listener ) );
+	}
 
-        XmlWriter& writeBlankLine();
+	void ListeningReporter::addReporter(IStreamingReporterPtr&& reporter) {
+		assert(!m_reporter && "Listening reporter can wrap only 1 real reporter");
+		m_reporter = std::move( reporter );
+		m_preferences.shouldRedirectStdOut = m_reporter->getPreferences().shouldRedirectStdOut;
+	}
 
-        void ensureTagClosed();
+	ReporterPreferences ListeningReporter::getPreferences() const {
+		return m_preferences;
+	}
 
-    private:
+	std::set<Verbosity> ListeningReporter::getSupportedVerbosities() {
+		return std::set<Verbosity>{ };
+	}
 
-        void writeDeclaration();
+	void ListeningReporter::noMatchingTestCases( std::string const& spec ) {
+		for ( auto const& listener : m_listeners ) {
+			listener->noMatchingTestCases( spec );
+		}
+		m_reporter->noMatchingTestCases( spec );
+	}
 
-        void newlineIfNecessary();
+	void ListeningReporter::benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) {
+		for ( auto const& listener : m_listeners ) {
+			listener->benchmarkStarting( benchmarkInfo );
+		}
+		m_reporter->benchmarkStarting( benchmarkInfo );
+	}
+	void ListeningReporter::benchmarkEnded( BenchmarkStats const& benchmarkStats ) {
+		for ( auto const& listener : m_listeners ) {
+			listener->benchmarkEnded( benchmarkStats );
+		}
+		m_reporter->benchmarkEnded( benchmarkStats );
+	}
 
-        bool m_tagIsOpen = false;
-        bool m_needsNewline = false;
-        std::vector<std::string> m_tags;
-        std::string m_indent;
-        std::ostream& m_os;
-        std::ostringstream m_oss;
-    };
+	void ListeningReporter::testRunStarting( TestRunInfo const& testRunInfo ) {
+		for ( auto const& listener : m_listeners ) {
+			listener->testRunStarting( testRunInfo );
+		}
+		m_reporter->testRunStarting( testRunInfo );
+	}
 
-}
+	void ListeningReporter::testGroupStarting( GroupInfo const& groupInfo ) {
+		for ( auto const& listener : m_listeners ) {
+			listener->testGroupStarting( groupInfo );
+		}
+		m_reporter->testGroupStarting( groupInfo );
+	}
 
-// end catch_xmlwriter.h
-#include <iomanip>
+	void ListeningReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
+		for ( auto const& listener : m_listeners ) {
+			listener->testCaseStarting( testInfo );
+		}
+		m_reporter->testCaseStarting( testInfo );
+	}
 
-namespace Catch {
+	void ListeningReporter::sectionStarting( SectionInfo const& sectionInfo ) {
+		for ( auto const& listener : m_listeners ) {
+			listener->sectionStarting( sectionInfo );
+		}
+		m_reporter->sectionStarting( sectionInfo );
+	}
 
-    XmlEncode::XmlEncode( std::string const& str, ForWhat forWhat )
-    :   m_str( str ),
-        m_forWhat( forWhat )
-    {}
-
-    void XmlEncode::encodeTo( std::ostream& os ) const {
-
-        // Apostrophe escaping not necessary if we always use " to write attributes
-        // (see: http://www.w3.org/TR/xml/#syntax)
-
-        for( std::size_t i = 0; i < m_str.size(); ++ i ) {
-            char c = m_str[i];
-            switch( c ) {
-                case '<':   os << "&lt;"; break;
-                case '&':   os << "&amp;"; break;
-
-                case '>':
-                    // See: http://www.w3.org/TR/xml/#syntax
-                    if( i > 2 && m_str[i-1] == ']' && m_str[i-2] == ']' )
-                        os << "&gt;";
-                    else
-                        os << c;
-                    break;
-
-                case '\"':
-                    if( m_forWhat == ForAttributes )
-                        os << "&quot;";
-                    else
-                        os << c;
-                    break;
-
-                default:
-                    // Escape control chars - based on contribution by @espenalb in PR #465 and
-                    // by @mrpi PR #588
-                    if ( ( c >= 0 && c < '\x09' ) || ( c > '\x0D' && c < '\x20') || c=='\x7F' ) {
-                        // see http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
-                        os << "\\x" << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
-                           << static_cast<int>( c );
-                    }
-                    else
-                        os << c;
-            }
-        }
-    }
-
-    std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
-        xmlEncode.encodeTo( os );
-        return os;
-    }
-
-    XmlWriter::ScopedElement::ScopedElement( XmlWriter* writer )
-    :   m_writer( writer )
-    {}
-
-    XmlWriter::ScopedElement::ScopedElement( ScopedElement&& other ) noexcept
-    :   m_writer( other.m_writer ){
-        other.m_writer = nullptr;
-    }
-    XmlWriter::ScopedElement& XmlWriter::ScopedElement::operator=( ScopedElement&& other ) noexcept {
-        if ( m_writer ) {
-            m_writer->endElement();
-        }
-        m_writer = other.m_writer;
-        other.m_writer = nullptr;
-        return *this;
-    }
-
-    XmlWriter::ScopedElement::~ScopedElement() {
-        if( m_writer )
-            m_writer->endElement();
-    }
-
-    XmlWriter::ScopedElement& XmlWriter::ScopedElement::writeText( std::string const& text, bool indent ) {
-        m_writer->writeText( text, indent );
-        return *this;
-    }
-
-    XmlWriter::XmlWriter( std::ostream& os ) : m_os( os )
-    {
-        writeDeclaration();
-    }
-
-    XmlWriter::~XmlWriter() {
-        while( !m_tags.empty() )
-            endElement();
-    }
-
-    XmlWriter& XmlWriter::startElement( std::string const& name ) {
-        ensureTagClosed();
-        newlineIfNecessary();
-        m_os << m_indent << '<' << name;
-        m_tags.push_back( name );
-        m_indent += "  ";
-        m_tagIsOpen = true;
-        return *this;
-    }
-
-    XmlWriter::ScopedElement XmlWriter::scopedElement( std::string const& name ) {
-        ScopedElement scoped( this );
-        startElement( name );
-        return scoped;
-    }
-
-    XmlWriter& XmlWriter::endElement() {
-        newlineIfNecessary();
-        m_indent = m_indent.substr( 0, m_indent.size()-2 );
-        if( m_tagIsOpen ) {
-            m_os << "/>";
-            m_tagIsOpen = false;
-        }
-        else {
-            m_os << m_indent << "</" << m_tags.back() << ">";
-        }
-        m_os << std::endl;
-        m_tags.pop_back();
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeAttribute( std::string const& name, std::string const& attribute ) {
-        if( !name.empty() && !attribute.empty() )
-            m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeAttribute( std::string const& name, bool attribute ) {
-        m_os << ' ' << name << "=\"" << ( attribute ? "true" : "false" ) << '"';
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeText( std::string const& text, bool indent ) {
-        if( !text.empty() ){
-            bool tagWasOpen = m_tagIsOpen;
-            ensureTagClosed();
-            if( tagWasOpen && indent )
-                m_os << m_indent;
-            m_os << XmlEncode( text );
-            m_needsNewline = true;
-        }
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeComment( std::string const& text ) {
-        ensureTagClosed();
-        m_os << m_indent << "<!--" << text << "-->";
-        m_needsNewline = true;
-        return *this;
-    }
-
-    void XmlWriter::writeStylesheetRef( std::string const& url ) {
-        m_os << "<?xml-stylesheet type=\"text/xsl\" href=\"" << url << "\"?>\n";
-    }
-
-    XmlWriter& XmlWriter::writeBlankLine() {
-        ensureTagClosed();
-        m_os << '\n';
-        return *this;
-    }
-
-    void XmlWriter::ensureTagClosed() {
-        if( m_tagIsOpen ) {
-            m_os << ">" << std::endl;
-            m_tagIsOpen = false;
-        }
-    }
-
-    void XmlWriter::writeDeclaration() {
-        m_os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
-    }
-
-    void XmlWriter::newlineIfNecessary() {
-        if( m_needsNewline ) {
-            m_os << std::endl;
-            m_needsNewline = false;
-        }
-    }
-}
-// end catch_xmlwriter.cpp
-// start catch_reporter_bases.cpp
+	void ListeningReporter::assertionStarting( AssertionInfo const& assertionInfo ) {
+		for ( auto const& listener : m_listeners ) {
+			listener->assertionStarting( assertionInfo );
+		}
+		m_reporter->assertionStarting( assertionInfo );
+	}
 
-#include <cstring>
-#include <cfloat>
-#include <cstdio>
-#include <assert.h>
-#include <memory>
+	// The return value indicates if the messages buffer should be cleared:
+	bool ListeningReporter::assertionEnded( AssertionStats const& assertionStats ) {
+		for( auto const& listener : m_listeners ) {
+			static_cast<void>( listener->assertionEnded( assertionStats ) );
+		}
+		return m_reporter->assertionEnded( assertionStats );
+	}
 
-namespace Catch {
-    void prepareExpandedExpression(AssertionResult& result) {
-        result.getExpandedExpression();
-    }
+	void ListeningReporter::sectionEnded( SectionStats const& sectionStats ) {
+		for ( auto const& listener : m_listeners ) {
+			listener->sectionEnded( sectionStats );
+		}
+		m_reporter->sectionEnded( sectionStats );
+	}
 
-    // Because formatting using c++ streams is stateful, drop down to C is required
-    // Alternatively we could use stringstream, but its performance is... not good.
-    std::string getFormattedDuration( double duration ) {
-        // Max exponent + 1 is required to represent the whole part
-        // + 1 for decimal point
-        // + 3 for the 3 decimal places
-        // + 1 for null terminator
-        const std::size_t maxDoubleSize = DBL_MAX_10_EXP + 1 + 1 + 3 + 1;
-        char buffer[maxDoubleSize];
+	void ListeningReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+		for ( auto const& listener : m_listeners ) {
+			listener->testCaseEnded( testCaseStats );
+		}
+		m_reporter->testCaseEnded( testCaseStats );
+	}
 
-        // Save previous errno, to prevent sprintf from overwriting it
-        ErrnoGuard guard;
-#ifdef _MSC_VER
-        sprintf_s(buffer, "%.3f", duration);
-#else
-        sprintf(buffer, "%.3f", duration);
-#endif
-        return std::string(buffer);
-    }
+	void ListeningReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
+		for ( auto const& listener : m_listeners ) {
+			listener->testGroupEnded( testGroupStats );
+		}
+		m_reporter->testGroupEnded( testGroupStats );
+	}
 
-    TestEventListenerBase::TestEventListenerBase(ReporterConfig const & _config)
-        :StreamingReporterBase(_config) {}
+	void ListeningReporter::testRunEnded( TestRunStats const& testRunStats ) {
+		for ( auto const& listener : m_listeners ) {
+			listener->testRunEnded( testRunStats );
+		}
+		m_reporter->testRunEnded( testRunStats );
+	}
 
-    void TestEventListenerBase::assertionStarting(AssertionInfo const &) {}
+	void ListeningReporter::skipTest( TestCaseInfo const& testInfo ) {
+		for ( auto const& listener : m_listeners ) {
+			listener->skipTest( testInfo );
+		}
+		m_reporter->skipTest( testInfo );
+	}
 
-    bool TestEventListenerBase::assertionEnded(AssertionStats const &) {
-        return false;
-    }
+	bool ListeningReporter::isMulti() const {
+		return true;
+	}
 
 } // end namespace Catch
-// end catch_reporter_bases.cpp
-// start catch_reporter_compact.cpp
+  // end catch_reporter_listening.cpp
+  // start catch_reporter_xml.cpp
 
-namespace {
-
-#ifdef CATCH_PLATFORM_MAC
-    const char* failedString() { return "FAILED"; }
-    const char* passedString() { return "PASSED"; }
-#else
-    const char* failedString() { return "failed"; }
-    const char* passedString() { return "passed"; }
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
+  // Note that 4062 (not all labels are handled
+  // and default is missing) is enabled
 #endif
 
-    // Colour::LightGrey
-    Catch::Colour::Code dimColour() { return Catch::Colour::FileName; }
+namespace Catch {
+	XmlReporter::XmlReporter( ReporterConfig const& _config )
+		:   StreamingReporterBase( _config ),
+		m_xml(_config.stream())
+	{
+		m_reporterPrefs.shouldRedirectStdOut = true;
+		m_reporterPrefs.shouldReportAllAssertions = true;
+	}
 
-    std::string bothOrAll( std::size_t count ) {
-        return count == 1 ? std::string() :
-               count == 2 ? "both " : "all " ;
-    }
-}
+	XmlReporter::~XmlReporter() = default;
 
-namespace Catch {
+	std::string XmlReporter::getDescription() {
+		return "Reports test results as an XML document";
+	}
 
-    struct CompactReporter : StreamingReporterBase<CompactReporter> {
-
-        using StreamingReporterBase::StreamingReporterBase;
-
-        ~CompactReporter() override;
-
-        static std::string getDescription() {
-            return "Reports test results on a single line, suitable for IDEs";
-        }
-
-        ReporterPreferences getPreferences() const override {
-            ReporterPreferences prefs;
-            prefs.shouldRedirectStdOut = false;
-            return prefs;
-        }
-
-        void noMatchingTestCases( std::string const& spec ) override {
-            stream << "No test cases matched '" << spec << '\'' << std::endl;
-        }
-
-        void assertionStarting( AssertionInfo const& ) override {}
-
-        bool assertionEnded( AssertionStats const& _assertionStats ) override {
-            AssertionResult const& result = _assertionStats.assertionResult;
-
-            bool printInfoMessages = true;
-
-            // Drop out if result was successful and we're not printing those
-            if( !m_config->includeSuccessfulResults() && result.isOk() ) {
-                if( result.getResultType() != ResultWas::Warning )
-                    return false;
-                printInfoMessages = false;
-            }
-
-            AssertionPrinter printer( stream, _assertionStats, printInfoMessages );
-            printer.print();
-
-            stream << std::endl;
-            return true;
-        }
-
-        void sectionEnded(SectionStats const& _sectionStats) override {
-            if (m_config->showDurations() == ShowDurations::Always) {
-                stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
-            }
-        }
-
-        void testRunEnded( TestRunStats const& _testRunStats ) override {
-            printTotals( _testRunStats.totals );
-            stream << '\n' << std::endl;
-            StreamingReporterBase::testRunEnded( _testRunStats );
-        }
-
-    private:
-        class AssertionPrinter {
-        public:
-            AssertionPrinter& operator= ( AssertionPrinter const& ) = delete;
-            AssertionPrinter( AssertionPrinter const& ) = delete;
-            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages )
-            : stream( _stream )
-            , result( _stats.assertionResult )
-            , messages( _stats.infoMessages )
-            , itMessage( _stats.infoMessages.begin() )
-            , printInfoMessages( _printInfoMessages )
-            {}
-
-            void print() {
-                printSourceInfo();
-
-                itMessage = messages.begin();
-
-                switch( result.getResultType() ) {
-                    case ResultWas::Ok:
-                        printResultType( Colour::ResultSuccess, passedString() );
-                        printOriginalExpression();
-                        printReconstructedExpression();
-                        if ( ! result.hasExpression() )
-                            printRemainingMessages( Colour::None );
-                        else
-                            printRemainingMessages();
-                        break;
-                    case ResultWas::ExpressionFailed:
-                        if( result.isOk() )
-                            printResultType( Colour::ResultSuccess, failedString() + std::string( " - but was ok" ) );
-                        else
-                            printResultType( Colour::Error, failedString() );
-                        printOriginalExpression();
-                        printReconstructedExpression();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::ThrewException:
-                        printResultType( Colour::Error, failedString() );
-                        printIssue( "unexpected exception with message:" );
-                        printMessage();
-                        printExpressionWas();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::FatalErrorCondition:
-                        printResultType( Colour::Error, failedString() );
-                        printIssue( "fatal error condition with message:" );
-                        printMessage();
-                        printExpressionWas();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::DidntThrowException:
-                        printResultType( Colour::Error, failedString() );
-                        printIssue( "expected exception, got none" );
-                        printExpressionWas();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::Info:
-                        printResultType( Colour::None, "info" );
-                        printMessage();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::Warning:
-                        printResultType( Colour::None, "warning" );
-                        printMessage();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::ExplicitFailure:
-                        printResultType( Colour::Error, failedString() );
-                        printIssue( "explicitly" );
-                        printRemainingMessages( Colour::None );
-                        break;
-                    // These cases are here to prevent compiler warnings
-                    case ResultWas::Unknown:
-                    case ResultWas::FailureBit:
-                    case ResultWas::Exception:
-                        printResultType( Colour::Error, "** internal error **" );
-                        break;
-                }
-            }
-
-        private:
-            void printSourceInfo() const {
-                Colour colourGuard( Colour::FileName );
-                stream << result.getSourceInfo() << ':';
-            }
-
-            void printResultType( Colour::Code colour, std::string const& passOrFail ) const {
-                if( !passOrFail.empty() ) {
-                    {
-                        Colour colourGuard( colour );
-                        stream << ' ' << passOrFail;
-                    }
-                    stream << ':';
-                }
-            }
-
-            void printIssue( std::string const& issue ) const {
-                stream << ' ' << issue;
-            }
-
-            void printExpressionWas() {
-                if( result.hasExpression() ) {
-                    stream << ';';
-                    {
-                        Colour colour( dimColour() );
-                        stream << " expression was:";
-                    }
-                    printOriginalExpression();
-                }
-            }
-
-            void printOriginalExpression() const {
-                if( result.hasExpression() ) {
-                    stream << ' ' << result.getExpression();
-                }
-            }
-
-            void printReconstructedExpression() const {
-                if( result.hasExpandedExpression() ) {
-                    {
-                        Colour colour( dimColour() );
-                        stream << " for: ";
-                    }
-                    stream << result.getExpandedExpression();
-                }
-            }
-
-            void printMessage() {
-                if ( itMessage != messages.end() ) {
-                    stream << " '" << itMessage->message << '\'';
-                    ++itMessage;
-                }
-            }
-
-            void printRemainingMessages( Colour::Code colour = dimColour() ) {
-                if ( itMessage == messages.end() )
-                    return;
-
-                // using messages.end() directly yields (or auto) compilation error:
-                std::vector<MessageInfo>::const_iterator itEnd = messages.end();
-                const std::size_t N = static_cast<std::size_t>( std::distance( itMessage, itEnd ) );
-
-                {
-                    Colour colourGuard( colour );
-                    stream << " with " << pluralise( N, "message" ) << ':';
-                }
-
-                for(; itMessage != itEnd; ) {
-                    // If this assertion is a warning ignore any INFO messages
-                    if( printInfoMessages || itMessage->type != ResultWas::Info ) {
-                        stream << " '" << itMessage->message << '\'';
-                        if ( ++itMessage != itEnd ) {
-                            Colour colourGuard( dimColour() );
-                            stream << " and";
-                        }
-                    }
-                }
-            }
-
-        private:
-            std::ostream& stream;
-            AssertionResult const& result;
-            std::vector<MessageInfo> messages;
-            std::vector<MessageInfo>::const_iterator itMessage;
-            bool printInfoMessages;
-        };
-
-        // Colour, message variants:
-        // - white: No tests ran.
-        // -   red: Failed [both/all] N test cases, failed [both/all] M assertions.
-        // - white: Passed [both/all] N test cases (no assertions).
-        // -   red: Failed N tests cases, failed M assertions.
-        // - green: Passed [both/all] N tests cases with M assertions.
-
-        void printTotals( const Totals& totals ) const {
-            if( totals.testCases.total() == 0 ) {
-                stream << "No tests ran.";
-            }
-            else if( totals.testCases.failed == totals.testCases.total() ) {
-                Colour colour( Colour::ResultError );
-                const std::string qualify_assertions_failed =
-                    totals.assertions.failed == totals.assertions.total() ?
-                        bothOrAll( totals.assertions.failed ) : std::string();
-                stream <<
-                    "Failed " << bothOrAll( totals.testCases.failed )
-                              << pluralise( totals.testCases.failed, "test case"  ) << ", "
-                    "failed " << qualify_assertions_failed <<
-                                 pluralise( totals.assertions.failed, "assertion" ) << '.';
-            }
-            else if( totals.assertions.total() == 0 ) {
-                stream <<
-                    "Passed " << bothOrAll( totals.testCases.total() )
-                              << pluralise( totals.testCases.total(), "test case" )
-                              << " (no assertions).";
-            }
-            else if( totals.assertions.failed ) {
-                Colour colour( Colour::ResultError );
-                stream <<
-                    "Failed " << pluralise( totals.testCases.failed, "test case"  ) << ", "
-                    "failed " << pluralise( totals.assertions.failed, "assertion" ) << '.';
-            }
-            else {
-                Colour colour( Colour::ResultSuccess );
-                stream <<
-                    "Passed " << bothOrAll( totals.testCases.passed )
-                              << pluralise( totals.testCases.passed, "test case"  ) <<
-                    " with "  << pluralise( totals.assertions.passed, "assertion" ) << '.';
-            }
-        }
-    };
-
-    CompactReporter::~CompactReporter() {}
-
-    CATCH_REGISTER_REPORTER( "compact", CompactReporter )
+	std::string XmlReporter::getStylesheetRef() const {
+		return std::string();
+	}
 
-} // end namespace Catch
-// end catch_reporter_compact.cpp
-// start catch_reporter_console.cpp
+	void XmlReporter::writeSourceInfo( SourceLineInfo const& sourceInfo ) {
+		m_xml
+			.writeAttribute( "filename", sourceInfo.file )
+			.writeAttribute( "line", sourceInfo.line );
+	}
 
-#include <cfloat>
-#include <cstdio>
+	void XmlReporter::noMatchingTestCases( std::string const& s ) {
+		StreamingReporterBase::noMatchingTestCases( s );
+	}
 
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
-                              // Note that 4062 (not all labels are handled
-                              // and default is missing) is enabled
-#endif
-
-namespace Catch {
-
-    namespace {
-        std::size_t makeRatio( std::size_t number, std::size_t total ) {
-            std::size_t ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number/ total : 0;
-            return ( ratio == 0 && number > 0 ) ? 1 : ratio;
-        }
-
-        std::size_t& findMax( std::size_t& i, std::size_t& j, std::size_t& k ) {
-            if( i > j && i > k )
-                return i;
-            else if( j > k )
-                return j;
-            else
-                return k;
-        }
-
-        struct ColumnInfo {
-            enum Justification { Left, Right };
-            std::string name;
-            int width;
-            Justification justification;
-        };
-        struct ColumnBreak {};
-        struct RowBreak {};
-
-        class TablePrinter {
-            std::ostream& m_os;
-            std::vector<ColumnInfo> m_columnInfos;
-            std::ostringstream m_oss;
-            int m_currentColumn = -1;
-            bool m_isOpen = false;
-
-        public:
-            TablePrinter( std::ostream& os, std::vector<ColumnInfo> const& columnInfos )
-            :   m_os( os ),
-                m_columnInfos( columnInfos )
-            {}
-
-            auto columnInfos() const -> std::vector<ColumnInfo> const& {
-                return m_columnInfos;
-            }
-
-            void open() {
-                if( !m_isOpen ) {
-                    m_isOpen = true;
-                    *this << RowBreak();
-                    for( auto const& info : m_columnInfos )
-                        *this << info.name << ColumnBreak();
-                    *this << RowBreak();
-                    m_os << Catch::getLineOfChars<'-'>() << "\n";
-                }
-            }
-            void close() {
-                if( m_isOpen ) {
-                    *this << RowBreak();
-                    m_os << std::endl;
-                    m_isOpen = false;
-                }
-            }
-
-            template<typename T>
-            friend TablePrinter& operator << ( TablePrinter& tp, T const& value ) {
-                tp.m_oss << value;
-                return tp;
-            }
-
-            friend TablePrinter& operator << ( TablePrinter& tp, ColumnBreak ) {
-                auto colStr = tp.m_oss.str();
-                // This takes account of utf8 encodings
-                auto strSize = Catch::StringRef( colStr ).numberOfCharacters();
-                tp.m_oss.str("");
-                tp.open();
-                if( tp.m_currentColumn == static_cast<int>(tp.m_columnInfos.size()-1) ) {
-                    tp.m_currentColumn = -1;
-                    tp.m_os << "\n";
-                }
-                tp.m_currentColumn++;
-
-                auto colInfo = tp.m_columnInfos[tp.m_currentColumn];
-                auto padding = ( strSize+2 < static_cast<std::size_t>( colInfo.width ) )
-                    ? std::string( colInfo.width-(strSize+2), ' ' )
-                    : std::string();
-                if( colInfo.justification == ColumnInfo::Left )
-                    tp.m_os << colStr << padding << " ";
-                else
-                    tp.m_os << padding << colStr << " ";
-                return tp;
-            }
-
-            friend TablePrinter& operator << ( TablePrinter& tp, RowBreak ) {
-                if( tp.m_currentColumn > 0 ) {
-                    tp.m_os << "\n";
-                    tp.m_currentColumn = -1;
-                }
-                return tp;
-            }
-        };
-
-        class Duration {
-            enum class Unit {
-                Auto,
-                Nanoseconds,
-                Microseconds,
-                Milliseconds,
-                Seconds,
-                Minutes
-            };
-            static const uint64_t s_nanosecondsInAMicrosecond = 1000;
-            static const uint64_t s_nanosecondsInAMillisecond = 1000*s_nanosecondsInAMicrosecond;
-            static const uint64_t s_nanosecondsInASecond = 1000*s_nanosecondsInAMillisecond;
-            static const uint64_t s_nanosecondsInAMinute = 60*s_nanosecondsInASecond;
-
-            uint64_t m_inNanoseconds;
-            Unit m_units;
-
-        public:
-            Duration( uint64_t inNanoseconds, Unit units = Unit::Auto )
-            :   m_inNanoseconds( inNanoseconds ),
-                m_units( units )
-            {
-                if( m_units == Unit::Auto ) {
-                    if( m_inNanoseconds < s_nanosecondsInAMicrosecond )
-                        m_units = Unit::Nanoseconds;
-                    else if( m_inNanoseconds < s_nanosecondsInAMillisecond )
-                        m_units = Unit::Microseconds;
-                    else if( m_inNanoseconds < s_nanosecondsInASecond )
-                        m_units = Unit::Milliseconds;
-                    else if( m_inNanoseconds < s_nanosecondsInAMinute )
-                        m_units = Unit::Seconds;
-                    else
-                        m_units = Unit::Minutes;
-                }
-
-            }
-
-            auto value() const -> double {
-                switch( m_units ) {
-                    case Unit::Microseconds:
-                        return m_inNanoseconds / static_cast<double>( s_nanosecondsInAMicrosecond );
-                    case Unit::Milliseconds:
-                        return m_inNanoseconds / static_cast<double>( s_nanosecondsInAMillisecond );
-                    case Unit::Seconds:
-                        return m_inNanoseconds / static_cast<double>( s_nanosecondsInASecond );
-                    case Unit::Minutes:
-                        return m_inNanoseconds / static_cast<double>( s_nanosecondsInAMinute );
-                    default:
-                        return static_cast<double>( m_inNanoseconds );
-                }
-            }
-            auto unitsAsString() const -> std::string {
-                switch( m_units ) {
-                    case Unit::Nanoseconds:
-                        return "ns";
-                    case Unit::Microseconds:
-                        return "µs";
-                    case Unit::Milliseconds:
-                        return "ms";
-                    case Unit::Seconds:
-                        return "s";
-                    case Unit::Minutes:
-                        return "m";
-                    default:
-                        return "** internal error **";
-                }
-
-            }
-            friend auto operator << ( std::ostream& os, Duration const& duration ) -> std::ostream& {
-                return os << duration.value() << " " << duration.unitsAsString();
-            }
-        };
-    } // end anon namespace
-
-    struct ConsoleReporter : StreamingReporterBase<ConsoleReporter> {
-        TablePrinter m_tablePrinter;
-
-        ConsoleReporter( ReporterConfig const& config )
-        :   StreamingReporterBase( config ),
-            m_tablePrinter( config.stream(),
-                            {
-                                { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH-32, ColumnInfo::Left },
-                                { "iters", 8, ColumnInfo::Right },
-                                { "elapsed ns", 14, ColumnInfo::Right },
-                                { "average", 14, ColumnInfo::Right }
-                            } )
-        {}
-        ~ConsoleReporter() override;
-        static std::string getDescription() {
-            return "Reports test results as plain lines of text";
-        }
-
-        void noMatchingTestCases( std::string const& spec ) override {
-            stream << "No test cases matched '" << spec << '\'' << std::endl;
-        }
-
-        void assertionStarting( AssertionInfo const& ) override {
-        }
-
-        bool assertionEnded( AssertionStats const& _assertionStats ) override {
-            AssertionResult const& result = _assertionStats.assertionResult;
-
-            bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
-
-            // Drop out if result was successful but we're not printing them.
-            if( !includeResults && result.getResultType() != ResultWas::Warning )
-                return false;
-
-            lazyPrint();
-
-            AssertionPrinter printer( stream, _assertionStats, includeResults );
-            printer.print();
-            stream << std::endl;
-            return true;
-        }
-
-        void sectionStarting( SectionInfo const& _sectionInfo ) override {
-            m_headerPrinted = false;
-            StreamingReporterBase::sectionStarting( _sectionInfo );
-        }
-        void sectionEnded( SectionStats const& _sectionStats ) override {
-            m_tablePrinter.close();
-            if( _sectionStats.missingAssertions ) {
-                lazyPrint();
-                Colour colour( Colour::ResultError );
-                if( m_sectionStack.size() > 1 )
-                    stream << "\nNo assertions in section";
-                else
-                    stream << "\nNo assertions in test case";
-                stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl;
-            }
-            if( m_config->showDurations() == ShowDurations::Always ) {
-                stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
-            }
-            if( m_headerPrinted ) {
-                m_headerPrinted = false;
-            }
-            StreamingReporterBase::sectionEnded( _sectionStats );
-        }
-
-        void benchmarkStarting( BenchmarkInfo const& info ) override {
-            lazyPrintWithoutClosingBenchmarkTable();
-
-            auto nameCol = Column( info.name ).width( m_tablePrinter.columnInfos()[0].width-2 );
-
-            bool firstLine = true;
-            for( auto line : nameCol ) {
-                if( !firstLine )
-                    m_tablePrinter << ColumnBreak() << ColumnBreak() << ColumnBreak();
-                else
-                    firstLine = false;
-
-                m_tablePrinter << line << ColumnBreak();
-            }
-        }
-        void benchmarkEnded( BenchmarkStats const& stats ) override {
-            Duration average( stats.elapsedTimeInNanoseconds/stats.iterations );
-            m_tablePrinter
-                    << stats.iterations << ColumnBreak()
-                    << stats.elapsedTimeInNanoseconds << ColumnBreak()
-                    << average << ColumnBreak();
-        }
-
-        void testCaseEnded( TestCaseStats const& _testCaseStats ) override {
-            m_tablePrinter.close();
-            StreamingReporterBase::testCaseEnded( _testCaseStats );
-            m_headerPrinted = false;
-        }
-        void testGroupEnded( TestGroupStats const& _testGroupStats ) override {
-            if( currentGroupInfo.used ) {
-                printSummaryDivider();
-                stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
-                printTotals( _testGroupStats.totals );
-                stream << '\n' << std::endl;
-            }
-            StreamingReporterBase::testGroupEnded( _testGroupStats );
-        }
-        void testRunEnded( TestRunStats const& _testRunStats ) override {
-            printTotalsDivider( _testRunStats.totals );
-            printTotals( _testRunStats.totals );
-            stream << std::endl;
-            StreamingReporterBase::testRunEnded( _testRunStats );
-        }
-
-    private:
-
-        class AssertionPrinter {
-        public:
-            AssertionPrinter& operator= ( AssertionPrinter const& ) = delete;
-            AssertionPrinter( AssertionPrinter const& ) = delete;
-            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages )
-            :   stream( _stream ),
-                stats( _stats ),
-                result( _stats.assertionResult ),
-                colour( Colour::None ),
-                message( result.getMessage() ),
-                messages( _stats.infoMessages ),
-                printInfoMessages( _printInfoMessages )
-            {
-                switch( result.getResultType() ) {
-                    case ResultWas::Ok:
-                        colour = Colour::Success;
-                        passOrFail = "PASSED";
-                        //if( result.hasMessage() )
-                        if( _stats.infoMessages.size() == 1 )
-                            messageLabel = "with message";
-                        if( _stats.infoMessages.size() > 1 )
-                            messageLabel = "with messages";
-                        break;
-                    case ResultWas::ExpressionFailed:
-                        if( result.isOk() ) {
-                            colour = Colour::Success;
-                            passOrFail = "FAILED - but was ok";
-                        }
-                        else {
-                            colour = Colour::Error;
-                            passOrFail = "FAILED";
-                        }
-                        if( _stats.infoMessages.size() == 1 )
-                            messageLabel = "with message";
-                        if( _stats.infoMessages.size() > 1 )
-                            messageLabel = "with messages";
-                        break;
-                    case ResultWas::ThrewException:
-                        colour = Colour::Error;
-                        passOrFail = "FAILED";
-                        messageLabel = "due to unexpected exception with ";
-                        if (_stats.infoMessages.size() == 1)
-                            messageLabel += "message";
-                        if (_stats.infoMessages.size() > 1)
-                            messageLabel += "messages";
-                        break;
-                    case ResultWas::FatalErrorCondition:
-                        colour = Colour::Error;
-                        passOrFail = "FAILED";
-                        messageLabel = "due to a fatal error condition";
-                        break;
-                    case ResultWas::DidntThrowException:
-                        colour = Colour::Error;
-                        passOrFail = "FAILED";
-                        messageLabel = "because no exception was thrown where one was expected";
-                        break;
-                    case ResultWas::Info:
-                        messageLabel = "info";
-                        break;
-                    case ResultWas::Warning:
-                        messageLabel = "warning";
-                        break;
-                    case ResultWas::ExplicitFailure:
-                        passOrFail = "FAILED";
-                        colour = Colour::Error;
-                        if( _stats.infoMessages.size() == 1 )
-                            messageLabel = "explicitly with message";
-                        if( _stats.infoMessages.size() > 1 )
-                            messageLabel = "explicitly with messages";
-                        break;
-                    // These cases are here to prevent compiler warnings
-                    case ResultWas::Unknown:
-                    case ResultWas::FailureBit:
-                    case ResultWas::Exception:
-                        passOrFail = "** internal error **";
-                        colour = Colour::Error;
-                        break;
-                }
-            }
-
-            void print() const {
-                printSourceInfo();
-                if( stats.totals.assertions.total() > 0 ) {
-                    if( result.isOk() )
-                        stream << '\n';
-                    printResultType();
-                    printOriginalExpression();
-                    printReconstructedExpression();
-                }
-                else {
-                    stream << '\n';
-                }
-                printMessage();
-            }
-
-        private:
-            void printResultType() const {
-                if( !passOrFail.empty() ) {
-                    Colour colourGuard( colour );
-                    stream << passOrFail << ":\n";
-                }
-            }
-            void printOriginalExpression() const {
-                if( result.hasExpression() ) {
-                    Colour colourGuard( Colour::OriginalExpression );
-                    stream  << "  ";
-                    stream << result.getExpressionInMacro();
-                    stream << '\n';
-                }
-            }
-            void printReconstructedExpression() const {
-                if( result.hasExpandedExpression() ) {
-                    stream << "with expansion:\n";
-                    Colour colourGuard( Colour::ReconstructedExpression );
-                    stream << Column( result.getExpandedExpression() ).indent(2) << '\n';
-                }
-            }
-            void printMessage() const {
-                if( !messageLabel.empty() )
-                    stream << messageLabel << ':' << '\n';
-                for( auto const& msg : messages ) {
-                    // If this assertion is a warning ignore any INFO messages
-                    if( printInfoMessages || msg.type != ResultWas::Info )
-                        stream << Column( msg.message ).indent(2) << '\n';
-                }
-            }
-            void printSourceInfo() const {
-                Colour colourGuard( Colour::FileName );
-                stream << result.getSourceInfo() << ": ";
-            }
-
-            std::ostream& stream;
-            AssertionStats const& stats;
-            AssertionResult const& result;
-            Colour::Code colour;
-            std::string passOrFail;
-            std::string messageLabel;
-            std::string message;
-            std::vector<MessageInfo> messages;
-            bool printInfoMessages;
-        };
-
-        void lazyPrint() {
-
-            m_tablePrinter.close();
-            lazyPrintWithoutClosingBenchmarkTable();
-        }
-
-        void lazyPrintWithoutClosingBenchmarkTable() {
-
-            if( !currentTestRunInfo.used )
-                lazyPrintRunInfo();
-            if( !currentGroupInfo.used )
-                lazyPrintGroupInfo();
-
-            if( !m_headerPrinted ) {
-                printTestCaseAndSectionHeader();
-                m_headerPrinted = true;
-            }
-        }
-        void lazyPrintRunInfo() {
-            stream  << '\n' << getLineOfChars<'~'>() << '\n';
-            Colour colour( Colour::SecondaryText );
-            stream  << currentTestRunInfo->name
-                    << " is a Catch v"  << libraryVersion() << " host application.\n"
-                    << "Run with -? for options\n\n";
-
-            if( m_config->rngSeed() != 0 )
-                stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n";
-
-            currentTestRunInfo.used = true;
-        }
-        void lazyPrintGroupInfo() {
-            if( !currentGroupInfo->name.empty() && currentGroupInfo->groupsCounts > 1 ) {
-                printClosedHeader( "Group: " + currentGroupInfo->name );
-                currentGroupInfo.used = true;
-            }
-        }
-        void printTestCaseAndSectionHeader() {
-            assert( !m_sectionStack.empty() );
-            printOpenHeader( currentTestCaseInfo->name );
-
-            if( m_sectionStack.size() > 1 ) {
-                Colour colourGuard( Colour::Headers );
-
-                auto
-                    it = m_sectionStack.begin()+1, // Skip first section (test case)
-                    itEnd = m_sectionStack.end();
-                for( ; it != itEnd; ++it )
-                    printHeaderString( it->name, 2 );
-            }
-
-            SourceLineInfo lineInfo = m_sectionStack.back().lineInfo;
-
-            if( !lineInfo.empty() ){
-                stream << getLineOfChars<'-'>() << '\n';
-                Colour colourGuard( Colour::FileName );
-                stream << lineInfo << '\n';
-            }
-            stream << getLineOfChars<'.'>() << '\n' << std::endl;
-        }
-
-        void printClosedHeader( std::string const& _name ) {
-            printOpenHeader( _name );
-            stream << getLineOfChars<'.'>() << '\n';
-        }
-        void printOpenHeader( std::string const& _name ) {
-            stream  << getLineOfChars<'-'>() << '\n';
-            {
-                Colour colourGuard( Colour::Headers );
-                printHeaderString( _name );
-            }
-        }
-
-        // if string has a : in first line will set indent to follow it on
-        // subsequent lines
-        void printHeaderString( std::string const& _string, std::size_t indent = 0 ) {
-            std::size_t i = _string.find( ": " );
-            if( i != std::string::npos )
-                i+=2;
-            else
-                i = 0;
-            stream << Column( _string ).indent( indent+i ).initialIndent( indent ) << '\n';
-        }
-
-        struct SummaryColumn {
-
-            SummaryColumn( std::string const& _label, Colour::Code _colour )
-            :   label( _label ),
-                colour( _colour )
-            {}
-            SummaryColumn addRow( std::size_t count ) {
-                std::ostringstream oss;
-                oss << count;
-                std::string row = oss.str();
-                for( auto& oldRow : rows ) {
-                    while( oldRow.size() < row.size() )
-                        oldRow = ' ' + oldRow;
-                    while( oldRow.size() > row.size() )
-                        row = ' ' + row;
-                }
-                rows.push_back( row );
-                return *this;
-            }
-
-            std::string label;
-            Colour::Code colour;
-            std::vector<std::string> rows;
-
-        };
-
-        void printTotals( Totals const& totals ) {
-            if( totals.testCases.total() == 0 ) {
-                stream << Colour( Colour::Warning ) << "No tests ran\n";
-            }
-            else if( totals.assertions.total() > 0 && totals.testCases.allPassed() ) {
-                stream << Colour( Colour::ResultSuccess ) << "All tests passed";
-                stream << " ("
-                        << pluralise( totals.assertions.passed, "assertion" ) << " in "
-                        << pluralise( totals.testCases.passed, "test case" ) << ')'
-                        << '\n';
-            }
-            else {
-
-                std::vector<SummaryColumn> columns;
-                columns.push_back( SummaryColumn( "", Colour::None )
-                                        .addRow( totals.testCases.total() )
-                                        .addRow( totals.assertions.total() ) );
-                columns.push_back( SummaryColumn( "passed", Colour::Success )
-                                        .addRow( totals.testCases.passed )
-                                        .addRow( totals.assertions.passed ) );
-                columns.push_back( SummaryColumn( "failed", Colour::ResultError )
-                                        .addRow( totals.testCases.failed )
-                                        .addRow( totals.assertions.failed ) );
-                columns.push_back( SummaryColumn( "failed as expected", Colour::ResultExpectedFailure )
-                                        .addRow( totals.testCases.failedButOk )
-                                        .addRow( totals.assertions.failedButOk ) );
-
-                printSummaryRow( "test cases", columns, 0 );
-                printSummaryRow( "assertions", columns, 1 );
-            }
-        }
-        void printSummaryRow( std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row ) {
-            for( auto col : cols ) {
-                std::string value = col.rows[row];
-                if( col.label.empty() ) {
-                    stream << label << ": ";
-                    if( value != "0" )
-                        stream << value;
-                    else
-                        stream << Colour( Colour::Warning ) << "- none -";
-                }
-                else if( value != "0" ) {
-                    stream  << Colour( Colour::LightGrey ) << " | ";
-                    stream  << Colour( col.colour )
-                            << value << ' ' << col.label;
-                }
-            }
-            stream << '\n';
-        }
-
-        void printTotalsDivider( Totals const& totals ) {
-            if( totals.testCases.total() > 0 ) {
-                std::size_t failedRatio = makeRatio( totals.testCases.failed, totals.testCases.total() );
-                std::size_t failedButOkRatio = makeRatio( totals.testCases.failedButOk, totals.testCases.total() );
-                std::size_t passedRatio = makeRatio( totals.testCases.passed, totals.testCases.total() );
-                while( failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH-1 )
-                    findMax( failedRatio, failedButOkRatio, passedRatio )++;
-                while( failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH-1 )
-                    findMax( failedRatio, failedButOkRatio, passedRatio )--;
-
-                stream << Colour( Colour::Error ) << std::string( failedRatio, '=' );
-                stream << Colour( Colour::ResultExpectedFailure ) << std::string( failedButOkRatio, '=' );
-                if( totals.testCases.allPassed() )
-                    stream << Colour( Colour::ResultSuccess ) << std::string( passedRatio, '=' );
-                else
-                    stream << Colour( Colour::Success ) << std::string( passedRatio, '=' );
-            }
-            else {
-                stream << Colour( Colour::Warning ) << std::string( CATCH_CONFIG_CONSOLE_WIDTH-1, '=' );
-            }
-            stream << '\n';
-        }
-        void printSummaryDivider() {
-            stream << getLineOfChars<'-'>() << '\n';
-        }
-
-    private:
-        bool m_headerPrinted = false;
-    };
-
-    CATCH_REGISTER_REPORTER( "console", ConsoleReporter )
-
-    ConsoleReporter::~ConsoleReporter() {}
+	void XmlReporter::testRunStarting( TestRunInfo const& testInfo ) {
+		StreamingReporterBase::testRunStarting( testInfo );
+		std::string stylesheetRef = getStylesheetRef();
+		if( !stylesheetRef.empty() )
+			m_xml.writeStylesheetRef( stylesheetRef );
+		m_xml.startElement( "Catch" );
+		if( !m_config->name().empty() )
+			m_xml.writeAttribute( "name", m_config->name() );
+		if( m_config->rngSeed() != 0 )
+			m_xml.scopedElement( "Randomness" )
+			.writeAttribute( "seed", m_config->rngSeed() );
+	}
 
-} // end namespace Catch
+	void XmlReporter::testGroupStarting( GroupInfo const& groupInfo ) {
+		StreamingReporterBase::testGroupStarting( groupInfo );
+		m_xml.startElement( "Group" )
+			.writeAttribute( "name", groupInfo.name );
+	}
 
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-// end catch_reporter_console.cpp
-// start catch_reporter_junit.cpp
+	void XmlReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
+		StreamingReporterBase::testCaseStarting(testInfo);
+		m_xml.startElement( "TestCase" )
+			.writeAttribute( "name", trim( testInfo.name ) )
+			.writeAttribute( "description", testInfo.description )
+			.writeAttribute( "tags", testInfo.tagsAsString() );
 
-#include <assert.h>
+		writeSourceInfo( testInfo.lineInfo );
 
-#include <ctime>
-#include <algorithm>
+		if ( m_config->showDurations() == ShowDurations::Always )
+			m_testCaseTimer.start();
+		m_xml.ensureTagClosed();
+	}
 
-namespace Catch {
+	void XmlReporter::sectionStarting( SectionInfo const& sectionInfo ) {
+		StreamingReporterBase::sectionStarting( sectionInfo );
+		if( m_sectionDepth++ > 0 ) {
+			m_xml.startElement( "Section" )
+				.writeAttribute( "name", trim( sectionInfo.name ) );
+			writeSourceInfo( sectionInfo.lineInfo );
+			m_xml.ensureTagClosed();
+		}
+	}
 
-    namespace {
-        std::string getCurrentTimestamp() {
-            // Beware, this is not reentrant because of backward compatibility issues
-            // Also, UTC only, again because of backward compatibility (%z is C++11)
-            time_t rawtime;
-            std::time(&rawtime);
-            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
+	void XmlReporter::assertionStarting( AssertionInfo const& ) { }
+
+	bool XmlReporter::assertionEnded( AssertionStats const& assertionStats ) {
+
+		AssertionResult const& result = assertionStats.assertionResult;
+
+		bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
+
+		if( includeResults || result.getResultType() == ResultWas::Warning ) {
+			// Print any info messages in <Info> tags.
+			for( auto const& msg : assertionStats.infoMessages ) {
+				if( msg.type == ResultWas::Info && includeResults ) {
+					m_xml.scopedElement( "Info" )
+						.writeText( msg.message );
+				} else if ( msg.type == ResultWas::Warning ) {
+					m_xml.scopedElement( "Warning" )
+						.writeText( msg.message );
+				}
+			}
+		}
+
+		// Drop out if result was successful but we're not printing them.
+		if( !includeResults && result.getResultType() != ResultWas::Warning )
+			return true;
+
+		// Print the expression if there is one.
+		if( result.hasExpression() ) {
+			m_xml.startElement( "Expression" )
+				.writeAttribute( "success", result.succeeded() )
+				.writeAttribute( "type", result.getTestMacroName() );
+
+			writeSourceInfo( result.getSourceInfo() );
+
+			m_xml.scopedElement( "Original" )
+				.writeText( result.getExpression() );
+			m_xml.scopedElement( "Expanded" )
+				.writeText( result.getExpandedExpression() );
+		}
+
+		// And... Print a result applicable to each result type.
+		switch( result.getResultType() ) {
+		case ResultWas::ThrewException:
+			m_xml.startElement( "Exception" );
+			writeSourceInfo( result.getSourceInfo() );
+			m_xml.writeText( result.getMessage() );
+			m_xml.endElement();
+			break;
+		case ResultWas::FatalErrorCondition:
+			m_xml.startElement( "FatalErrorCondition" );
+			writeSourceInfo( result.getSourceInfo() );
+			m_xml.writeText( result.getMessage() );
+			m_xml.endElement();
+			break;
+		case ResultWas::Info:
+			m_xml.scopedElement( "Info" )
+				.writeText( result.getMessage() );
+			break;
+		case ResultWas::Warning:
+			// Warning will already have been written
+			break;
+		case ResultWas::ExplicitFailure:
+			m_xml.startElement( "Failure" );
+			writeSourceInfo( result.getSourceInfo() );
+			m_xml.writeText( result.getMessage() );
+			m_xml.endElement();
+			break;
+		default:
+			break;
+		}
+
+		if( result.hasExpression() )
+			m_xml.endElement();
+
+		return true;
+	}
 
-#ifdef _MSC_VER
-            std::tm timeInfo = {};
-            gmtime_s(&timeInfo, &rawtime);
-#else
-            std::tm* timeInfo;
-            timeInfo = std::gmtime(&rawtime);
-#endif
+	void XmlReporter::sectionEnded( SectionStats const& sectionStats ) {
+		StreamingReporterBase::sectionEnded( sectionStats );
+		if( --m_sectionDepth > 0 ) {
+			XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
+			e.writeAttribute( "successes", sectionStats.assertions.passed );
+			e.writeAttribute( "failures", sectionStats.assertions.failed );
+			e.writeAttribute( "expectedFailures", sectionStats.assertions.failedButOk );
 
-            char timeStamp[timeStampSize];
-            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
+			if ( m_config->showDurations() == ShowDurations::Always )
+				e.writeAttribute( "durationInSeconds", sectionStats.durationInSeconds );
 
-#ifdef _MSC_VER
-            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
-#else
-            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
-#endif
-            return std::string(timeStamp);
-        }
-
-        std::string fileNameTag(const std::vector<std::string> &tags) {
-            auto it = std::find_if(begin(tags),
-                                   end(tags),
-                                   [] (std::string const& tag) {return tag.front() == '#'; });
-            if (it != tags.end())
-                return it->substr(1);
-            return std::string();
-        }
-    }
-
-    class JunitReporter : public CumulativeReporterBase<JunitReporter> {
-    public:
-        JunitReporter( ReporterConfig const& _config )
-        :   CumulativeReporterBase( _config ),
-            xml( _config.stream() )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = true;
-        }
-
-        ~JunitReporter() override;
-
-        static std::string getDescription() {
-            return "Reports test results in an XML format that looks like Ant's junitreport target";
-        }
-
-        void noMatchingTestCases( std::string const& /*spec*/ ) override {}
-
-        void testRunStarting( TestRunInfo const& runInfo ) override {
-            CumulativeReporterBase::testRunStarting( runInfo );
-            xml.startElement( "testsuites" );
-        }
-
-        void testGroupStarting( GroupInfo const& groupInfo ) override {
-            suiteTimer.start();
-            stdOutForSuite.str("");
-            stdErrForSuite.str("");
-            unexpectedExceptions = 0;
-            CumulativeReporterBase::testGroupStarting( groupInfo );
-        }
-
-        void testCaseStarting( TestCaseInfo const& testCaseInfo ) override {
-            m_okToFail = testCaseInfo.okToFail();
-        }
-        bool assertionEnded( AssertionStats const& assertionStats ) override {
-            if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException && !m_okToFail )
-                unexpectedExceptions++;
-            return CumulativeReporterBase::assertionEnded( assertionStats );
-        }
-
-        void testCaseEnded( TestCaseStats const& testCaseStats ) override {
-            stdOutForSuite << testCaseStats.stdOut;
-            stdErrForSuite << testCaseStats.stdErr;
-            CumulativeReporterBase::testCaseEnded( testCaseStats );
-        }
-
-        void testGroupEnded( TestGroupStats const& testGroupStats ) override {
-            double suiteTime = suiteTimer.getElapsedSeconds();
-            CumulativeReporterBase::testGroupEnded( testGroupStats );
-            writeGroup( *m_testGroups.back(), suiteTime );
-        }
-
-        void testRunEndedCumulative() override {
-            xml.endElement();
-        }
-
-        void writeGroup( TestGroupNode const& groupNode, double suiteTime ) {
-            XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
-            TestGroupStats const& stats = groupNode.value;
-            xml.writeAttribute( "name", stats.groupInfo.name );
-            xml.writeAttribute( "errors", unexpectedExceptions );
-            xml.writeAttribute( "failures", stats.totals.assertions.failed-unexpectedExceptions );
-            xml.writeAttribute( "tests", stats.totals.assertions.total() );
-            xml.writeAttribute( "hostname", "tbd" ); // !TBD
-            if( m_config->showDurations() == ShowDurations::Never )
-                xml.writeAttribute( "time", "" );
-            else
-                xml.writeAttribute( "time", suiteTime );
-            xml.writeAttribute( "timestamp", getCurrentTimestamp() );
-
-            // Write test cases
-            for( auto const& child : groupNode.children )
-                writeTestCase( *child );
-
-            xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite.str() ), false );
-            xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite.str() ), false );
-        }
-
-        void writeTestCase( TestCaseNode const& testCaseNode ) {
-            TestCaseStats const& stats = testCaseNode.value;
-
-            // All test cases have exactly one section - which represents the
-            // test case itself. That section may have 0-n nested sections
-            assert( testCaseNode.children.size() == 1 );
-            SectionNode const& rootSection = *testCaseNode.children.front();
-
-            std::string className = stats.testInfo.className;
-
-            if( className.empty() ) {
-                className = fileNameTag(stats.testInfo.tags);
-                if ( className.empty() )
-                    className = "global";
-            }
-
-            if ( !m_config->name().empty() )
-                className = m_config->name() + "." + className;
-
-            writeSection( className, "", rootSection );
-        }
-
-        void writeSection(  std::string const& className,
-                            std::string const& rootName,
-                            SectionNode const& sectionNode ) {
-            std::string name = trim( sectionNode.stats.sectionInfo.name );
-            if( !rootName.empty() )
-                name = rootName + '/' + name;
-
-            if( !sectionNode.assertions.empty() ||
-                !sectionNode.stdOut.empty() ||
-                !sectionNode.stdErr.empty() ) {
-                XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
-                if( className.empty() ) {
-                    xml.writeAttribute( "classname", name );
-                    xml.writeAttribute( "name", "root" );
-                }
-                else {
-                    xml.writeAttribute( "classname", className );
-                    xml.writeAttribute( "name", name );
-                }
-                xml.writeAttribute( "time", ::Catch::Detail::stringify( sectionNode.stats.durationInSeconds ) );
-
-                writeAssertions( sectionNode );
-
-                if( !sectionNode.stdOut.empty() )
-                    xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), false );
-                if( !sectionNode.stdErr.empty() )
-                    xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), false );
-            }
-            for( auto const& childNode : sectionNode.childSections )
-                if( className.empty() )
-                    writeSection( name, "", *childNode );
-                else
-                    writeSection( className, name, *childNode );
-        }
-
-        void writeAssertions( SectionNode const& sectionNode ) {
-            for( auto const& assertion : sectionNode.assertions )
-                writeAssertion( assertion );
-        }
-        void writeAssertion( AssertionStats const& stats ) {
-            AssertionResult const& result = stats.assertionResult;
-            if( !result.isOk() ) {
-                std::string elementName;
-                switch( result.getResultType() ) {
-                    case ResultWas::ThrewException:
-                    case ResultWas::FatalErrorCondition:
-                        elementName = "error";
-                        break;
-                    case ResultWas::ExplicitFailure:
-                        elementName = "failure";
-                        break;
-                    case ResultWas::ExpressionFailed:
-                        elementName = "failure";
-                        break;
-                    case ResultWas::DidntThrowException:
-                        elementName = "failure";
-                        break;
-
-                    // We should never see these here:
-                    case ResultWas::Info:
-                    case ResultWas::Warning:
-                    case ResultWas::Ok:
-                    case ResultWas::Unknown:
-                    case ResultWas::FailureBit:
-                    case ResultWas::Exception:
-                        elementName = "internalError";
-                        break;
-                }
-
-                XmlWriter::ScopedElement e = xml.scopedElement( elementName );
-
-                xml.writeAttribute( "message", result.getExpandedExpression() );
-                xml.writeAttribute( "type", result.getTestMacroName() );
-
-                std::ostringstream oss;
-                if( !result.getMessage().empty() )
-                    oss << result.getMessage() << '\n';
-                for( auto const& msg : stats.infoMessages )
-                    if( msg.type == ResultWas::Info )
-                        oss << msg.message << '\n';
-
-                oss << "at " << result.getSourceInfo();
-                xml.writeText( oss.str(), false );
-            }
-        }
-
-        XmlWriter xml;
-        Timer suiteTimer;
-        std::ostringstream stdOutForSuite;
-        std::ostringstream stdErrForSuite;
-        unsigned int unexpectedExceptions = 0;
-        bool m_okToFail = false;
-    };
-
-    JunitReporter::~JunitReporter() {}
-    CATCH_REGISTER_REPORTER( "junit", JunitReporter )
+			m_xml.endElement();
+		}
+	}
 
-} // end namespace Catch
-// end catch_reporter_junit.cpp
-// start catch_reporter_multi.cpp
-
-namespace Catch {
-
-    void MultipleReporters::add( IStreamingReporterPtr&& reporter ) {
-        m_reporters.push_back( std::move( reporter ) );
-    }
-
-    ReporterPreferences MultipleReporters::getPreferences() const {
-        return m_reporters[0]->getPreferences();
-    }
-
-    std::set<Verbosity> MultipleReporters::getSupportedVerbosities() {
-        return std::set<Verbosity>{ };
-    }
-
-    void MultipleReporters::noMatchingTestCases( std::string const& spec ) {
-        for( auto const& reporter : m_reporters )
-            reporter->noMatchingTestCases( spec );
-    }
-
-    void MultipleReporters::benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) {
-        for( auto const& reporter : m_reporters )
-            reporter->benchmarkStarting( benchmarkInfo );
-    }
-    void MultipleReporters::benchmarkEnded( BenchmarkStats const& benchmarkStats ) {
-        for( auto const& reporter : m_reporters )
-            reporter->benchmarkEnded( benchmarkStats );
-    }
-
-    void MultipleReporters::testRunStarting( TestRunInfo const& testRunInfo ) {
-        for( auto const& reporter : m_reporters )
-            reporter->testRunStarting( testRunInfo );
-    }
-
-    void MultipleReporters::testGroupStarting( GroupInfo const& groupInfo ) {
-        for( auto const& reporter : m_reporters )
-            reporter->testGroupStarting( groupInfo );
-    }
-
-    void MultipleReporters::testCaseStarting( TestCaseInfo const& testInfo ) {
-        for( auto const& reporter : m_reporters )
-            reporter->testCaseStarting( testInfo );
-    }
-
-    void MultipleReporters::sectionStarting( SectionInfo const& sectionInfo ) {
-        for( auto const& reporter : m_reporters )
-            reporter->sectionStarting( sectionInfo );
-    }
-
-    void MultipleReporters::assertionStarting( AssertionInfo const& assertionInfo ) {
-        for( auto const& reporter : m_reporters )
-            reporter->assertionStarting( assertionInfo );
-    }
-
-    // The return value indicates if the messages buffer should be cleared:
-    bool MultipleReporters::assertionEnded( AssertionStats const& assertionStats ) {
-        bool clearBuffer = false;
-        for( auto const& reporter : m_reporters )
-            clearBuffer |= reporter->assertionEnded( assertionStats );
-        return clearBuffer;
-    }
-
-    void MultipleReporters::sectionEnded( SectionStats const& sectionStats ) {
-        for( auto const& reporter : m_reporters )
-            reporter->sectionEnded( sectionStats );
-    }
-
-    void MultipleReporters::testCaseEnded( TestCaseStats const& testCaseStats ) {
-        for( auto const& reporter : m_reporters )
-            reporter->testCaseEnded( testCaseStats );
-    }
-
-    void MultipleReporters::testGroupEnded( TestGroupStats const& testGroupStats ) {
-        for( auto const& reporter : m_reporters )
-            reporter->testGroupEnded( testGroupStats );
-    }
-
-    void MultipleReporters::testRunEnded( TestRunStats const& testRunStats ) {
-        for( auto const& reporter : m_reporters )
-            reporter->testRunEnded( testRunStats );
-    }
-
-    void MultipleReporters::skipTest( TestCaseInfo const& testInfo ) {
-        for( auto const& reporter : m_reporters )
-            reporter->skipTest( testInfo );
-    }
-
-    bool MultipleReporters::isMulti() const {
-        return true;
-    }
+	void XmlReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+		StreamingReporterBase::testCaseEnded( testCaseStats );
+		XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
+		e.writeAttribute( "success", testCaseStats.totals.assertions.allOk() );
 
-} // end namespace Catch
-// end catch_reporter_multi.cpp
-// start catch_reporter_xml.cpp
+		if ( m_config->showDurations() == ShowDurations::Always )
+			e.writeAttribute( "durationInSeconds", m_testCaseTimer.getElapsedSeconds() );
 
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
-                              // Note that 4062 (not all labels are handled
-                              // and default is missing) is enabled
-#endif
-
-namespace Catch {
-    class XmlReporter : public StreamingReporterBase<XmlReporter> {
-    public:
-        XmlReporter( ReporterConfig const& _config )
-        :   StreamingReporterBase( _config ),
-            m_xml(_config.stream())
-        {
-            m_reporterPrefs.shouldRedirectStdOut = true;
-        }
-
-        ~XmlReporter() override;
-
-        static std::string getDescription() {
-            return "Reports test results as an XML document";
-        }
-
-        virtual std::string getStylesheetRef() const {
-            return std::string();
-        }
-
-        void writeSourceInfo( SourceLineInfo const& sourceInfo ) {
-            m_xml
-                .writeAttribute( "filename", sourceInfo.file )
-                .writeAttribute( "line", sourceInfo.line );
-        }
-
-    public: // StreamingReporterBase
-
-        void noMatchingTestCases( std::string const& s ) override {
-            StreamingReporterBase::noMatchingTestCases( s );
-        }
-
-        void testRunStarting( TestRunInfo const& testInfo ) override {
-            StreamingReporterBase::testRunStarting( testInfo );
-            std::string stylesheetRef = getStylesheetRef();
-            if( !stylesheetRef.empty() )
-                m_xml.writeStylesheetRef( stylesheetRef );
-            m_xml.startElement( "Catch" );
-            if( !m_config->name().empty() )
-                m_xml.writeAttribute( "name", m_config->name() );
-        }
-
-        void testGroupStarting( GroupInfo const& groupInfo ) override {
-            StreamingReporterBase::testGroupStarting( groupInfo );
-            m_xml.startElement( "Group" )
-                .writeAttribute( "name", groupInfo.name );
-        }
-
-        void testCaseStarting( TestCaseInfo const& testInfo ) override {
-            StreamingReporterBase::testCaseStarting(testInfo);
-            m_xml.startElement( "TestCase" )
-                .writeAttribute( "name", trim( testInfo.name ) )
-                .writeAttribute( "description", testInfo.description )
-                .writeAttribute( "tags", testInfo.tagsAsString() );
-
-            writeSourceInfo( testInfo.lineInfo );
-
-            if ( m_config->showDurations() == ShowDurations::Always )
-                m_testCaseTimer.start();
-            m_xml.ensureTagClosed();
-        }
-
-        void sectionStarting( SectionInfo const& sectionInfo ) override {
-            StreamingReporterBase::sectionStarting( sectionInfo );
-            if( m_sectionDepth++ > 0 ) {
-                m_xml.startElement( "Section" )
-                    .writeAttribute( "name", trim( sectionInfo.name ) )
-                    .writeAttribute( "description", sectionInfo.description );
-                writeSourceInfo( sectionInfo.lineInfo );
-                m_xml.ensureTagClosed();
-            }
-        }
-
-        void assertionStarting( AssertionInfo const& ) override { }
-
-        bool assertionEnded( AssertionStats const& assertionStats ) override {
-
-            AssertionResult const& result = assertionStats.assertionResult;
-
-            bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
-
-            if( includeResults ) {
-                // Print any info messages in <Info> tags.
-                for( auto const& msg : assertionStats.infoMessages ) {
-                    if( msg.type == ResultWas::Info ) {
-                        m_xml.scopedElement( "Info" )
-                                .writeText( msg.message );
-                    } else if ( msg.type == ResultWas::Warning ) {
-                        m_xml.scopedElement( "Warning" )
-                                .writeText( msg.message );
-                    }
-                }
-            }
-
-            // Drop out if result was successful but we're not printing them.
-            if( !includeResults && result.getResultType() != ResultWas::Warning )
-                return true;
-
-            // Print the expression if there is one.
-            if( result.hasExpression() ) {
-                m_xml.startElement( "Expression" )
-                    .writeAttribute( "success", result.succeeded() )
-                    .writeAttribute( "type", result.getTestMacroName() );
-
-                writeSourceInfo( result.getSourceInfo() );
-
-                m_xml.scopedElement( "Original" )
-                    .writeText( result.getExpression() );
-                m_xml.scopedElement( "Expanded" )
-                    .writeText( result.getExpandedExpression() );
-            }
-
-            // And... Print a result applicable to each result type.
-            switch( result.getResultType() ) {
-                case ResultWas::ThrewException:
-                    m_xml.startElement( "Exception" );
-                    writeSourceInfo( result.getSourceInfo() );
-                    m_xml.writeText( result.getMessage() );
-                    m_xml.endElement();
-                    break;
-                case ResultWas::FatalErrorCondition:
-                    m_xml.startElement( "FatalErrorCondition" );
-                    writeSourceInfo( result.getSourceInfo() );
-                    m_xml.writeText( result.getMessage() );
-                    m_xml.endElement();
-                    break;
-                case ResultWas::Info:
-                    m_xml.scopedElement( "Info" )
-                        .writeText( result.getMessage() );
-                    break;
-                case ResultWas::Warning:
-                    // Warning will already have been written
-                    break;
-                case ResultWas::ExplicitFailure:
-                    m_xml.startElement( "Failure" );
-                    writeSourceInfo( result.getSourceInfo() );
-                    m_xml.writeText( result.getMessage() );
-                    m_xml.endElement();
-                    break;
-                default:
-                    break;
-            }
-
-            if( result.hasExpression() )
-                m_xml.endElement();
-
-            return true;
-        }
-
-        void sectionEnded( SectionStats const& sectionStats ) override {
-            StreamingReporterBase::sectionEnded( sectionStats );
-            if( --m_sectionDepth > 0 ) {
-                XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
-                e.writeAttribute( "successes", sectionStats.assertions.passed );
-                e.writeAttribute( "failures", sectionStats.assertions.failed );
-                e.writeAttribute( "expectedFailures", sectionStats.assertions.failedButOk );
-
-                if ( m_config->showDurations() == ShowDurations::Always )
-                    e.writeAttribute( "durationInSeconds", sectionStats.durationInSeconds );
-
-                m_xml.endElement();
-            }
-        }
-
-        void testCaseEnded( TestCaseStats const& testCaseStats ) override {
-            StreamingReporterBase::testCaseEnded( testCaseStats );
-            XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
-            e.writeAttribute( "success", testCaseStats.totals.assertions.allOk() );
-
-            if ( m_config->showDurations() == ShowDurations::Always )
-                e.writeAttribute( "durationInSeconds", m_testCaseTimer.getElapsedSeconds() );
-
-            if( !testCaseStats.stdOut.empty() )
-                m_xml.scopedElement( "StdOut" ).writeText( trim( testCaseStats.stdOut ), false );
-            if( !testCaseStats.stdErr.empty() )
-                m_xml.scopedElement( "StdErr" ).writeText( trim( testCaseStats.stdErr ), false );
-
-            m_xml.endElement();
-        }
-
-        void testGroupEnded( TestGroupStats const& testGroupStats ) override {
-            StreamingReporterBase::testGroupEnded( testGroupStats );
-            // TODO: Check testGroupStats.aborting and act accordingly.
-            m_xml.scopedElement( "OverallResults" )
-                .writeAttribute( "successes", testGroupStats.totals.assertions.passed )
-                .writeAttribute( "failures", testGroupStats.totals.assertions.failed )
-                .writeAttribute( "expectedFailures", testGroupStats.totals.assertions.failedButOk );
-            m_xml.endElement();
-        }
-
-        void testRunEnded( TestRunStats const& testRunStats ) override {
-            StreamingReporterBase::testRunEnded( testRunStats );
-            m_xml.scopedElement( "OverallResults" )
-                .writeAttribute( "successes", testRunStats.totals.assertions.passed )
-                .writeAttribute( "failures", testRunStats.totals.assertions.failed )
-                .writeAttribute( "expectedFailures", testRunStats.totals.assertions.failedButOk );
-            m_xml.endElement();
-        }
-
-    private:
-        Timer m_testCaseTimer;
-        XmlWriter m_xml;
-        int m_sectionDepth = 0;
-    };
-
-    XmlReporter::~XmlReporter() {}
-    CATCH_REGISTER_REPORTER( "xml", XmlReporter )
+		if( !testCaseStats.stdOut.empty() )
+			m_xml.scopedElement( "StdOut" ).writeText( trim( testCaseStats.stdOut ), false );
+		if( !testCaseStats.stdErr.empty() )
+			m_xml.scopedElement( "StdErr" ).writeText( trim( testCaseStats.stdErr ), false );
+
+		m_xml.endElement();
+	}
+
+	void XmlReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
+		StreamingReporterBase::testGroupEnded( testGroupStats );
+		// TODO: Check testGroupStats.aborting and act accordingly.
+		m_xml.scopedElement( "OverallResults" )
+			.writeAttribute( "successes", testGroupStats.totals.assertions.passed )
+			.writeAttribute( "failures", testGroupStats.totals.assertions.failed )
+			.writeAttribute( "expectedFailures", testGroupStats.totals.assertions.failedButOk );
+		m_xml.endElement();
+	}
+
+	void XmlReporter::testRunEnded( TestRunStats const& testRunStats ) {
+		StreamingReporterBase::testRunEnded( testRunStats );
+		m_xml.scopedElement( "OverallResults" )
+			.writeAttribute( "successes", testRunStats.totals.assertions.passed )
+			.writeAttribute( "failures", testRunStats.totals.assertions.failed )
+			.writeAttribute( "expectedFailures", testRunStats.totals.assertions.failedButOk );
+		m_xml.endElement();
+	}
+
+	CATCH_REGISTER_REPORTER( "xml", XmlReporter )
 
 } // end namespace Catch
 
 #if defined(_MSC_VER)
 #pragma warning(pop)
 #endif
-// end catch_reporter_xml.cpp
+  // end catch_reporter_xml.cpp
 
 namespace Catch {
-    LeakDetector leakDetector;
+	LeakDetector leakDetector;
 }
 
 #ifdef __clang__
@@ -11705,7 +13988,7 @@ namespace Catch {
 
 #ifndef __OBJC__
 
-#if defined(WIN32) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
+#if defined(CATCH_CONFIG_WCHAR) && defined(WIN32) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
 // Standard C/C++ Win32 Unicode wmain entry point
 extern "C" int wmain (int argc, wchar_t * argv[], wchar_t * []) {
 #else
@@ -11713,7 +13996,7 @@ extern "C" int wmain (int argc, wchar_t * argv[], wchar_t * []) {
 int main (int argc, char * argv[]) {
 #endif
 
-    return Catch::Session().run( argc, argv );
+	return Catch::Session().run( argc, argv );
 }
 
 #else // __OBJC__
@@ -11721,17 +14004,17 @@ int main (int argc, char * argv[]) {
 // Objective-C entry point
 int main (int argc, char * const argv[]) {
 #if !CATCH_ARC_ENABLED
-    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
+	NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
 #endif
 
-    Catch::registerTestMethods();
-    int result = Catch::Session().run( argc, (char**)argv );
+	Catch::registerTestMethods();
+	int result = Catch::Session().run( argc, (char**)argv );
 
 #if !CATCH_ARC_ENABLED
-    [pool drain];
+	[pool drain];
 #endif
 
-    return result;
+	return result;
 }
 
 #endif // __OBJC__
@@ -11739,6 +14022,8 @@ int main (int argc, char * const argv[]) {
 // end catch_default_main.hpp
 #endif
 
+#if !defined(CATCH_CONFIG_IMPL_ONLY)
+
 #ifdef CLARA_CONFIG_MAIN_NOT_DEFINED
 #  undef CLARA_CONFIG_MAIN
 #endif
@@ -11781,27 +14066,45 @@ int main (int argc, char * const argv[]) {
 
 #define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
 #define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( "CATCH_WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
-#define CATCH_CAPTURE( msg ) INTERNAL_CATCH_INFO( "CATCH_CAPTURE", #msg " := " << ::Catch::Detail::stringify(msg) )
+#define CATCH_CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CATCH_CAPTURE",__VA_ARGS__ )
 
 #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
 #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
 #define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
 #define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
 #define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
+#define CATCH_DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
 #define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
 #define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
 #define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
 
 #define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()
 
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#else
+#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#endif
+
+#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
+#define CATCH_STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__ ,      #__VA_ARGS__ );     CATCH_SUCCEED( #__VA_ARGS__ )
+#define CATCH_STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); CATCH_SUCCEED( #__VA_ARGS__ )
+#else
+#define CATCH_STATIC_REQUIRE( ... )       CATCH_REQUIRE( __VA_ARGS__ )
+#define CATCH_STATIC_REQUIRE_FALSE( ... ) CATCH_REQUIRE_FALSE( __VA_ARGS__ )
+#endif
+
 // "BDD-style" convenience wrappers
 #define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ )
 #define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
-#define CATCH_GIVEN( desc )    CATCH_SECTION( std::string( "Given: ") + desc )
-#define CATCH_WHEN( desc )     CATCH_SECTION( std::string( " When: ") + desc )
-#define CATCH_AND_WHEN( desc ) CATCH_SECTION( std::string( "  And: ") + desc )
-#define CATCH_THEN( desc )     CATCH_SECTION( std::string( " Then: ") + desc )
-#define CATCH_AND_THEN( desc ) CATCH_SECTION( std::string( "  And: ") + desc )
+#define CATCH_GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
+#define CATCH_AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
+#define CATCH_WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
+#define CATCH_AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
+#define CATCH_THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
+#define CATCH_AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
 
 // If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
 #else
@@ -11839,18 +14142,35 @@ int main (int argc, char * const argv[]) {
 
 #define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
 #define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
-#define CAPTURE( msg ) INTERNAL_CATCH_INFO( "CAPTURE", #msg " := " << ::Catch::Detail::stringify(msg) )
+#define CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CAPTURE",__VA_ARGS__ )
 
 #define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
 #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
 #define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
 #define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
 #define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
+#define DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
 #define FAIL( ... ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
 #define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
 #define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
 #define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()
 
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#else
+#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
+#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#endif
+
+#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
+#define STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__,  #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )
+#define STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" )
+#else
+#define STATIC_REQUIRE( ... )       REQUIRE( __VA_ARGS__ )
+#define STATIC_REQUIRE_FALSE( ... ) REQUIRE_FALSE( __VA_ARGS__ )
+#endif
+
 #endif
 
 #define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
@@ -11859,15 +14179,17 @@ int main (int argc, char * const argv[]) {
 #define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
 #define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
 
-#define GIVEN( desc )    SECTION( std::string("   Given: ") + desc )
-#define WHEN( desc )     SECTION( std::string("    When: ") + desc )
-#define AND_WHEN( desc ) SECTION( std::string("And when: ") + desc )
-#define THEN( desc )     SECTION( std::string("    Then: ") + desc )
-#define AND_THEN( desc ) SECTION( std::string("     And: ") + desc )
+#define GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
+#define AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
+#define WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
+#define AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
+#define THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
+#define AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
 
 using Catch::Detail::Approx;
 
-#else
+#else // CATCH_CONFIG_DISABLE
+
 //////
 // If this config identifier is defined then all CATCH macros are prefixed with CATCH_
 #ifdef CATCH_CONFIG_PREFIX_ALL
@@ -11912,21 +14234,34 @@ using Catch::Detail::Approx;
 #define CATCH_METHOD_AS_TEST_CASE( method, ... )
 #define CATCH_REGISTER_TEST_CASE( Function, ... ) (void)(0)
 #define CATCH_SECTION( ... )
+#define CATCH_DYNAMIC_SECTION( ... )
 #define CATCH_FAIL( ... ) (void)(0)
 #define CATCH_FAIL_CHECK( ... ) (void)(0)
 #define CATCH_SUCCEED( ... ) (void)(0)
 
 #define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
 
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), className )
+#else
+#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) ) )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), className ) )
+#endif
+
 // "BDD-style" convenience wrappers
 #define CATCH_SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
 #define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
 #define CATCH_GIVEN( desc )
+#define CATCH_AND_GIVEN( desc )
 #define CATCH_WHEN( desc )
 #define CATCH_AND_WHEN( desc )
 #define CATCH_THEN( desc )
 #define CATCH_AND_THEN( desc )
 
+#define CATCH_STATIC_REQUIRE( ... )       (void)(0)
+#define CATCH_STATIC_REQUIRE_FALSE( ... ) (void)(0)
+
 // If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
 #else
 
@@ -11970,11 +14305,23 @@ using Catch::Detail::Approx;
 #define METHOD_AS_TEST_CASE( method, ... )
 #define REGISTER_TEST_CASE( Function, ... ) (void)(0)
 #define SECTION( ... )
+#define DYNAMIC_SECTION( ... )
 #define FAIL( ... ) (void)(0)
 #define FAIL_CHECK( ... ) (void)(0)
 #define SUCCEED( ... ) (void)(0)
 #define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
 
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) )
+#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), className )
+#else
+#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) ) )
+#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), className ) )
+#endif
+
+#define STATIC_REQUIRE( ... )       (void)(0)
+#define STATIC_REQUIRE_FALSE( ... ) (void)(0)
+
 #endif
 
 #define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
@@ -11984,6 +14331,7 @@ using Catch::Detail::Approx;
 #define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
 
 #define GIVEN( desc )
+#define AND_GIVEN( desc )
 #define WHEN( desc )
 #define AND_WHEN( desc )
 #define THEN( desc )
@@ -11993,6 +14341,8 @@ using Catch::Detail::Approx;
 
 #endif
 
+#endif // ! CATCH_CONFIG_IMPL_ONLY
+
 // start catch_reenable_warnings.h
 
 

From 54eed441716770bac8c04161263f7228a9e22705 Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Sat, 15 Dec 2018 10:50:39 +0800
Subject: [PATCH 12/38] Added HeterEventQueue. Moved internal code to internal
 folder.

---
 include/eventpp/eventqueue.h                  |  93 ++---
 include/eventpp/hetereventdispatcher.h        | 109 ++----
 include/eventpp/hetereventqueue.h             | 361 ++++++++++++++++++
 include/eventpp/internal/eventpolicies_i.h    |   4 +-
 include/eventpp/internal/eventqueue_i.h       |  59 +++
 .../eventpp/internal/hetereventdispatcher_i.h | 133 +++++++
 .../{typeutil.h => internal/typeutil_i.h}     |   7 +-
 include/eventpp/mixins/mixinfilter.h          |  15 +-
 tests/unittest/CMakeLists.txt                 |   1 +
 tests/unittest/test_heterdispatcher_basic.cpp |  73 +++-
 tests/unittest/test_heterqueue_basic.cpp      |  44 +++
 tests/unittest/test_queue_basic.cpp           |  27 ++
 12 files changed, 766 insertions(+), 160 deletions(-)
 create mode 100644 include/eventpp/hetereventqueue.h
 create mode 100644 include/eventpp/internal/hetereventdispatcher_i.h
 rename include/eventpp/{typeutil.h => internal/typeutil_i.h} (92%)
 create mode 100644 tests/unittest/test_heterqueue_basic.cpp

diff --git a/include/eventpp/eventqueue.h b/include/eventpp/eventqueue.h
index 5f9cdb3..8012532 100644
--- a/include/eventpp/eventqueue.h
+++ b/include/eventpp/eventqueue.h
@@ -77,48 +77,7 @@ class EventQueueBase <
 		std::tuple<typename std::remove_cv<typename std::remove_reference<Args>::type>::type...> arguments;
 	};
 
-	class QueuedItem
-	{
-	public:
-		QueuedItem() : buffer(), allocated(false)
-		{
-		}
-
-		~QueuedItem()
-		{
-			if(allocated) {
-				clear();
-			}
-		}
-
-		QueuedItem(QueuedItem &&) = delete;
-		QueuedItem(const QueuedItem &) = delete;
-		QueuedItem & operator = (const QueuedItem &) = delete;
-
-		void set(QueuedEvent_ && item) {
-			assert(! allocated);
-
-			new (buffer.data()) QueuedEvent_(std::move(item));
-			allocated = true;
-		}
-
-		QueuedEvent_ & get() {
-			assert(allocated);
-
-			return *reinterpret_cast<QueuedEvent_ *>(buffer.data());
-		}
-
-		void clear() {
-			assert(allocated);
-
-			get().~QueuedEvent_();
-			allocated = false;
-		}
-
-	private:
-		std::array<char, sizeof(QueuedEvent_)> buffer;
-		bool allocated;
-	};
+	using BufferedItemList = std::list<BufferedItem<sizeof(QueuedEvent_)> >;
 
 public:
 	using QueuedEvent = QueuedEvent_;
@@ -188,7 +147,7 @@ class EventQueueBase <
 	{
 		static_assert(super::ArgumentPassingMode::canIncludeEventType, "Enqueuing arguments count doesn't match required (Event type should be included).");
 
-		using GetEvent = typename SelectGetEvent<Policies_, EventType_, HasFunctionGetEvent<Policies_, Args...>::value>::Type;
+		using GetEvent = typename SelectGetEvent<Policies_, EventType_, HasFunctionGetEvent<Policies_, A...>::value>::Type;
 
 		doEnqueue(QueuedEvent{
 			GetEvent::getEvent(args...),
@@ -205,7 +164,7 @@ class EventQueueBase <
 	{
 		static_assert(super::ArgumentPassingMode::canExcludeEventType, "Enqueuing arguments count doesn't match required (Event type should NOT be included).");
 
-		using GetEvent = typename SelectGetEvent<Policies_, EventType_, HasFunctionGetEvent<Policies_, T &&, Args...>::value>::Type;
+		using GetEvent = typename SelectGetEvent<Policies_, EventType_, HasFunctionGetEvent<Policies_, T &&, A...>::value>::Type;
 
 		doEnqueue(QueuedEvent{
 			GetEvent::getEvent(std::forward<T>(first), args...),
@@ -225,7 +184,7 @@ class EventQueueBase <
 	void clearEvents()
 	{
 		if(! queueList.empty()) {
-			std::list<QueuedItem> tempList;
+			BufferedItemList tempList;
 
 			{
 				std::lock_guard<Mutex> queueListLock(queueListMutex);
@@ -246,7 +205,7 @@ class EventQueueBase <
 	bool process()
 	{
 		if(! queueList.empty()) {
-			std::list<QueuedItem> tempList;
+			BufferedItemList tempList;
 
 			// Use a counter to tell the queue list is not empty during processing
 			// even though queueList is swapped to empty.
@@ -260,8 +219,8 @@ class EventQueueBase <
 			if(! tempList.empty()) {
 				for(auto & item : tempList) {
 					doDispatchQueuedEvent(
-						item.get(),
-						typename internal_::MakeIndexSequence<sizeof...(Args)>::Type()
+						item.template get<QueuedEvent_>(),
+						typename MakeIndexSequence<sizeof...(Args)>::Type()
 					);
 					item.clear();
 				}
@@ -279,7 +238,7 @@ class EventQueueBase <
 	bool processOne()
 	{
 		if(! queueList.empty()) {
-			std::list<QueuedItem> tempList;
+			BufferedItemList tempList;
 
 			// Use a counter to tell the queue list is not empty during processing
 			// even though queueList is swapped to empty.
@@ -295,8 +254,8 @@ class EventQueueBase <
 			if(! tempList.empty()) {
 				auto & item = tempList.front();
 				doDispatchQueuedEvent(
-					item.get(),
-					typename internal_::MakeIndexSequence<sizeof...(Args)>::Type()
+					item.template get<QueuedEvent_>(),
+					typename MakeIndexSequence<sizeof...(Args)>::Type()
 				);
 				item.clear();
 
@@ -314,8 +273,8 @@ class EventQueueBase <
 	bool processIf(F && func)
 	{
 		if(! queueList.empty()) {
-			std::list<QueuedItem> tempList;
-			std::list<QueuedItem> idleList;
+			BufferedItemList tempList;
+			BufferedItemList idleList;
 
 			// Use a counter to tell the queue list is not empty during processing
 			// even though queueList is swapped to empty.
@@ -330,12 +289,12 @@ class EventQueueBase <
 				for(auto it = tempList.begin(); it != tempList.end(); ++it) {
 					if(doInvokeFuncWithQueuedEvent(
 							func,
-							it->get(),
-							typename internal_::MakeIndexSequence<sizeof...(Args)>::Type())
+							it->template get<QueuedEvent_>(),
+							typename MakeIndexSequence<sizeof...(Args)>::Type())
 						) {
 						doDispatchQueuedEvent(
-							it->get(),
-							typename internal_::MakeIndexSequence<sizeof...(Args)>::Type()
+							it->template get<QueuedEvent_>(),
+							typename MakeIndexSequence<sizeof...(Args)>::Type()
 						);
 						it->clear();
 						
@@ -387,7 +346,7 @@ class EventQueueBase <
 	{
 		doDispatchQueuedEvent(
 			queuedEvent,
-			typename internal_::MakeIndexSequence<sizeof...(Args)>::Type()
+			typename MakeIndexSequence<sizeof...(Args)>::Type()
 		);
 	}
 
@@ -397,7 +356,7 @@ class EventQueueBase <
 			std::lock_guard<Mutex> queueListLock(queueListMutex);
 			
 			if(! queueList.empty()) {
-				*queuedEvent = queueList.front().get();
+				*queuedEvent = queueList.front().template get<QueuedEvent_>();
 				return true;
 			}
 		}
@@ -408,7 +367,7 @@ class EventQueueBase <
 	bool takeEvent(QueuedEvent * queuedEvent)
 	{
 		if(! queueList.empty()) {
-			std::list<QueuedItem> tempList;
+			BufferedItemList tempList;
 
 			{
 				std::lock_guard<Mutex> queueListLock(queueListMutex);
@@ -419,7 +378,7 @@ class EventQueueBase <
 			}
 
 			if(! tempList.empty()) {
-				*queuedEvent = std::move(tempList.front().get());
+				*queuedEvent = std::move(tempList.front().template get<QueuedEvent_>());
 				tempList.front().clear();
 
 				std::lock_guard<Mutex> queueListLock(freeListMutex);
@@ -433,11 +392,13 @@ class EventQueueBase <
 	}
 
 protected:
-	bool doCanProcess() const {
+	bool doCanProcess() const
+	{
 		return ! empty() && doCanNotifyQueueAvailable();
 	}
 
-	bool doCanNotifyQueueAvailable() const {
+	bool doCanNotifyQueueAvailable() const
+	{
 		return queueNotifyCounter.load(std::memory_order_acquire) == 0;
 	}
 
@@ -461,7 +422,7 @@ class EventQueueBase <
 
 	void doEnqueue(QueuedEvent && item)
 	{
-		std::list<QueuedItem> tempList;
+		BufferedItemList tempList;
 		if(! freeList.empty()) {
 			{
 				std::lock_guard<Mutex> queueListLock(freeListMutex);
@@ -487,9 +448,9 @@ class EventQueueBase <
 	typename Threading::template Atomic<int> queueEmptyCounter;
 	typename Threading::template Atomic<int> queueNotifyCounter;
 	mutable Mutex queueListMutex;
-	std::list<QueuedItem> queueList;
+	BufferedItemList queueList;
 	Mutex freeListMutex;
-	std::list<QueuedItem> freeList;
+	BufferedItemList freeList;
 };
 
 } //namespace internal_
diff --git a/include/eventpp/hetereventdispatcher.h b/include/eventpp/hetereventdispatcher.h
index 056c047..5b55d7a 100644
--- a/include/eventpp/hetereventdispatcher.h
+++ b/include/eventpp/hetereventdispatcher.h
@@ -15,6 +15,7 @@
 #define HETEREVENTDISPATCHER_H_127766658555
 
 #include "eventdispatcher.h"
+#include "internal/hetereventdispatcher_i.h"
 
 #include <array>
 #include <string>
@@ -28,62 +29,12 @@
 
 namespace eventpp {
 
-namespace internal_ {
-
-template <typename ...Args>
-struct CanConvert
-{
-	enum { value = false };
-};
-
-template <typename From, typename ...FromArgs, typename To, typename ...ToArgs>
-struct CanConvert <std::tuple<From, FromArgs...>, std::tuple<To, ToArgs...> >
-{
-	enum { value = std::is_convertible<From, To>::value && CanConvert<std::tuple<FromArgs...>, std::tuple<ToArgs...> >::value };
-};
-
-template <>
-struct CanConvert <std::tuple<>, std::tuple<> >
-{
-	enum { value = true };
-};
-
-template <int N, typename PrototypeList_, typename Callable>
-struct FindCallablePrototypeHelper
-{
-	using Prototype = void;
-	enum {index = -1 };
-};
-
-template <int N, typename RT, typename ...Args, typename ...Others, typename Callable>
-struct FindCallablePrototypeHelper <N, std::tuple<RT (Args...), Others...>, Callable>
-{
-	using Prototype = typename std::conditional<
-		CanInvoke<Callable, Args...>::value,
-		RT (Args...),
-		typename FindCallablePrototypeHelper<N + 1, std::tuple<Others...>, Callable>::Prototype
-	>::type;
-	enum {
-		index = CanInvoke<Callable, Args...>::value
-			? N
-			: FindCallablePrototypeHelper<N + 1, std::tuple<Others...>, Callable>::index
-	};
-};
-
-template <typename PrototypeList_, typename Callable>
-struct FindCallablePrototype : public FindCallablePrototypeHelper <0, PrototypeList_, Callable>
-{
-};
-
-} //namespace internal_
-
-
 namespace internal_ {
 
 template <
-	typename EventType,
+	typename EventType_,
 	typename PrototypeList_,
-	typename PoliciesType,
+	typename Policies_,
 	typename MixinRoot_
 >
 class HeterEventDispatcherBase
@@ -102,18 +53,18 @@ class HeterEventDispatcherBase
 	class HomoDispatcherTypeBase
 	{
 	public:
-		virtual bool doRemoveListener(const EventType & event, const Handle_ & handle) = 0;
+		virtual bool doRemoveListener(const EventType_ & event, const Handle_ & handle) = 0;
 		virtual std::shared_ptr<HomoDispatcherTypeBase> doClone() = 0;
 	};
 
 	template <typename T>
-	class HomoDispatcherType : public EventDispatcher<EventType, T, PoliciesType>, public HomoDispatcherTypeBase
+	class HomoDispatcherType : public EventDispatcher<EventType_, T, Policies_>, public HomoDispatcherTypeBase
 	{
 	private:
-		using super = EventDispatcher<EventType, T, PoliciesType>;
+		using super = EventDispatcher<EventType_, T, Policies_>;
 
 	public:
-		virtual bool doRemoveListener(const EventType & event, const Handle_ & handle) override {
+		virtual bool doRemoveListener(const EventType_ & event, const Handle_ & handle) override {
 			auto sp = handle.homoHandle.lock();
 			if(! sp) {
 				return false;
@@ -128,13 +79,13 @@ class HeterEventDispatcherBase
 
 protected:
 	using ThisType = HeterEventDispatcherBase<
-		EventType,
+		EventType_,
 		PrototypeList_,
-		PoliciesType,
+		Policies_,
 		MixinRoot_
 	>;
 
-	using Policies = PoliciesType;
+	using Policies = Policies_;
 	using Threading = typename SelectThreading<Policies, HasTypeThreading<Policies>::value>::Type;
 
 	// Disable ArgumentPassingMode explicitly
@@ -144,7 +95,7 @@ class HeterEventDispatcherBase
 
 public:
 	using Handle = Handle_;
-	using Event = EventType;
+	using Event = EventType_;
 	using Mutex = typename Threading::Mutex;
 
 public:
@@ -196,10 +147,12 @@ class HeterEventDispatcherBase
 	template <typename C>
 	Handle appendListener(const Event & event, const C & callback)
 	{
-		using FindResult = FindCallablePrototype<PrototypeList_, C>;
-		auto dispatcher = doFindDispatcher<FindResult>();
+		using PrototypeInfo = FindPrototypeByCallable<PrototypeList_, C>;
+		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
+
+		auto dispatcher = doFindDispatcher<PrototypeInfo>();
 		return Handle {
-			FindResult::index,
+			PrototypeInfo::index,
 			dispatcher->appendListener(event, callback)
 		};
 	}
@@ -207,10 +160,12 @@ class HeterEventDispatcherBase
 	template <typename C>
 	Handle prependListener(const Event & event, const C & callback)
 	{
-		using FindResult = FindCallablePrototype<PrototypeList_, C>;
-		auto dispatcher = doFindDispatcher<FindResult>();
+		using PrototypeInfo = FindPrototypeByCallable<PrototypeList_, C>;
+		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
+
+		auto dispatcher = doFindDispatcher<PrototypeInfo>();
 		return Handle {
-			FindResult::index,
+			PrototypeInfo::index,
 			dispatcher->prependListener(event, callback)
 		};
 	}
@@ -228,26 +183,28 @@ class HeterEventDispatcherBase
 	template <typename T, typename ...Args>
 	void dispatch(T && first, Args ...args) const
 	{
-		using FindResult = FindCallablePrototype<PrototypeList_, void(Args...)>;
-		auto dispatcher = doFindDispatcher<FindResult>();
+		using PrototypeInfo = FindPrototypeByArgs<PrototypeList_, Args...>;
+		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
+
+		auto dispatcher = doFindDispatcher<PrototypeInfo>();
 		dispatcher->dispatch(std::forward<T>(first), std::forward<Args>(args)...);
 	}
 
-private:
-	template <typename FindResult>
+protected:
+	template <typename PrototypeInfo>
 	auto doFindDispatcher() const
-		-> HomoDispatcherType<typename FindResult::Prototype> *
+		-> HomoDispatcherType<typename PrototypeInfo::Prototype> *
 	{
-		static_assert(FindResult::index >= 0, "Can't find invoker for the given argument types.");
+		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
 
-		if(! dispatcherList[FindResult::index]) {
-			if(! dispatcherList[FindResult::index]) {
+		if(! dispatcherList[PrototypeInfo::index]) {
+			if(! dispatcherList[PrototypeInfo::index]) {
 				std::lock_guard<Mutex> lockGuard(dispatcherListMutex);
-				dispatcherList[FindResult::index] = std::make_shared<HomoDispatcherType<typename FindResult::Prototype> >();
+				dispatcherList[PrototypeInfo::index] = std::make_shared<HomoDispatcherType<typename PrototypeInfo::Prototype> >();
 			}
 		}
 
-		return static_cast<HomoDispatcherType<typename FindResult::Prototype> *>(dispatcherList[FindResult::index].get());
+		return static_cast<HomoDispatcherType<typename PrototypeInfo::Prototype> *>(dispatcherList[PrototypeInfo::index].get());
 	}
 
 private:
diff --git a/include/eventpp/hetereventqueue.h b/include/eventpp/hetereventqueue.h
new file mode 100644
index 0000000..3264874
--- /dev/null
+++ b/include/eventpp/hetereventqueue.h
@@ -0,0 +1,361 @@
+// eventpp library
+// Copyright (C) 2018 Wang Qi (wqking)
+// Github: https://github.com/wqking/eventpp
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//   http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef HETEREVENTQUEUE_H_210892536510
+#define HETEREVENTQUEUE_H_210892536510
+
+#include "hetereventdispatcher.h"
+
+// temp, should move the internal code in eventqueue to separated file
+#include "eventqueue.h"
+
+namespace eventpp {
+
+namespace internal_ {
+
+template <
+	typename EventType_,
+	typename PrototypeList_,
+	typename Policies_
+>
+class HeterEventQueueBase : public HeterEventDispatcherBase<
+		EventType_,
+		PrototypeList_,
+		Policies_,
+		HeterEventQueueBase <
+			EventType_,
+			PrototypeList_,
+			Policies_
+		>
+	>
+{
+private:
+	using super = HeterEventDispatcherBase<
+		EventType_,
+		PrototypeList_,
+		Policies_,
+		HeterEventQueueBase <
+			EventType_,
+			PrototypeList_,
+			Policies_
+		>
+	>;
+
+	using Policies = typename super::Policies;
+	using Threading = typename super::Threading;
+	using ConditionVariable = typename Threading::ConditionVariable;
+
+	struct QueuedItemBase;
+	using ItemDispatcher = void (*)(const HeterEventQueueBase *, const QueuedItemBase &);
+
+	struct QueuedItemBase
+	{
+		QueuedItemBase(const EventType_ & event, const ItemDispatcher dispatcher)
+			: event(event), dispatcher(dispatcher)
+		{
+		}
+
+		EventType_ event;
+		ItemDispatcher dispatcher;
+	};
+
+	template <typename T>
+	struct QueuedItem : public QueuedItemBase
+	{
+		QueuedItem(const EventType_ & event, const ItemDispatcher dispatcher, T && arguments)
+			: QueuedItemBase(event, dispatcher), arguments(std::move(arguments))
+		{
+		}
+
+		T arguments;
+	};
+
+	template <typename ...Args>
+	using QueuedItemSizer = QueuedItem<std::tuple<typename std::remove_cv<typename std::remove_reference<Args>::type>::type...> >;
+
+	using BufferedQueuedItem = BufferedItem<GetCallablePrototypeMaxSize<PrototypeList_, QueuedItemSizer>::value>;
+
+	using BufferedItemList = std::list<BufferedQueuedItem>;
+
+public:
+	using super::Event;
+	using super::Handle;
+	using Mutex = typename super::Mutex;
+
+public:
+	template <typename T, typename ...Args>
+	void enqueue(T && first, Args ...args)
+	{
+		using GetEvent = typename SelectGetEvent<Policies_, EventType_, HasFunctionGetEvent<Policies_, T &&, Args...>::value>::Type;
+		using PrototypeInfo = FindPrototypeByArgs<PrototypeList_, Args...>;
+		using QueuedItemType = QueuedItem<typename PrototypeInfo::ArgsTuple>;
+
+		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
+		static_assert(std::tuple_size<typename PrototypeInfo::ArgsTuple>::value == sizeof...(Args), "Arguments count mismatch.");
+
+		doEnqueue(QueuedItemType(
+			GetEvent::getEvent(std::forward<T>(first), args...),
+			&HeterEventQueueBase::doDispatchItem<typename PrototypeInfo::ArgsTuple>,
+			typename PrototypeInfo::ArgsTuple(std::forward<Args>(args)...)
+		));
+
+		if(doCanProcess()) {
+			queueListConditionVariable.notify_one();
+		}
+	}
+
+	bool empty() const
+	{
+		return queueList.empty() && (queueEmptyCounter.load(std::memory_order_acquire) == 0);
+	}
+
+	bool process()
+	{
+		if(! queueList.empty()) {
+			BufferedItemList tempList;
+
+			// Use a counter to tell the queue list is not empty during processing
+			// even though queueList is swapped to empty.
+			CounterGuard<decltype(queueEmptyCounter)> counterGuard(queueEmptyCounter);
+
+			{
+				std::lock_guard<Mutex> queueListLock(queueListMutex);
+				std::swap(queueList, tempList);
+			}
+
+			if(! tempList.empty()) {
+				for(auto & item : tempList) {
+					doDispatchQueuedEvent(item.template get<QueuedItemBase>());
+					item.clear();
+				}
+
+				std::lock_guard<Mutex> queueListLock(freeListMutex);
+				freeList.splice(freeList.end(), tempList);
+
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	bool processOne()
+	{
+		if(! queueList.empty()) {
+			BufferedItemList tempList;
+
+			// Use a counter to tell the queue list is not empty during processing
+			// even though queueList is swapped to empty.
+			CounterGuard<decltype(queueEmptyCounter)> counterGuard(queueEmptyCounter);
+
+			{
+				std::lock_guard<Mutex> queueListLock(queueListMutex);
+				if(! queueList.empty()) {
+					tempList.splice(tempList.end(), queueList, queueList.begin());
+				}
+			}
+
+			if(! tempList.empty()) {
+				auto & item = tempList.front();
+				doDispatchQueuedEvent(item.template get<QueuedItemBase>());
+				item.clear();
+
+				std::lock_guard<Mutex> queueListLock(freeListMutex);
+				freeList.splice(freeList.end(), tempList);
+
+				return true;
+			}
+		}
+
+		return false;
+	}
+/*
+	template <typename F>
+	bool processIf(F && func)
+	{
+		if(! queueList.empty()) {
+			BufferedItemList tempList;
+			BufferedItemList idleList;
+
+			// Use a counter to tell the queue list is not empty during processing
+			// even though queueList is swapped to empty.
+			CounterGuard<decltype(queueEmptyCounter)> counterGuard(queueEmptyCounter);
+
+			{
+				std::lock_guard<Mutex> queueListLock(queueListMutex);
+				std::swap(queueList, tempList);
+			}
+
+			if(! tempList.empty()) {
+				for(auto it = tempList.begin(); it != tempList.end(); ++it) {
+					if(doInvokeFuncWithQueuedEvent(
+						func,
+						it->template get<QueuedItemBase>(),
+						typename MakeIndexSequence<sizeof...(Args)>::Type())
+						) {
+						doDispatchQueuedEvent(item.template get<QueuedItemBase>());
+						it->clear();
+
+						auto tempIt = it;
+						--it;
+						idleList.splice(idleList.end(), tempList, tempIt);
+					}
+				}
+
+				if (! tempList.empty()) {
+					std::lock_guard<Mutex> queueListLock(queueListMutex);
+					queueList.splice(queueList.begin(), tempList);
+				}
+
+				if(! idleList.empty()) {
+					std::lock_guard<Mutex> queueListLock(freeListMutex);
+					freeList.splice(freeList.end(), idleList);
+
+					return true;
+				}
+			}
+		}
+
+		return false;
+	}
+*/
+
+	void wait() const
+	{
+		std::unique_lock<Mutex> queueListLock(queueListMutex);
+		queueListConditionVariable.wait(queueListLock, [this]() -> bool {
+			return doCanProcess();
+		});
+	}
+
+	template <class Rep, class Period>
+	bool waitFor(const std::chrono::duration<Rep, Period> & duration) const
+	{
+		std::unique_lock<Mutex> queueListLock(queueListMutex);
+		return queueListConditionVariable.wait_for(queueListLock, duration, [this]() -> bool {
+			return doCanProcess();
+		});
+	}
+
+	using super::dispatch;
+
+private:
+	bool doCanProcess() const
+	{
+		return ! empty() && doCanNotifyQueueAvailable();
+	}
+
+	bool doCanNotifyQueueAvailable() const
+	{
+		return queueNotifyCounter.load(std::memory_order_acquire) == 0;
+	}
+
+	void doDispatchQueuedEvent(const QueuedItemBase & item)
+	{
+		item.dispatcher(this, item);
+	}
+
+	template <typename ArgsTuple>
+	static void doDispatchItem(const HeterEventQueueBase * self, const QueuedItemBase & baseItem)
+	{
+		const QueuedItem<ArgsTuple> & item = static_cast<const QueuedItem<ArgsTuple> &>(baseItem);
+		self->doDispatchQueuedItem(
+			item,
+			typename MakeIndexSequence<std::tuple_size<ArgsTuple>::value>::Type()
+		);
+	}
+
+	template <typename T, size_t ...Indexes>
+	void doDispatchQueuedItem(T && item, IndexSequence<Indexes...>) const
+	{
+		this->dispatch(item.event, std::get<Indexes>(item.arguments)...);
+	}
+
+	/*
+	template <typename F, typename T, size_t ...Indexes>
+	bool doInvokeFuncWithQueuedEvent(F && func, T && item, IndexSequence<Indexes...>) const
+	{
+		return doInvokeFuncWithQueuedEventHelper(std::forward<F>(func), item.event, std::get<Indexes>(item.arguments)...);
+	}
+
+	template <typename F, typename ...Args>
+	bool doInvokeFuncWithQueuedEventHelper(F && func, const typename super::Event & e, Args ...args) const
+	{
+		return func(std::forward<Args>(args)...);
+	}
+	*/
+
+	template <typename T>
+	void doEnqueue(T && item)
+	{
+		BufferedItemList tempList;
+		if(! freeList.empty()) {
+			{
+				std::lock_guard<Mutex> queueListLock(freeListMutex);
+				if(! freeList.empty()) {
+					tempList.splice(tempList.end(), freeList, freeList.begin());
+				}
+			}
+		}
+
+		if(tempList.empty()) {
+			tempList.emplace_back();
+		}
+
+		auto it = tempList.begin();
+		it->set(std::move(item));
+
+		std::lock_guard<Mutex> queueListLock(queueListMutex);
+		queueList.splice(queueList.end(), tempList, it);
+	}
+
+private:
+	mutable ConditionVariable queueListConditionVariable;
+	typename Threading::template Atomic<int> queueEmptyCounter;
+	typename Threading::template Atomic<int> queueNotifyCounter;
+	mutable Mutex queueListMutex;
+	BufferedItemList queueList;
+	Mutex freeListMutex;
+	BufferedItemList freeList;
+};
+
+
+
+} //namespace internal_
+
+template <
+	typename Event_,
+	typename PrototypeList_,
+	typename Policies_ = DefaultPolicies
+>
+class HeterEventQueue : public internal_::InheritMixins<
+		internal_::HeterEventQueueBase<Event_, PrototypeList_, Policies_>,
+		typename internal_::SelectMixins<Policies_, internal_::HasTypeMixins<Policies_>::value >::Type
+	>::Type, public TagEventDispatcher
+{
+private:
+	using super = typename internal_::InheritMixins<
+		internal_::HeterEventQueueBase<Event_, PrototypeList_, Policies_>,
+		typename internal_::SelectMixins<Policies_, internal_::HasTypeMixins<Policies_>::value >::Type
+	>::Type;
+
+public:
+	using super::super;
+};
+
+
+} //namespace eventpp
+
+
+#endif
+
diff --git a/include/eventpp/internal/eventpolicies_i.h b/include/eventpp/internal/eventpolicies_i.h
index 9f5e6af..8fb770c 100644
--- a/include/eventpp/internal/eventpolicies_i.h
+++ b/include/eventpp/internal/eventpolicies_i.h
@@ -176,7 +176,7 @@ struct HasFunctionMixinBeforeDispatch
 	enum { value = !! decltype(test<T>(0))() };
 };
 
-template <typename F, typename ...A>
+template <typename F, typename ...Args>
 struct CanInvoke
 {
 	template <typename U, typename ...X>
@@ -186,7 +186,7 @@ struct CanInvoke
 	static auto invoke(...) -> std::false_type;
 
 	enum {
-		value = !! decltype(invoke<F, A...>(0))()
+		value = !! decltype(invoke<F, Args...>(0))()
 	};
 };
 
diff --git a/include/eventpp/internal/eventqueue_i.h b/include/eventpp/internal/eventqueue_i.h
index 2be0346..89dbec7 100644
--- a/include/eventpp/internal/eventqueue_i.h
+++ b/include/eventpp/internal/eventqueue_i.h
@@ -1,6 +1,9 @@
 #ifndef EVENTQUEUE_I_H
 #define EVENTQUEUE_I_H
 
+#include <array>
+#include <cassert>
+
 namespace eventpp {
 
 namespace internal_ {
@@ -35,6 +38,62 @@ struct CounterGuard
 	T & value;
 };
 
+using DtorFunc = void (*)(void *);
+
+template <typename T>
+void commonDtor(void * instance)
+{
+	reinterpret_cast<T *>(instance)->~T();
+}
+
+template <size_t Size>
+class BufferedItem
+{
+public:
+	explicit BufferedItem() : buffer(), dtor(nullptr)
+	{
+	}
+
+	~BufferedItem()
+	{
+		if(dtor != nullptr) {
+			clear();
+		}
+	}
+
+	BufferedItem(BufferedItem &&) = delete;
+	BufferedItem(const BufferedItem &) = delete;
+	BufferedItem & operator = (const BufferedItem &) = delete;
+
+	template <typename U>
+	void set(U && item) {
+		static_assert(sizeof(U) <= Size, "Item is too large to fit in BufferedItem");
+		assert(dtor == nullptr);
+
+		new (buffer.data()) U(std::forward<U>(item));
+		dtor = &commonDtor<U>;
+	}
+
+	template <typename U>
+	U & get() {
+		assert(dtor != nullptr);
+
+		return *reinterpret_cast<U *>(buffer.data());
+	}
+
+	void clear() {
+		assert(dtor != nullptr);
+
+		dtor(buffer.data());
+		dtor = nullptr;
+	}
+
+private:
+	std::array<char, Size> buffer;
+	DtorFunc dtor;
+};
+
+
 } //namespace internal_
 
 } //namespace eventpp
diff --git a/include/eventpp/internal/hetereventdispatcher_i.h b/include/eventpp/internal/hetereventdispatcher_i.h
new file mode 100644
index 0000000..87246c0
--- /dev/null
+++ b/include/eventpp/internal/hetereventdispatcher_i.h
@@ -0,0 +1,133 @@
+// eventpp library
+// Copyright (C) 2018 Wang Qi (wqking)
+// Github: https://github.com/wqking/eventpp
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//   http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef HETEREVENTDISPATCHER_I_H
+#define HETEREVENTDISPATCHER_I_H
+
+namespace eventpp {
+
+namespace internal_ {
+
+template <size_t N, typename PrototypeList_, typename Callable>
+struct FindPrototypeByCallableHelper;
+
+template <size_t N, typename RT, typename ...Args, typename ...Others, typename Callable>
+struct FindPrototypeByCallableHelper <N, std::tuple<RT (Args...), Others...>, Callable>
+{
+	enum { canInvoke = CanInvoke<Callable, Args...>::value };
+
+	using Prototype = typename std::conditional<
+		canInvoke,
+		RT (Args...),
+		typename FindPrototypeByCallableHelper<N + 1, std::tuple<Others...>, Callable>::Prototype
+	>::type;
+
+	using ArgsTuple = typename std::conditional<
+		canInvoke,
+		std::tuple<typename std::remove_cv<typename std::remove_reference<Args>::type>::type...>,
+		typename FindPrototypeByCallableHelper<N + 1, std::tuple<Others...>, Callable>::ArgsTuple
+	>::type;
+
+	enum {
+		index = canInvoke
+			? N
+			: FindPrototypeByCallableHelper<N + 1, std::tuple<Others...>, Callable>::index
+	};
+};
+
+template <size_t N, typename Callable>
+struct FindPrototypeByCallableHelper <N, std::tuple<>, Callable>
+{
+	using Prototype = void;
+
+	using ArgsTuple = std::tuple<>;
+
+	enum {
+		index = -1
+	};
+};
+
+template <typename PrototypeList_, typename Callable>
+struct FindPrototypeByCallable : public FindPrototypeByCallableHelper <0, PrototypeList_, Callable>
+{
+};
+
+template <size_t N, typename PrototypeList_, typename ...InArgs>
+struct FindPrototypeByArgsHelper;
+
+template <size_t N, typename RT, typename ...Args, typename ...Others, typename ...InArgs>
+struct FindPrototypeByArgsHelper <N, std::tuple<RT (Args...), Others...>, InArgs...>
+{
+	enum { canInvoke = CanInvoke<RT (Args...), InArgs...>::value };
+
+	using Prototype = typename std::conditional<
+		canInvoke,
+		RT (Args...),
+		typename FindPrototypeByArgsHelper<N + 1, std::tuple<Others...>, InArgs...>::Prototype
+	>::type;
+
+	using ArgsTuple = typename std::conditional<
+		canInvoke,
+		std::tuple<typename std::remove_cv<typename std::remove_reference<Args>::type>::type...>,
+		typename FindPrototypeByArgsHelper<N + 1, std::tuple<Others...>, InArgs...>::ArgsTuple
+	>::type;
+
+	enum {
+		index = canInvoke
+		? N
+		: FindPrototypeByArgsHelper<N + 1, std::tuple<Others...>, InArgs...>::index
+	};
+};
+
+template <size_t N, typename ...InArgs>
+struct FindPrototypeByArgsHelper <N, std::tuple<>, InArgs...>
+{
+	using Prototype = void;
+
+	using ArgsTuple = std::tuple<>;
+
+	enum {
+		index = -1
+	};
+};
+
+template <typename PrototypeList_, typename ...InArgs>
+struct FindPrototypeByArgs : public FindPrototypeByArgsHelper <0, PrototypeList_, InArgs...>
+{
+};
+
+template <typename PrototypeList_, template <typename ...> class Record>
+struct GetCallablePrototypeMaxSize;
+
+template <typename RT, typename ...Args, typename ...Others, template <typename ...> class Record>
+struct GetCallablePrototypeMaxSize <std::tuple<RT (Args...), Others...>, Record>
+{
+	enum {
+		my = sizeof(Record<Args...>),
+		other = GetCallablePrototypeMaxSize<std::tuple<Others...>, Record>::value
+	};
+	enum { value = (my > other ? (size_t)my : (size_t)other) };
+};
+
+template <template <typename ...> class Record>
+struct GetCallablePrototypeMaxSize <std::tuple<>, Record>
+{
+	enum { value = 1 }; // set minimum size to 1 instead of 0
+};
+
+} //namespace internal_
+
+
+} //namespace eventpp
+
+#endif
diff --git a/include/eventpp/typeutil.h b/include/eventpp/internal/typeutil_i.h
similarity index 92%
rename from include/eventpp/typeutil.h
rename to include/eventpp/internal/typeutil_i.h
index 2a1fb6f..9187642 100644
--- a/include/eventpp/typeutil.h
+++ b/include/eventpp/internal/typeutil_i.h
@@ -11,11 +11,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef TYPEUTIL_H_879959971810
-#define TYPEUTIL_H_879959971810
+#ifndef TYPEUTIL_I_H
+#define TYPEUTIL_I_H
 
 namespace eventpp {
 
+namespace internal_ {
+
 template <typename F, template <typename> class T>
 struct TransformArguments;
 
@@ -34,6 +36,7 @@ struct ReplaceReturnType <RT (Args...), Replacement>
 	using Type = Replacement (Args...);
 };
 
+} //namespace internal_
 
 } //namespace eventpp
 
diff --git a/include/eventpp/mixins/mixinfilter.h b/include/eventpp/mixins/mixinfilter.h
index 9185d9e..98cbb06 100644
--- a/include/eventpp/mixins/mixinfilter.h
+++ b/include/eventpp/mixins/mixinfilter.h
@@ -15,7 +15,7 @@
 #define MIXINFILTER_H_713231680355
 
 #include "../callbacklist.h"
-#include "../typeutil.h"
+#include "../internal/typeutil_i.h"
 
 #include <functional>
 #include <type_traits>
@@ -28,8 +28,8 @@ class MixinFilter : public Base
 private:
 	using super = Base;
 
-	using BoolReferencePrototype = typename ReplaceReturnType<
-		typename TransformArguments<
+	using BoolReferencePrototype = typename internal_::ReplaceReturnType<
+		typename internal_::TransformArguments<
 			typename super::Prototype,
 			std::add_lvalue_reference
 		>::Type,
@@ -56,11 +56,10 @@ class MixinFilter : public Base
 	template <typename ...Args>
 	bool mixinBeforeDispatch(Args && ...args) const {
 		if(! filterList.empty()) {
-			if(
-				! filterList.forEachIf([&args...](typename FilterList::Callback & callback) {
-				return callback(args...);
-			})
-				) {
+			if(! filterList.forEachIf([&args...](typename FilterList::Callback & callback) {
+					return callback(args...);
+				})
+			) {
 				return false;
 			}
 		}
diff --git a/tests/unittest/CMakeLists.txt b/tests/unittest/CMakeLists.txt
index f6fcfce..b4cb1c0 100644
--- a/tests/unittest/CMakeLists.txt
+++ b/tests/unittest/CMakeLists.txt
@@ -14,6 +14,7 @@ set(SRC_TEST
 	test_queue_basic.cpp
 	test_queue_multithread.cpp
 	test_heterdispatcher_basic.cpp
+	test_heterqueue_basic.cpp
 	test_eventutil.cpp
 	test_conditionalremover.cpp
 	test_counterremover.cpp
diff --git a/tests/unittest/test_heterdispatcher_basic.cpp b/tests/unittest/test_heterdispatcher_basic.cpp
index 728264d..258cbc5 100644
--- a/tests/unittest/test_heterdispatcher_basic.cpp
+++ b/tests/unittest/test_heterdispatcher_basic.cpp
@@ -15,13 +15,74 @@
 #include "eventpp/hetereventdispatcher.h"
 
 struct xxx{};
-static_assert(eventpp::internal_::CanConvert<std::tuple<int, int>, std::tuple<int ,int> >::value, "");
-static_assert(eventpp::internal_::FindCallablePrototype<std::tuple<void (), void (int, int)>, void() >::index == 0, "");
-static_assert(eventpp::internal_::FindCallablePrototype<std::tuple<void (int), void (int, int)>, void(char)>::index == 0, "");
-static_assert(eventpp::internal_::FindCallablePrototype<std::tuple<void (int), void (int, int)>, void(char, int)>::index == 1, "");
-static_assert(eventpp::internal_::FindCallablePrototype<std::tuple<void (int), void (int, int), void (int, const xxx &)>, void(int, xxx)>::index == 2, "");
+static_assert(eventpp::internal_::FindPrototypeByCallable<std::tuple<void (), void (int, int)>, void() >::index == 0, "");
+static_assert(eventpp::internal_::FindPrototypeByCallable<std::tuple<void (int), void (int, int)>, void(char)>::index == 0, "");
+static_assert(eventpp::internal_::FindPrototypeByCallable<std::tuple<void (int), void (int, int)>, void(char, int)>::index == 1, "");
+static_assert(eventpp::internal_::FindPrototypeByCallable<std::tuple<void (int), void (int, int), void (int, const xxx &)>, void(int, xxx)>::index == 2, "");
+static_assert(eventpp::internal_::FindPrototypeByCallable<std::tuple<void (), void (const std::string &)>, void(const std::string &) >::index == 1, "");
 
-TEST_CASE("xxx HeterEventDispatcher, 1")
+template <bool condition>
+struct FindTypeByIndexHelper;
+
+template <>
+struct FindTypeByIndexHelper <true>
+{
+	template <int N, int M, typename C, typename ...Args>
+	static constexpr void find(const int index, const C & c, Args && ...args)
+	{
+		if(index == N) {
+			c.template operator()<N>(std::forward<Args>(args)...);
+		}
+
+		FindTypeByIndexHelper<(N + 1 < M)>::template find<N + 1, M>(index, c, std::forward<Args>(args)...);
+	}
+
+};
+
+template <>
+struct FindTypeByIndexHelper <false>
+{
+	template <int N, int M, typename C, typename ...Args>
+	static constexpr void find(const int index, const C & c, Args && ...args)
+	{
+	}
+
+};
+
+template <int N, int M, typename C, typename ...Args>
+constexpr void findTypeByIndex(const int index, const C & c, Args && ...args)
+{
+	FindTypeByIndexHelper<(N < M)>::template find<N, M>(index, c, std::forward<Args>(args)...);
+}
+
+struct Back
+{
+	template <int N, typename T>
+	void operator()(T *, int * p) const {
+		*p = (int)sizeof(typename std::tuple_element<N, T>::type);
+	}
+};
+
+using FreeFunc = void (*)(void *);
+template <typename T>
+void freeIt(void * p)
+{
+	*(int *)p = sizeof(T);
+}
+
+template <typename ...Args>
+struct YYY
+{
+	static const FreeFunc * get() {
+		static std::array<FreeFunc, sizeof...(Args)> data {
+			&freeIt<Args>...
+		};
+
+		return data.data();
+	}
+};
+
+TEST_CASE("HeterEventDispatcher, 1")
 {
 	eventpp::HeterEventDispatcher<int, std::tuple<void (), void (int, int, int)> > dispatcher;
 
diff --git a/tests/unittest/test_heterqueue_basic.cpp b/tests/unittest/test_heterqueue_basic.cpp
new file mode 100644
index 0000000..74057b8
--- /dev/null
+++ b/tests/unittest/test_heterqueue_basic.cpp
@@ -0,0 +1,44 @@
+// eventpp library
+// Copyright (C) 2018 Wang Qi (wqking)
+// Github: https://github.com/wqking/eventpp
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//   http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "test.h"
+#include "eventpp/hetereventqueue.h"
+
+TEST_CASE("xxx HeterEventQueue 1")
+{
+	eventpp::HeterEventQueue<std::string, std::tuple<void (), void (const std::string &)> > queue;
+
+	int a = 1;
+	int b = 5;
+
+	queue.appendListener("event1", [&a](const std::string &) {
+		a = 2;
+	});
+	queue.appendListener("event1", [&b]() {
+		b = 8;
+	});
+
+	REQUIRE(a != 2);
+	REQUIRE(b != 8);
+
+	queue.enqueue("event1");
+	queue.process();
+	REQUIRE(a == 1);
+	REQUIRE(b == 8);
+
+	queue.enqueue("event1", "a");
+	queue.process();
+	REQUIRE(a == 2);
+	REQUIRE(b == 8);
+}
+
diff --git a/tests/unittest/test_queue_basic.cpp b/tests/unittest/test_queue_basic.cpp
index 905227a..264dea2 100644
--- a/tests/unittest/test_queue_basic.cpp
+++ b/tests/unittest/test_queue_basic.cpp
@@ -211,6 +211,33 @@ TEST_CASE("EventQueue, no memory leak in queued arguments")
 	}
 }
 
+TEST_CASE("EventQueue, no memory leak in queued arguments after queue is destroyed")
+{
+	using SP = std::shared_ptr<int>;
+	using WP = std::weak_ptr<int>;
+	using EQ = eventpp::EventQueue<int, void (SP)>;
+
+	std::vector<WP> wpList;
+
+	{
+		std::unique_ptr<EQ> queue(new EQ());
+
+		auto add = [&wpList, &queue](int n) {
+			SP sp(std::make_shared<int>(n));
+			queue->enqueue(n, sp);
+			wpList.push_back(WP(sp));
+		};
+
+		add(1);
+		add(2);
+		add(3);
+
+		REQUIRE(! checkAllWeakPtrAreFreed(wpList));
+	}
+
+	REQUIRE(checkAllWeakPtrAreFreed(wpList));
+}
+
 TEST_CASE("EventQueue, no memory leak or double free in queued arguments")
 {
 	struct Item {

From f5791a461c6b019944100c575d9d0b45da139d3a Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Sat, 15 Dec 2018 22:40:46 +0800
Subject: [PATCH 13/38] Improved documents

---
 doc/callbacklist.md | 19 ++++++++++---------
 doc/introduction.md | 16 ++++++++--------
 2 files changed, 18 insertions(+), 17 deletions(-)

diff --git a/doc/callbacklist.md b/doc/callbacklist.md
index 35a7f8c..26f5d13 100644
--- a/doc/callbacklist.md
+++ b/doc/callbacklist.md
@@ -11,7 +11,8 @@
 
 CallbackList is the fundamental class in eventpp. The other classes EventDispatcher and EventQueue are built on CallbackList.  
 
-CallbackList holds a list of callbacks. On invocation, CallbackList simply invokes each callbacks one by one. Think CallbackList as the signal/slot system in Qt, or the callback function pointer in some Windows APIs (such as lpCompletionRoutine in `ReadFileEx`).  
+CallbackList holds a list of callbacks. At the time of the call, CallbackList simply invokes each callback one by one. Consider CallbackList as the signal/slot system in Qt, or the callback function pointer in some Windows APIs (such as lpCompletionRoutine in `ReadFileEx`).  
+The *callback* can be any callback target -- functions, pointers to functions, , pointers to member functions, lambda expressions, and function objects.  
 
 <a name="apis"></a>
 ## API reference
@@ -53,7 +54,7 @@ CallbackList can be copied, moved,  assigned, and move assigned.
 bool empty() const;
 ```
 Return true if the callback list is empty.  
-Note: in multi threading, this function returning true doesn't guarantee the list is empty. The list may become non-empty immediately after the function returns true.
+Note: in multi threading, this function returning true doesn't guarantee that the list is empty. The list may immediately become non-empty after the function returns true.
 
 ```c++
 operator bool() const;
@@ -66,8 +67,8 @@ Handle append(const Callback & callback);
 ```  
 Add the *callback* to the callback list.  
 The callback is added to the end of the callback list.  
-Return a handle which represents the callback. The handle can be used to remove this callback or insert other callback before this callback.  
-If `append` is called in another callback during the invoking of the callback list, the new callback is guaranteed not triggered during the same callback list invoking.  
+Return a handle that represents the callback. The handle can be used to remove this callback or to insert additional callbacks before this callback.  
+If `append` is called in another callback during the invoking of the callback list, the new callback is guaranteed not to be triggered during the same callback list invoking.  
 The time complexity is O(1).
 
 ```c++
@@ -75,16 +76,16 @@ Handle prepend(const Callback & callback);
 ```  
 Add the *callback* to the callback list.  
 The callback is added to the beginning of the callback list.  
-Return a handle which represents the callback. The handle can be used to remove this callback or insert other callback before this callback.  
-If `prepend` is called in another callback during the invoking of the callback list, the new callback is guaranteed not triggered during the same callback list invoking.  
+Return a handle that represents the callback. The handle can be used to remove this callback or to insert additional callbacks before this callback.  
+If `prepend` is called in another callback during the invoking of the callback list, the new callback is guaranteed not to be triggered during the same callback list invoking.  
 The time complexity is O(1).
 
 ```c++
 Handle insert(const Callback & callback, const Handle before);
 ```  
 Insert the *callback* to the callback list before the callback handle *before*. If *before* is not found, *callback* is added at the end of the callback list.  
-Return a handle which represents the callback. The handle can be used to remove this callback or insert other callback before this callback.  
-If `insert` is called in another callback during the invoking of the callback list, the new callback is guaranteed not triggered during the same callback list invoking.  
+Return a handle that represents the callback. The handle can be used to remove this callback or to insert additional callbacks before this callback.  
+If `insert` is called in another callback during the invoking of the callback list, the new callback is guaranteed not to be triggered during the same callback list invoking.  
 The time complexity is O(1).  
 
 ```c++
@@ -139,4 +140,4 @@ The callbacks are called in the thread same as the callee of `operator()`.
 ## Internal data structure
 
 CallbackList uses doubly linked list to manage the callbacks.  
-Each node is linked by shared pointer. Using shared pointer allows the node be removed while iterating.  
+Each node is linked by a shared pointer. Using shared pointer allows nodes to be removed during iterating.  
diff --git a/doc/introduction.md b/doc/introduction.md
index 1b5bdda..58e08ca 100644
--- a/doc/introduction.md
+++ b/doc/introduction.md
@@ -1,20 +1,20 @@
 # Introduction to eventpp library
 
-eventpp includes three major classes, CallbackList, EventDispatcher, and EventQueue. Each class has different purpose and usage.  
+eventpp includes three main classes, CallbackList, EventDispatcher, and EventQueue. Each class has a different purpose and usage.  
 
 ## Class CallbackList
 
 CallbackList is the fundamental class in eventpp. The other classes EventDispatcher and EventQueue are built on CallbackList.  
 
-CallbackList holds a list of callbacks. On invocation, CallbackList simply invokes each callbacks one by one. Think CallbackList as the signal/slot system in Qt, or the callback function pointer in some Windows APIs (such as lpCompletionRoutine in `ReadFileEx`).  
+CallbackList holds a list of callbacks. At the time of the call, CallbackList simply invokes each callback one by one. Consider CallbackList as the signal/slot system in Qt, or the callback function pointer in some Windows APIs (such as lpCompletionRoutine in `ReadFileEx`).  
 The *callback* can be any callback target -- functions, pointers to functions, , pointers to member functions, lambda expressions, and function objects.  
 
-CallbackList is ideal when there are very few kinds of events. Each event can have its own CallbackList, and each CallbackList can have different prototype. For example,
+CallbackList is ideal when there are very few kinds of events. Each event can have its own CallbackList, and each CallbackList can have a different prototype. For example,
 ```c++
 eventpp::CallbackList<void()> onStart;
 eventpp::CallbackList<void(MyStopReason)> onStop;
 ```
-However, if there are lots of kinds of events, hundreds to unlimited (this is quite common in a GUI or game system), using CallbackList for each events will be crazy. This is how EventDispatcher comes useful.  
+However, if there are many kinds of events, hundreds of to unlimited (this is quite common in GUI or game systems), it would be crazy to use CallbackList for each event. This is how EventDispatcher comes useful.  
 
 ## Class EventDispatcher
 
@@ -22,7 +22,7 @@ EventDispatcher is something like std::map<EventType, CallbackList>.
 
 EventDispatcher holds a map of `<EventType, CallbackList>` pairs. On dispatching, EventDispatcher finds the CallbackList of the event type, then invoke the callback list. The invocation is always synchronous. The listeners are triggered when `EventDispatcher::dispatch` is called.  
 
-EventDispatcher is ideal when there are lots of kinds of events, or the number of events can't be determined. Each event is distinguished by an event type. For example,
+EventDispatcher is ideal when there are many kinds of events, or the number of events cannot be predetermined. Each event is distinguished by the event type. For example,
 ```c++
 enum class MyEventType
 {
@@ -48,7 +48,7 @@ eventpp::EventDispatcher<MyEventType, void(const MyEvent &), MyEventPolicies> di
 dispatcher.dispatch(MyEvent { MyEventType::redraw });
 ```
 (Note: if you are confused with MyEventPolicies in above sample, please read the [document of policies](policies.md), and just consider the dispatcher as `eventpp::EventDispatcher<MyEventType, void(const MyEvent &)> dispatcher` for now.)  
-The disadvantage of EventDispatcher is that all events must have the same callback prototype (`void(const MyEvent &)` in the sample code). The common solution is that the callback takes a base class of Event and all events derive their own event data from Event. In the sample code, MyEvent is the base event class, the callback takes one argument of const reference to MyEvent.  
+The disadvantage of EventDispatcher is that all events must have the same callback prototype (`void(const MyEvent &)` in the sample code). The common solution is that the callback takes a base class of Event and all events derive their own event data from Event. In the sample code, MyEvent is the base event class, the callback takes an argument of `const reference to MyEvent`.  
 
 ## Class EventQueue
 
@@ -69,8 +69,8 @@ queue.process();
 ```
 
 ## Thread safety
-All classes are thread safe. All public functions can be invoked from multiple threads simultaneously. If it fails, please report a bug.  
-The library guarantees the integration of each single function invocation, such as `EventDispatcher::appendListener`, 'CallbackList::remove`, but it doesn't guarantee the order of the operations in multiple threads. For example, if a thread is dispatching an event, the other thread removes a listener in the mean time, the removed listener may be still triggered after it's removed.  
+All classes are thread-safe. You can call all public functions from multiple threads at the same time. If it fails, please report a bug.  
+The library guarantees the integration of each single function call, such as `EventDispatcher::appendListener`, 'CallbackList::remove`, but it does not guarantee the order of operations in multiple threads. For example, if a thread is dispatching an event, another thread removes a listener at the same time, the removed listener may be still triggered after it's removed.  
 
 ## Exception safety
 

From 9a90b1901283efef74378344e33820c30e1d7abe Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Sat, 15 Dec 2018 22:41:38 +0800
Subject: [PATCH 14/38] Added MixinHeterFilter

---
 include/eventpp/hetereventdispatcher.h        |  25 ++-
 include/eventpp/internal/eventpolicies_i.h    |  13 ++
 .../eventpp/internal/hetereventdispatcher_i.h |  57 ++++-
 include/eventpp/internal/typeutil_i.h         |  35 ++++
 include/eventpp/mixins/mixinheterfilter.h     | 100 +++++++++
 tests/unittest/test_dispatcher_basic.cpp      |   1 -
 tests/unittest/test_heterdispatcher_basic.cpp | 196 ++++++++++++------
 7 files changed, 337 insertions(+), 90 deletions(-)
 create mode 100644 include/eventpp/mixins/mixinheterfilter.h

diff --git a/include/eventpp/hetereventdispatcher.h b/include/eventpp/hetereventdispatcher.h
index 5b55d7a..b1e72ad 100644
--- a/include/eventpp/hetereventdispatcher.h
+++ b/include/eventpp/hetereventdispatcher.h
@@ -39,7 +39,7 @@ template <
 >
 class HeterEventDispatcherBase
 {
-private:
+protected:
 	struct Handle_
 	{
 		int index;
@@ -77,7 +77,6 @@ class HeterEventDispatcherBase
 		}
 	};
 
-protected:
 	using ThisType = HeterEventDispatcherBase<
 		EventType_,
 		PrototypeList_,
@@ -91,13 +90,12 @@ class HeterEventDispatcherBase
 	// Disable ArgumentPassingMode explicitly
 	static_assert(! HasTypeArgumentPassingMode<Policies>::value, "Policies can't have ArgumentPassingMode in heterogeneous dispatcher.");
 
-	enum { prototypeCount = std::tuple_size<PrototypeList_>::value };
+	using PrototypeList = PrototypeList_;
 
 public:
 	using Handle = Handle_;
 	using Event = EventType_;
 	using Mutex = typename Threading::Mutex;
-
 public:
 	HeterEventDispatcherBase()
 		:
@@ -193,22 +191,29 @@ class HeterEventDispatcherBase
 protected:
 	template <typename PrototypeInfo>
 	auto doFindDispatcher() const
-		-> HomoDispatcherType<typename PrototypeInfo::Prototype> *
+		-> std::shared_ptr<HomoDispatcherType<typename PrototypeInfo::Prototype> >
 	{
 		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
 
 		if(! dispatcherList[PrototypeInfo::index]) {
+			std::lock_guard<Mutex> lockGuard(dispatcherListMutex);
+
 			if(! dispatcherList[PrototypeInfo::index]) {
-				std::lock_guard<Mutex> lockGuard(dispatcherListMutex);
 				dispatcherList[PrototypeInfo::index] = std::make_shared<HomoDispatcherType<typename PrototypeInfo::Prototype> >();
 			}
 		}
 
-		return static_cast<HomoDispatcherType<typename PrototypeInfo::Prototype> *>(dispatcherList[PrototypeInfo::index].get());
+		return std::static_pointer_cast<HomoDispatcherType<typename PrototypeInfo::Prototype> >(dispatcherList[PrototypeInfo::index]);
+	}
+
+	// Used by mixins
+	std::shared_ptr<HomoDispatcherTypeBase> doGetDispatcherAt(const int index) const
+	{
+		return dispatcherList[index];
 	}
 
 private:
-	mutable std::array<std::shared_ptr<HomoDispatcherTypeBase>, prototypeCount> dispatcherList;
+	mutable std::array<std::shared_ptr<HomoDispatcherTypeBase>, std::tuple_size<PrototypeList_>::value> dispatcherList;
 	mutable Mutex dispatcherListMutex;
 };
 
@@ -222,13 +227,13 @@ template <
 >
 class HeterEventDispatcher : public internal_::InheritMixins<
 		internal_::HeterEventDispatcherBase<Event_, PrototypeList_, Policies_, void>,
-		typename internal_::SelectMixins<Policies_, internal_::HasTypeMixins<Policies_>::value >::Type
+		typename internal_::SelectHeterMixins<Policies_, internal_::HasTypeHeterMixins<Policies_>::value >::Type
 	>::Type, public TagEventDispatcher
 {
 private:
 	using super = typename internal_::InheritMixins<
 		internal_::HeterEventDispatcherBase<Event_, PrototypeList_, Policies_, void>,
-		typename internal_::SelectMixins<Policies_, internal_::HasTypeMixins<Policies_>::value >::Type
+		typename internal_::SelectHeterMixins<Policies_, internal_::HasTypeHeterMixins<Policies_>::value >::Type
 	>::Type;
 
 public:
diff --git a/include/eventpp/internal/eventpolicies_i.h b/include/eventpp/internal/eventpolicies_i.h
index 8fb770c..ca04522 100644
--- a/include/eventpp/internal/eventpolicies_i.h
+++ b/include/eventpp/internal/eventpolicies_i.h
@@ -122,6 +122,19 @@ template <typename T> struct SelectMixins <T, true> { using Type = typename T::M
 template <typename T> struct SelectMixins <T, false> { using Type = MixinList<>; };
 
 
+template <typename T>
+struct HasTypeHeterMixins
+{
+	template <typename C> static std::true_type test(typename C::HeterMixins *) ;
+	template <typename C> static std::false_type test(...);    
+
+	enum { value = !! decltype(test<T>(0))() };
+};
+template <typename T, bool> struct SelectHeterMixins;
+template <typename T> struct SelectHeterMixins <T, true> { using Type = typename T::HeterMixins; };
+template <typename T> struct SelectHeterMixins <T, false> { using Type = MixinList<>; };
+
+
 template <typename Root, typename TList>
 struct InheritMixins;
 
diff --git a/include/eventpp/internal/hetereventdispatcher_i.h b/include/eventpp/internal/hetereventdispatcher_i.h
index 87246c0..7cd63aa 100644
--- a/include/eventpp/internal/hetereventdispatcher_i.h
+++ b/include/eventpp/internal/hetereventdispatcher_i.h
@@ -18,10 +18,10 @@ namespace eventpp {
 
 namespace internal_ {
 
-template <size_t N, typename PrototypeList_, typename Callable>
+template <int N, typename PrototypeList_, typename Callable>
 struct FindPrototypeByCallableHelper;
 
-template <size_t N, typename RT, typename ...Args, typename ...Others, typename Callable>
+template <int N, typename RT, typename ...Args, typename ...Others, typename Callable>
 struct FindPrototypeByCallableHelper <N, std::tuple<RT (Args...), Others...>, Callable>
 {
 	enum { canInvoke = CanInvoke<Callable, Args...>::value };
@@ -45,7 +45,7 @@ struct FindPrototypeByCallableHelper <N, std::tuple<RT (Args...), Others...>, Ca
 	};
 };
 
-template <size_t N, typename Callable>
+template <int N, typename Callable>
 struct FindPrototypeByCallableHelper <N, std::tuple<>, Callable>
 {
 	using Prototype = void;
@@ -62,10 +62,10 @@ struct FindPrototypeByCallable : public FindPrototypeByCallableHelper <0, Protot
 {
 };
 
-template <size_t N, typename PrototypeList_, typename ...InArgs>
+template <int N, typename PrototypeList_, typename ...InArgs>
 struct FindPrototypeByArgsHelper;
 
-template <size_t N, typename RT, typename ...Args, typename ...Others, typename ...InArgs>
+template <int N, typename RT, typename ...Args, typename ...Others, typename ...InArgs>
 struct FindPrototypeByArgsHelper <N, std::tuple<RT (Args...), Others...>, InArgs...>
 {
 	enum { canInvoke = CanInvoke<RT (Args...), InArgs...>::value };
@@ -89,16 +89,14 @@ struct FindPrototypeByArgsHelper <N, std::tuple<RT (Args...), Others...>, InArgs
 	};
 };
 
-template <size_t N, typename ...InArgs>
+template <int N, typename ...InArgs>
 struct FindPrototypeByArgsHelper <N, std::tuple<>, InArgs...>
 {
 	using Prototype = void;
 
 	using ArgsTuple = std::tuple<>;
 
-	enum {
-		index = -1
-	};
+	enum { index = -1 };
 };
 
 template <typename PrototypeList_, typename ...InArgs>
@@ -106,6 +104,45 @@ struct FindPrototypeByArgs : public FindPrototypeByArgsHelper <0, PrototypeList_
 {
 };
 
+template <int I, int N, typename PrototypeList_>
+struct FindPrototypeByIndexHelper;
+
+template <int I, int N, typename RT, typename ...Args, typename ...Others>
+struct FindPrototypeByIndexHelper <I, N, std::tuple<RT (Args...), Others...> >
+{
+	using NextType = FindPrototypeByIndexHelper<I + 1, N, std::tuple<Others...> >;
+	using Prototype = typename NextType::Prototype;
+
+	using ArgsTuple = typename NextType::ArgsTuple;
+
+	enum { index = NextType::index };
+};
+
+template <int N, typename RT, typename ...Args, typename ...Others>
+struct FindPrototypeByIndexHelper <N, N, std::tuple<RT (Args...), Others...> >
+{
+	using Prototype = RT (Args...);
+
+	using ArgsTuple = std::tuple<typename std::remove_cv<typename std::remove_reference<Args>::type>::type...>;
+
+	enum { index = N };
+};
+
+template <int I, int N>
+struct FindPrototypeByIndexHelper <I, N, std::tuple<>>
+{
+	using Prototype = void;
+
+	using ArgsTuple = std::tuple<>;
+
+	enum { index = -1 };
+};
+
+template <typename PrototypeList_, int N>
+struct FindPrototypeByIndex : public FindPrototypeByIndexHelper <0, N, PrototypeList_>
+{
+};
+
 template <typename PrototypeList_, template <typename ...> class Record>
 struct GetCallablePrototypeMaxSize;
 
@@ -116,7 +153,7 @@ struct GetCallablePrototypeMaxSize <std::tuple<RT (Args...), Others...>, Record>
 		my = sizeof(Record<Args...>),
 		other = GetCallablePrototypeMaxSize<std::tuple<Others...>, Record>::value
 	};
-	enum { value = (my > other ? (size_t)my : (size_t)other) };
+	enum { value = (my > other ? (int)my : (int)other) };
 };
 
 template <template <typename ...> class Record>
diff --git a/include/eventpp/internal/typeutil_i.h b/include/eventpp/internal/typeutil_i.h
index 9187642..1a1e57d 100644
--- a/include/eventpp/internal/typeutil_i.h
+++ b/include/eventpp/internal/typeutil_i.h
@@ -36,6 +36,41 @@ struct ReplaceReturnType <RT (Args...), Replacement>
 	using Type = Replacement (Args...);
 };
 
+template <int N, int M>
+struct IntToConstantHelper
+{
+	template <typename C, typename ...Args>
+	static auto find(const int index, C && c, Args && ...args)
+		-> decltype(std::declval<C>().template operator()<0>(std::declval<Args>()...))
+	{
+		if(N == index) {
+			return c.template operator()<N>(std::forward<Args>(args)...);
+		}
+		else {
+			return IntToConstantHelper<N + 1, M>::find(index, std::forward<C>(c), std::forward<Args>(args)...);
+		}
+	}
+};
+
+template <int M>
+struct IntToConstantHelper <M, M>
+{
+	template <typename C, typename ...Args>
+	static auto find(const int index, C && c, Args && ...args)
+		-> decltype(std::declval<C>().template operator()<0>(std::declval<Args>()...))
+	{
+		return decltype(c.template operator()<0>(std::forward<Args>(args)...))();
+	}
+};
+
+template <int M, typename C, typename ...Args>
+auto intToConstant(const int index, C && c, Args && ...args)
+	-> decltype(std::declval<C>().template operator()<0>(std::declval<Args>()...))
+{
+	return IntToConstantHelper<0, M>::find(index, std::forward<C>(c), std::forward<Args>(args)...);
+}
+
+
 } //namespace internal_
 
 } //namespace eventpp
diff --git a/include/eventpp/mixins/mixinheterfilter.h b/include/eventpp/mixins/mixinheterfilter.h
new file mode 100644
index 0000000..5248a3d
--- /dev/null
+++ b/include/eventpp/mixins/mixinheterfilter.h
@@ -0,0 +1,100 @@
+// eventpp library
+// Copyright (C) 2018 Wang Qi (wqking)
+// Github: https://github.com/wqking/eventpp
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//   http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef MIXINHETERFILTER_H_990158796753
+#define MIXINHETERFILTER_H_990158796753
+
+#include "../callbacklist.h"
+#include "../internal/typeutil_i.h"
+
+#include <functional>
+#include <type_traits>
+
+namespace eventpp {
+
+template <typename Base>
+class MixinHeterFilter : public Base
+{
+private:
+	using super = Base;
+
+	struct FilterHandle_
+	{
+		int index;
+		std::weak_ptr<void> homoHandle;
+
+		operator bool () const noexcept {
+			return (bool)homoHandle;
+		}
+	};
+
+	struct RemoveFilterCallback
+	{
+		template <int N, typename PrototypeList>
+		bool operator() (MixinHeterFilter * self, const PrototypeList *, const FilterHandle_ & filterHandle) const
+		{
+			auto sp = filterHandle.homoHandle.lock();
+			if(! sp) {
+				return false;
+			}
+
+			using PrototypeInfo = internal_::FindPrototypeByIndex<PrototypeList, N>;
+			auto dispatcher = self->template doFindDispatcher<PrototypeInfo>();
+			if(! dispatcher) {
+				return false;
+			}
+			return dispatcher->removeFilter(typename decltype(dispatcher)::element_type::FilterHandle(
+				std::static_pointer_cast<
+					typename decltype(dispatcher)::element_type::FilterHandle::element_type
+				>(sp)
+			));
+		}
+	};
+
+public:
+	using FilterHandle = FilterHandle_;
+
+public:
+	template <typename C>
+	FilterHandle appendFilter(const C & callback) const
+	{
+		using PrototypeInfo = internal_::FindPrototypeByCallable<typename super::PrototypeList, C>;
+		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
+
+		auto dispatcher = this->template doFindDispatcher<PrototypeInfo>();
+		return FilterHandle {
+			PrototypeInfo::index,
+			dispatcher->appendFilter(callback)
+		};
+	}
+
+	bool removeFilter(const FilterHandle & filterHandle)
+	{
+		return internal_::intToConstant<std::tuple_size<typename super::PrototypeList>::value>(
+			filterHandle.index,
+			RemoveFilterCallback(),
+			this,
+			(typename super::PrototypeList *)nullptr,
+			filterHandle
+		);
+	}
+
+private:
+};
+
+
+} //namespace eventpp
+
+
+#endif
+
diff --git a/tests/unittest/test_dispatcher_basic.cpp b/tests/unittest/test_dispatcher_basic.cpp
index 226176b..d36d5d3 100644
--- a/tests/unittest/test_dispatcher_basic.cpp
+++ b/tests/unittest/test_dispatcher_basic.cpp
@@ -290,7 +290,6 @@ TEST_CASE("EventDispatcher, event filter")
 		});
 	}
 
-
 	constexpr int filterCount = 2;
 	std::vector<int> filterData(filterCount);
 
diff --git a/tests/unittest/test_heterdispatcher_basic.cpp b/tests/unittest/test_heterdispatcher_basic.cpp
index 258cbc5..b54232e 100644
--- a/tests/unittest/test_heterdispatcher_basic.cpp
+++ b/tests/unittest/test_heterdispatcher_basic.cpp
@@ -13,76 +13,10 @@
 
 #include "test.h"
 #include "eventpp/hetereventdispatcher.h"
+#include "eventpp/mixins/mixinfilter.h"
+#include "eventpp/mixins/mixinheterfilter.h"
 
-struct xxx{};
-static_assert(eventpp::internal_::FindPrototypeByCallable<std::tuple<void (), void (int, int)>, void() >::index == 0, "");
-static_assert(eventpp::internal_::FindPrototypeByCallable<std::tuple<void (int), void (int, int)>, void(char)>::index == 0, "");
-static_assert(eventpp::internal_::FindPrototypeByCallable<std::tuple<void (int), void (int, int)>, void(char, int)>::index == 1, "");
-static_assert(eventpp::internal_::FindPrototypeByCallable<std::tuple<void (int), void (int, int), void (int, const xxx &)>, void(int, xxx)>::index == 2, "");
-static_assert(eventpp::internal_::FindPrototypeByCallable<std::tuple<void (), void (const std::string &)>, void(const std::string &) >::index == 1, "");
-
-template <bool condition>
-struct FindTypeByIndexHelper;
-
-template <>
-struct FindTypeByIndexHelper <true>
-{
-	template <int N, int M, typename C, typename ...Args>
-	static constexpr void find(const int index, const C & c, Args && ...args)
-	{
-		if(index == N) {
-			c.template operator()<N>(std::forward<Args>(args)...);
-		}
-
-		FindTypeByIndexHelper<(N + 1 < M)>::template find<N + 1, M>(index, c, std::forward<Args>(args)...);
-	}
-
-};
-
-template <>
-struct FindTypeByIndexHelper <false>
-{
-	template <int N, int M, typename C, typename ...Args>
-	static constexpr void find(const int index, const C & c, Args && ...args)
-	{
-	}
-
-};
-
-template <int N, int M, typename C, typename ...Args>
-constexpr void findTypeByIndex(const int index, const C & c, Args && ...args)
-{
-	FindTypeByIndexHelper<(N < M)>::template find<N, M>(index, c, std::forward<Args>(args)...);
-}
-
-struct Back
-{
-	template <int N, typename T>
-	void operator()(T *, int * p) const {
-		*p = (int)sizeof(typename std::tuple_element<N, T>::type);
-	}
-};
-
-using FreeFunc = void (*)(void *);
-template <typename T>
-void freeIt(void * p)
-{
-	*(int *)p = sizeof(T);
-}
-
-template <typename ...Args>
-struct YYY
-{
-	static const FreeFunc * get() {
-		static std::array<FreeFunc, sizeof...(Args)> data {
-			&freeIt<Args>...
-		};
-
-		return data.data();
-	}
-};
-
-TEST_CASE("HeterEventDispatcher, 1")
+TEST_CASE("xxx HeterEventDispatcher, 1")
 {
 	eventpp::HeterEventDispatcher<int, std::tuple<void (), void (int, int, int)> > dispatcher;
 
@@ -119,3 +53,127 @@ TEST_CASE("HeterEventDispatcher, 1")
 	REQUIRE(dataList[1] == 24);
 }
 
+TEST_CASE("xxx HeterEventDispatcher, event filter")
+{
+	struct MyPolicies {
+		using Mixins = eventpp::MixinList<eventpp::MixinFilter>;
+		using HeterMixins = eventpp::MixinList<eventpp::MixinHeterFilter>;
+	};
+	using ED = eventpp::HeterEventDispatcher<int, std::tuple<void (int, int), void ()>, MyPolicies>;
+	ED dispatcher;
+
+	constexpr int itemCount = 5;
+	std::vector<int> dataList(itemCount);
+
+	for(int i = 0; i < itemCount; ++i) {
+		dispatcher.appendListener(i, [&dataList, i](int e, int index) {
+			dataList[e] = index;
+		});
+	}
+
+	constexpr int filterCount = 2;
+	std::vector<int> filterData(filterCount);
+
+	SECTION("Filter invoked count") {
+		auto handle1 = dispatcher.appendFilter([&filterData](int, int) -> bool {
+			++filterData[0];
+			return true;
+		});
+		auto handle2 = dispatcher.appendFilter([&filterData]() -> bool {
+			++filterData[1];
+			return true;
+		});
+
+		for(int i = 0; i < itemCount; ++i) {
+			dispatcher.dispatch(i, i, 58);
+			dispatcher.dispatch(i);
+		}
+
+		REQUIRE(filterData == std::vector<int>{ itemCount, itemCount });
+		REQUIRE(dataList == std::vector<int>{ 58, 58, 58, 58, 58 });
+
+		dispatcher.removeFilter(handle1);
+
+		for(int i = 0; i < itemCount; ++i) {
+			dispatcher.dispatch(i, i, 38);
+			dispatcher.dispatch(i);
+		}
+
+		REQUIRE(filterData == std::vector<int>{ itemCount, itemCount * 2 });
+
+		dispatcher.removeFilter(handle2);
+		dispatcher.removeFilter(handle2);
+
+		for(int i = 0; i < itemCount; ++i) {
+			dispatcher.dispatch(i, i, 38);
+			dispatcher.dispatch(i);
+		}
+
+		REQUIRE(filterData == std::vector<int>{ itemCount, itemCount * 2 });
+	}
+#if 0
+	SECTION("First filter blocks all other filters and listeners") {
+		dispatcher.appendFilter([&filterData](int e, int /*index*/) -> bool {
+			++filterData[0];
+			if(e >= 2) {
+				return false;
+			}
+			return true;
+		});
+		dispatcher.appendFilter([&filterData](int /*e*/, int /*index*/) -> bool {
+			++filterData[1];
+			return true;
+		});
+
+		for(int i = 0; i < itemCount; ++i) {
+			dispatcher.dispatch(i, 58);
+		}
+
+		REQUIRE(filterData == std::vector<int>{ itemCount, 2 });
+		REQUIRE(dataList == std::vector<int>{ 58, 58, 0, 0, 0 });
+	}
+
+	SECTION("Second filter doesn't block first filter but all listeners") {
+		dispatcher.appendFilter([&filterData](int /*e*/, int /*index*/) -> bool {
+			++filterData[0];
+			return true;
+		});
+		dispatcher.appendFilter([&filterData](int e, int /*index*/) -> bool {
+			++filterData[1];
+			if(e >= 2) {
+				return false;
+			}
+			return true;
+		});
+
+		for(int i = 0; i < itemCount; ++i) {
+			dispatcher.dispatch(i, 58);
+		}
+
+		REQUIRE(filterData == std::vector<int>{ itemCount, itemCount });
+		REQUIRE(dataList == std::vector<int>{ 58, 58, 0, 0, 0 });
+	}
+
+	SECTION("Filter manipulates the parameters") {
+		dispatcher.appendFilter([&filterData](int e, int & index) -> bool {
+			++filterData[0];
+			if(e >= 2) {
+				++index;
+			}
+			return true;
+		});
+		dispatcher.appendFilter([&filterData](int /*e*/, int /*index*/) -> bool {
+			++filterData[1];
+			return true;
+		});
+
+		for(int i = 0; i < itemCount; ++i) {
+			dispatcher.dispatch(i, 58);
+		}
+
+		REQUIRE(filterData == std::vector<int>{ itemCount, itemCount });
+		REQUIRE(dataList == std::vector<int>{ 58, 58, 59, 59, 59 });
+	}
+#endif
+}
+

From 689c8c70d6f6eb1d18824cbc79f3a2c970350bb3 Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Sat, 15 Dec 2018 23:21:28 +0800
Subject: [PATCH 15/38] Improved readme

---
 readme.md | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/readme.md b/readme.md
index bf00c33..8c3098d 100644
--- a/readme.md
+++ b/readme.md
@@ -1,16 +1,16 @@
 # eventpp -- C++ library for event dispatcher and callback list
 
-eventpp is a C++ event library that provides tools that allow your application components to communicate with each other by dispatching events and listening to them. With eventpp you can implement signal/slot mechanism, or observer pattern, very easily.
+eventpp is a C++ event library that provides tools that enable your application components to communicate with each other by dispatching events and listening for them. With eventpp you can easily implement signal/slot mechanism, or observer pattern.
 
 ## Facts and features
 
 - **Powerful**
-  - Supports both synchronous event dispatching and asynchronous event queue.
+  - Supports synchronous event dispatching and asynchronous event queue.
   - Configurable and extensible with policies and mixins.
   - Supports event filter via mixins.
 - **Robust**
-  - Supports nested event. During handling an event a listener can safely dispatch event, append/prepend/insert/remove other listeners.
-  - Thread safety. Supports multiple threading.
+  - Supports nested event. During the process of handling an event, a listener can safely dispatch event and append/prepend/insert/remove other listeners.
+  - Thread safety. Supports multi-threading.
   - Exception safety. Most operations guarantee strong exception safety.
   - Well tested. Backed by unit tests.
 - **Fast**
@@ -18,8 +18,8 @@ eventpp is a C++ event library that provides tools that allow your application c
   - The CallbackList can invoke 100M callbacks in 1 second (100K callbacks per millisecond).
   - The CallbackList can add/remove 5M callbacks in 1 second (5K callbacks per millisecond).
 - **Flexible and easy to use**
-  - The listeners and events can be any type, no need to inherit from any base class.
-  - Header only, no source file, no need to build. No dependencies on other libraries.
+  - Listeners and events can be of any type and do not need to be inherited from any base class.
+  - Header only, no source file, no need to build. Does not depend on other libraries.
   - Requires C++ 11 (tested with MSVC 2017, MSVC 2015, MinGW (Msys) gcc 7.2, and Ubuntu gcc 5.4).
   - Written in portable and standard C++, no hacks or quirks.
 
@@ -29,7 +29,7 @@ Apache License, Version 2.0
 
 ## Version 0.1.0
 
-eventpp is currently usable and near stable.
+eventpp is currently usable and stable.
 
 ## Source code
 
@@ -123,6 +123,6 @@ Go to folder `tests/build`, then run `make` with different target.
 
 ## Motivations
 
-I (wqking) am a big fan of observer pattern (publish/subscribe pattern), I used such pattern a lot in my code. I either used GCallbackList in my [cpgf library](https://github.com/cpgf/cpgf) which is too simple and not safe (not support multi threading nor nested event), or repeated coding event dispatching mechanism such as I did in my [Gincu game engine](https://github.com/wqking/gincu) (the latest version has be rewritten to use eventpp). Both approaches are neither fun nor robust.  
-Thanking to C++11, now it's quite easy to write a reusable event library with beautiful syntax (it's a nightmare to simulate the variadic template in C++03), so here comes `eventpp`.
+I (wqking) am a big fan of observer pattern (publish/subscribe pattern), and I used this pattern extensively in my code. I either used GCallbackList in my [cpgf library](https://github.com/cpgf/cpgf) which is too simple and unsafe (not support multi-threading or nested events), or repeated coding event dispatching mechanism such as I did in my [Gincu game engine](https://github.com/wqking/gincu) (the latest version has be rewritten to use eventpp). Both or these methods are neither fun nor robust.  
+Thanking to C++11, now it's quite easy to write a reusable event library with beautiful syntax (it's a nightmare to simulate the variadic template in C++03), so here is `eventpp`.
 

From d8c960483e3daad013c186a73557ef00503d9497 Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Sun, 16 Dec 2018 14:49:44 +0800
Subject: [PATCH 16/38] Improved mixin handling in HeterEventDispatcher

---
 include/eventpp/callbacklist.h                |  3 +-
 include/eventpp/eventpolicies.h               | 22 ++------
 include/eventpp/hetereventdispatcher.h        | 52 ++++++++++++++++---
 include/eventpp/internal/eventpolicies_i.h    | 33 ++----------
 .../eventpp/internal/hetereventdispatcher_i.h |  4 ++
 include/eventpp/internal/typeutil_i.h         | 16 ++++++
 tests/unittest/test_heterdispatcher_basic.cpp |  3 +-
 tests/unittest/tutorial_eventdispatcher.cpp   |  5 +-
 8 files changed, 80 insertions(+), 58 deletions(-)

diff --git a/include/eventpp/callbacklist.h b/include/eventpp/callbacklist.h
index 33e7931..9197b1f 100644
--- a/include/eventpp/callbacklist.h
+++ b/include/eventpp/callbacklist.h
@@ -15,6 +15,7 @@
 #define CALLBACKLIST_H_588722158669
 
 #include "eventpolicies.h"
+#include "internal/typeutil_i.h"
 
 #include <atomic>
 #include <condition_variable>
@@ -55,7 +56,7 @@ class CallbackListBase<
 	>::Type;
 
 	using CanContinueInvoking = typename SelectCanContinueInvoking<
-		Policies, HasFunctionCanContinueInvoking<Policies>::value
+		Policies, HasFunctionCanContinueInvoking<Policies, Args...>::value
 	>::Type;
 
 	struct Node;
diff --git a/include/eventpp/eventpolicies.h b/include/eventpp/eventpolicies.h
index 4d61d4a..00fe48f 100644
--- a/include/eventpp/eventpolicies.h
+++ b/include/eventpp/eventpolicies.h
@@ -14,6 +14,8 @@
 #ifndef EVENTOPTIONS_H_730367862613
 #define EVENTOPTIONS_H_730367862613
 
+#include "internal/typeutil_i.h"
+
 #include <mutex>
 #include <atomic>
 #include <condition_variable>
@@ -155,27 +157,9 @@ struct ArgumentPassingExcludeEvent
 
 struct DefaultPolicies
 {
-	/* default types for CallbackList
-	using Callback = std::function<blah, blah>;
-	using Threading = MultipleThreading;
-	*/
-
-	/* default types/implements for EventDispatch and EventQueue
-	template <typename U, typename ...Args>
-	static E getEvent(U && e, const Args &...) {
-		return e;
-	}
-
-	using Callback = std::function<blah, blah>;
-	using Threading = MultipleThreading;
-	using ArgumentPassingMode = ArgumentPassingAutoDetect;
-
-	template <typename Key, typename T>
-	using Map = std::map <Key, T>;
-	*/
 };
 
-template <template <typename> class ...Args>
+template <template <typename> class ...Mixins>
 struct MixinList
 {
 };
diff --git a/include/eventpp/hetereventdispatcher.h b/include/eventpp/hetereventdispatcher.h
index b1e72ad..73a6c0d 100644
--- a/include/eventpp/hetereventdispatcher.h
+++ b/include/eventpp/hetereventdispatcher.h
@@ -14,8 +14,10 @@
 #ifndef HETEREVENTDISPATCHER_H_127766658555
 #define HETEREVENTDISPATCHER_H_127766658555
 
-#include "eventdispatcher.h"
 #include "internal/hetereventdispatcher_i.h"
+#include "eventdispatcher.h"
+#include "mixins/mixinheterfilter.h"
+#include "mixins/mixinfilter.h"
 
 #include <array>
 #include <string>
@@ -31,6 +33,37 @@ namespace eventpp {
 
 namespace internal_ {
 
+template <template <typename> class MixinA, template <typename> class MixinB>
+struct IsSameMixin
+{
+	enum { value = false };
+};
+
+template <template <typename> class MixinA>
+struct IsSameMixin <MixinA, MixinA>
+{
+	enum { value = true };
+};
+
+template <typename MList, template <typename> class ...UnderlyingMixins>
+struct BuildHeterUnderlyingMixinList;
+
+template <template <typename> class First, template <typename> class ...Mixins, template <typename> class ...UnderlyingMixins>
+struct BuildHeterUnderlyingMixinList <MixinList<First, Mixins...>, UnderlyingMixins...>
+{
+	using Type = typename std::conditional<
+		IsSameMixin<First, MixinHeterFilter>::value,
+		typename BuildHeterUnderlyingMixinList<MixinList<Mixins...>, UnderlyingMixins..., MixinFilter>::Type,
+		typename BuildHeterUnderlyingMixinList<MixinList<Mixins...>, UnderlyingMixins..., First>::Type
+	>::type;
+};
+
+template <template <typename> class ...UnderlyingMixins>
+struct BuildHeterUnderlyingMixinList <MixinList<>, UnderlyingMixins...>
+{
+	using Type = MixinList<UnderlyingMixins...>;
+};
+
 template <
 	typename EventType_,
 	typename PrototypeList_,
@@ -50,6 +83,13 @@ class HeterEventDispatcherBase
 		}
 	};
 
+	struct UnderlyingPoliciesType_
+	{
+		using Mixins = typename BuildHeterUnderlyingMixinList<
+			typename internal_::SelectMixins<Policies_, internal_::HasTypeMixins<Policies_>::value >::Type
+		>::Type;
+	};
+
 	class HomoDispatcherTypeBase
 	{
 	public:
@@ -58,10 +98,10 @@ class HeterEventDispatcherBase
 	};
 
 	template <typename T>
-	class HomoDispatcherType : public EventDispatcher<EventType_, T, Policies_>, public HomoDispatcherTypeBase
+	class HomoDispatcherType : public EventDispatcher<EventType_, T, UnderlyingPoliciesType_>, public HomoDispatcherTypeBase
 	{
 	private:
-		using super = EventDispatcher<EventType_, T, Policies_>;
+		using super = EventDispatcher<EventType_, T, UnderlyingPoliciesType_>;
 
 	public:
 		virtual bool doRemoveListener(const EventType_ & event, const Handle_ & handle) override {
@@ -217,9 +257,9 @@ class HeterEventDispatcherBase
 	mutable Mutex dispatcherListMutex;
 };
 
-
 } //namespace internal_
 
+
 template <
 	typename Event_,
 	typename PrototypeList_,
@@ -227,13 +267,13 @@ template <
 >
 class HeterEventDispatcher : public internal_::InheritMixins<
 		internal_::HeterEventDispatcherBase<Event_, PrototypeList_, Policies_, void>,
-		typename internal_::SelectHeterMixins<Policies_, internal_::HasTypeHeterMixins<Policies_>::value >::Type
+		typename internal_::SelectMixins<Policies_, internal_::HasTypeMixins<Policies_>::value >::Type
 	>::Type, public TagEventDispatcher
 {
 private:
 	using super = typename internal_::InheritMixins<
 		internal_::HeterEventDispatcherBase<Event_, PrototypeList_, Policies_, void>,
-		typename internal_::SelectHeterMixins<Policies_, internal_::HasTypeHeterMixins<Policies_>::value >::Type
+		typename internal_::SelectMixins<Policies_, internal_::HasTypeMixins<Policies_>::value >::Type
 	>::Type;
 
 public:
diff --git a/include/eventpp/internal/eventpolicies_i.h b/include/eventpp/internal/eventpolicies_i.h
index ca04522..d1f2aa5 100644
--- a/include/eventpp/internal/eventpolicies_i.h
+++ b/include/eventpp/internal/eventpolicies_i.h
@@ -1,3 +1,5 @@
+// Don't include this header, include eventpolicies.h instead
+
 namespace internal_ {
 
 template <typename T>
@@ -56,10 +58,10 @@ template <typename T, typename Key, bool> struct SelectGetEvent;
 template <typename T, typename Key> struct SelectGetEvent<T, Key, true> { using Type = T; };
 template <typename T, typename Key> struct SelectGetEvent<T, Key, false> { using Type = DefaultGetEvent<Key>; };
 
-template <typename T>
+template <typename T, typename ...Args>
 struct HasFunctionCanContinueInvoking
 {
-	template <typename C> static std::true_type test(decltype(&C::canContinueInvoking) *) ;
+	template <typename C> static std::true_type test(decltype(C::canContinueInvoking(std::declval<Args>()...)) *) ;
 	template <typename C> static std::false_type test(...);    
 
 	enum { value = !! decltype(test<T>(0))() };
@@ -122,19 +124,6 @@ template <typename T> struct SelectMixins <T, true> { using Type = typename T::M
 template <typename T> struct SelectMixins <T, false> { using Type = MixinList<>; };
 
 
-template <typename T>
-struct HasTypeHeterMixins
-{
-	template <typename C> static std::true_type test(typename C::HeterMixins *) ;
-	template <typename C> static std::false_type test(...);    
-
-	enum { value = !! decltype(test<T>(0))() };
-};
-template <typename T, bool> struct SelectHeterMixins;
-template <typename T> struct SelectHeterMixins <T, true> { using Type = typename T::HeterMixins; };
-template <typename T> struct SelectHeterMixins <T, false> { using Type = MixinList<>; };
-
-
 template <typename Root, typename TList>
 struct InheritMixins;
 
@@ -189,19 +178,5 @@ struct HasFunctionMixinBeforeDispatch
 	enum { value = !! decltype(test<T>(0))() };
 };
 
-template <typename F, typename ...Args>
-struct CanInvoke
-{
-	template <typename U, typename ...X>
-	static auto invoke(int) -> decltype(std::declval<U>()(std::declval<X>()...), std::true_type());
-
-	template <typename U, typename ...X>
-	static auto invoke(...) -> std::false_type;
-
-	enum {
-		value = !! decltype(invoke<F, Args...>(0))()
-	};
-};
-
 
 } //namespace internal_
diff --git a/include/eventpp/internal/hetereventdispatcher_i.h b/include/eventpp/internal/hetereventdispatcher_i.h
index 7cd63aa..52aa1ca 100644
--- a/include/eventpp/internal/hetereventdispatcher_i.h
+++ b/include/eventpp/internal/hetereventdispatcher_i.h
@@ -14,6 +14,10 @@
 #ifndef HETEREVENTDISPATCHER_I_H
 #define HETEREVENTDISPATCHER_I_H
 
+#include "typeutil_i.h"
+
+#include <tuple>
+
 namespace eventpp {
 
 namespace internal_ {
diff --git a/include/eventpp/internal/typeutil_i.h b/include/eventpp/internal/typeutil_i.h
index 1a1e57d..76a2c55 100644
--- a/include/eventpp/internal/typeutil_i.h
+++ b/include/eventpp/internal/typeutil_i.h
@@ -14,6 +14,8 @@
 #ifndef TYPEUTIL_I_H
 #define TYPEUTIL_I_H
 
+#include <utility>
+
 namespace eventpp {
 
 namespace internal_ {
@@ -70,6 +72,20 @@ auto intToConstant(const int index, C && c, Args && ...args)
 	return IntToConstantHelper<0, M>::find(index, std::forward<C>(c), std::forward<Args>(args)...);
 }
 
+template <typename F, typename ...Args>
+struct CanInvoke
+{
+	template <typename U, typename ...X>
+	static auto invoke(int) -> decltype(std::declval<U>()(std::declval<X>()...), std::true_type());
+
+	template <typename U, typename ...X>
+	static auto invoke(...) -> std::false_type;
+
+	enum {
+		value = !! decltype(invoke<F, Args...>(0))()
+	};
+};
+
 
 } //namespace internal_
 
diff --git a/tests/unittest/test_heterdispatcher_basic.cpp b/tests/unittest/test_heterdispatcher_basic.cpp
index b54232e..6a03f51 100644
--- a/tests/unittest/test_heterdispatcher_basic.cpp
+++ b/tests/unittest/test_heterdispatcher_basic.cpp
@@ -56,8 +56,7 @@ TEST_CASE("xxx HeterEventDispatcher, 1")
 TEST_CASE("xxx HeterEventDispatcher, event filter")
 {
 	struct MyPolicies {
-		using Mixins = eventpp::MixinList<eventpp::MixinFilter>;
-		using HeterMixins = eventpp::MixinList<eventpp::MixinHeterFilter>;
+		using Mixins = eventpp::MixinList<eventpp::MixinHeterFilter>;
 	};
 	using ED = eventpp::HeterEventDispatcher<int, std::tuple<void (int, int), void ()>, MyPolicies>;
 	ED dispatcher;
diff --git a/tests/unittest/tutorial_eventdispatcher.cpp b/tests/unittest/tutorial_eventdispatcher.cpp
index c8c47ee..ec55487 100644
--- a/tests/unittest/tutorial_eventdispatcher.cpp
+++ b/tests/unittest/tutorial_eventdispatcher.cpp
@@ -139,7 +139,10 @@ struct Tutor4MyEventPolicies
 		return e.type;
 	}
 
-	static bool canContinueInvoking(const Tutor4MyEvent & e) {
+	// E is Tutor4MyEvent and canContinueInvoking doesn't need to be template.
+	// We make it template to show canContinueInvoking can be templated member.
+	template <typename E>
+	static bool canContinueInvoking(const E & e) {
 		return ! e.canceled;
 	}
 };

From 5a3de87a087031ad81b7cf1535f316c7d750c1f2 Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Sun, 23 Dec 2018 09:15:14 +0800
Subject: [PATCH 17/38] Improved template code

---
 include/eventpp/internal/eventpolicies_i.h | 22 +++++++---------------
 1 file changed, 7 insertions(+), 15 deletions(-)

diff --git a/include/eventpp/internal/eventpolicies_i.h b/include/eventpp/internal/eventpolicies_i.h
index d1f2aa5..a49b1e2 100644
--- a/include/eventpp/internal/eventpolicies_i.h
+++ b/include/eventpp/internal/eventpolicies_i.h
@@ -10,8 +10,7 @@ struct HasTypeArgumentPassingMode
 
 	enum { value = !! decltype(test<T>(0))() };
 };
-template <typename T, bool> struct SelectArgumentPassingMode;
-template <typename T> struct SelectArgumentPassingMode <T, true> { using Type = typename T::ArgumentPassingMode; };
+template <typename T, bool> struct SelectArgumentPassingMode { using Type = typename T::ArgumentPassingMode; };
 template <typename T> struct SelectArgumentPassingMode <T, false> { using Type = ArgumentPassingAutoDetect; };
 
 template <typename T>
@@ -22,8 +21,7 @@ struct HasTypeThreading
 
 	enum { value = !! decltype(test<T>(0))() };
 };
-template <typename T, bool> struct SelectThreading;
-template <typename T> struct SelectThreading <T, true> { using Type = typename T::Threading; };
+template <typename T, bool> struct SelectThreading { using Type = typename T::Threading; };
 template <typename T> struct SelectThreading <T, false> { using Type = MultipleThreading; };
 
 template <typename T>
@@ -34,8 +32,7 @@ struct HasTypeCallback
 
 	enum { value = !! decltype(test<T>(0))() };
 };
-template <typename T, bool, typename D> struct SelectCallback;
-template <typename T, typename D> struct SelectCallback<T, true, D> { using Type = typename T::Callback; };
+template <typename T, bool, typename D> struct SelectCallback { using Type = typename T::Callback; };
 template <typename T, typename D> struct SelectCallback<T, false, D> { using Type = D; };
 
 template <typename T, typename ...Args>
@@ -54,8 +51,7 @@ struct DefaultGetEvent
 		return e;
 	}
 };
-template <typename T, typename Key, bool> struct SelectGetEvent;
-template <typename T, typename Key> struct SelectGetEvent<T, Key, true> { using Type = T; };
+template <typename T, typename Key, bool> struct SelectGetEvent { using Type = T; };
 template <typename T, typename Key> struct SelectGetEvent<T, Key, false> { using Type = DefaultGetEvent<Key>; };
 
 template <typename T, typename ...Args>
@@ -73,8 +69,7 @@ struct DefaultCanContinueInvoking
 		return true;
 	}
 };
-template <typename T, bool> struct SelectCanContinueInvoking;
-template <typename T> struct SelectCanContinueInvoking<T, true> { using Type = T; };
+template <typename T, bool> struct SelectCanContinueInvoking { using Type = T; };
 template <typename T> struct SelectCanContinueInvoking<T, false> { using Type = DefaultCanContinueInvoking; };
 
 template <typename T>
@@ -95,9 +90,7 @@ class HasHash
 	enum { value = !! decltype(test<T>(0))() };
 };
 template <typename Key, typename Value, typename T, bool>
-struct SelectMap;
-template <typename Key, typename Value, typename T>
-struct SelectMap<Key, Value, T, true>
+struct SelectMap
 {
 	using Type = typename T::template Map<Key, Value>;
 };
@@ -119,8 +112,7 @@ struct HasTypeMixins
 
 	enum { value = !! decltype(test<T>(0))() };
 };
-template <typename T, bool> struct SelectMixins;
-template <typename T> struct SelectMixins <T, true> { using Type = typename T::Mixins; };
+template <typename T, bool> struct SelectMixins { using Type = typename T::Mixins; };
 template <typename T> struct SelectMixins <T, false> { using Type = MixinList<>; };
 
 

From 901070bf7ca75f4c70d279981b905540cd3c6f90 Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Sat, 29 Dec 2018 22:31:41 +0800
Subject: [PATCH 18/38] Added ArgumentPassingMode to HeterEventDispatcher.
 Improved HeterEventQueue.

---
 include/eventpp/eventdispatcher.h             |  15 +-
 include/eventpp/eventqueue.h                  |   2 +-
 include/eventpp/hetereventdispatcher.h        |  58 +++--
 include/eventpp/hetereventqueue.h             | 245 ++++++++++++------
 include/eventpp/internal/eventpolicies_i.h    |   4 +-
 .../eventpp/internal/hetereventdispatcher_i.h |  79 ++++--
 include/eventpp/internal/typeutil_i.h         |  32 +++
 include/eventpp/mixins/mixinheterfilter.h     |   6 +-
 tests/unittest/test_heterdispatcher_basic.cpp |  19 +-
 tests/unittest/test_heterqueue_basic.cpp      |  56 +++-
 10 files changed, 387 insertions(+), 129 deletions(-)

diff --git a/include/eventpp/eventdispatcher.h b/include/eventpp/eventdispatcher.h
index dee70ac..4b7bcd7 100644
--- a/include/eventpp/eventdispatcher.h
+++ b/include/eventpp/eventdispatcher.h
@@ -65,7 +65,8 @@ class EventDispatcherBase <
 
 	using ArgumentPassingMode = typename SelectArgumentPassingMode<
 		Policies_,
-		HasTypeArgumentPassingMode<Policies_>::value
+		HasTypeArgumentPassingMode<Policies_>::value,
+		ArgumentPassingAutoDetect
 	>::Type;
 
 	using Callback_ = typename SelectCallback<
@@ -195,8 +196,8 @@ class EventDispatcherBase <
 		using GetEvent = typename SelectGetEvent<Policies_, EventType_, HasFunctionGetEvent<Policies_, Args...>::value>::Type;
 
 		// can't std::forward<Args>(args) in GetEvent::getEvent because the pass by value arguments will be moved to getEvent
-		// then the other std::forward<Args>(args) to doDispatch will get empty values.
-		doDispatch(
+		// then the other std::forward<Args>(args) to directDispatch will get empty values.
+		directDispatch(
 			GetEvent::getEvent(args...),
 			std::forward<Args>(args)...
 		);
@@ -209,14 +210,15 @@ class EventDispatcherBase <
 
 		using GetEvent = typename SelectGetEvent<Policies_, EventType_, HasFunctionGetEvent<Policies_, T &&, Args...>::value>::Type;
 
-		doDispatch(
+		directDispatch(
 			GetEvent::getEvent(std::forward<T>(first), args...),
 			std::forward<Args>(args)...
 		);
 	}
 
-protected:
-	void doDispatch(const Event & e, Args ...args) const
+	// Bypass any getEvent policy. The first argument is the event type.
+	// Most used for internal purpose.
+	void directDispatch(const Event & e, Args ...args) const
 	{
 		if(! internal_::ForEachMixins<MixinRoot, Mixins, DoMixinBeforeDispatch>::forEach(
 			this, typename std::add_lvalue_reference<Args>::type(args)...)) {
@@ -229,6 +231,7 @@ class EventDispatcherBase <
 		}
 	}
 
+protected:
 	const CallbackList_ * doFindCallableList(const Event & e) const
 	{
 		return doFindCallableListHelper(this, e);
diff --git a/include/eventpp/eventqueue.h b/include/eventpp/eventqueue.h
index 8012532..fe82506 100644
--- a/include/eventpp/eventqueue.h
+++ b/include/eventpp/eventqueue.h
@@ -405,7 +405,7 @@ class EventQueueBase <
 	template <typename T, size_t ...Indexes>
 	void doDispatchQueuedEvent(T && item, IndexSequence<Indexes...>)
 	{
-		this->doDispatch(item.event, std::get<Indexes>(item.arguments)...);
+		this->directDispatch(item.event, std::get<Indexes>(item.arguments)...);
 	}
 
 	template <typename F, typename T, size_t ...Indexes>
diff --git a/include/eventpp/hetereventdispatcher.h b/include/eventpp/hetereventdispatcher.h
index 73a6c0d..4cf23aa 100644
--- a/include/eventpp/hetereventdispatcher.h
+++ b/include/eventpp/hetereventdispatcher.h
@@ -83,6 +83,15 @@ class HeterEventDispatcherBase
 		}
 	};
 
+	using ArgumentPassingMode = typename SelectArgumentPassingMode<
+		Policies_,
+		HasTypeArgumentPassingMode<Policies_>::value,
+		ArgumentPassingExcludeEvent
+	>::Type;
+
+	static_assert(! std::is_same<ArgumentPassingMode, ArgumentPassingAutoDetect>::value,
+		"ArgumentPassingMode can't be ArgumentPassingAutoDetect in heterogeneous dispatcher.");
+
 	struct UnderlyingPoliciesType_
 	{
 		using Mixins = typename BuildHeterUnderlyingMixinList<
@@ -117,25 +126,16 @@ class HeterEventDispatcherBase
 		}
 	};
 
-	using ThisType = HeterEventDispatcherBase<
-		EventType_,
-		PrototypeList_,
-		Policies_,
-		MixinRoot_
-	>;
-
 	using Policies = Policies_;
 	using Threading = typename SelectThreading<Policies, HasTypeThreading<Policies>::value>::Type;
 
-	// Disable ArgumentPassingMode explicitly
-	static_assert(! HasTypeArgumentPassingMode<Policies>::value, "Policies can't have ArgumentPassingMode in heterogeneous dispatcher.");
-
 	using PrototypeList = PrototypeList_;
 
 public:
 	using Handle = Handle_;
 	using Event = EventType_;
 	using Mutex = typename Threading::Mutex;
+
 public:
 	HeterEventDispatcherBase()
 		:
@@ -188,7 +188,7 @@ class HeterEventDispatcherBase
 		using PrototypeInfo = FindPrototypeByCallable<PrototypeList_, C>;
 		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
 
-		auto dispatcher = doFindDispatcher<PrototypeInfo>();
+		auto dispatcher = doGetDispatcher<PrototypeInfo>();
 		return Handle {
 			PrototypeInfo::index,
 			dispatcher->appendListener(event, callback)
@@ -201,7 +201,7 @@ class HeterEventDispatcherBase
 		using PrototypeInfo = FindPrototypeByCallable<PrototypeList_, C>;
 		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
 
-		auto dispatcher = doFindDispatcher<PrototypeInfo>();
+		auto dispatcher = doGetDispatcher<PrototypeInfo>();
 		return Handle {
 			PrototypeInfo::index,
 			dispatcher->prependListener(event, callback)
@@ -220,17 +220,35 @@ class HeterEventDispatcherBase
 
 	template <typename T, typename ...Args>
 	void dispatch(T && first, Args ...args) const
+	{
+		doDispatch<ArgumentPassingMode>(std::forward<T>(first), std::forward<Args>(args)...);
+	}
+
+protected:
+	template <typename ArgumentMode, typename T, typename ...Args>
+	auto doDispatch(T && first, Args ...args) const
+		-> typename std::enable_if<std::is_same<ArgumentMode, ArgumentPassingIncludeEvent>::value>::type
+	{
+		using PrototypeInfo = FindPrototypeByArgs<PrototypeList_, T, Args...>;
+		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
+
+		auto dispatcher = doGetDispatcher<PrototypeInfo>();
+		dispatcher->dispatch(std::forward<T>(first), std::forward<T>(first), std::forward<Args>(args)...);
+	}
+
+	template <typename ArgumentMode, typename T, typename ...Args>
+	auto doDispatch(T && first, Args ...args) const
+		-> typename std::enable_if<std::is_same<ArgumentMode, ArgumentPassingExcludeEvent>::value>::type
 	{
 		using PrototypeInfo = FindPrototypeByArgs<PrototypeList_, Args...>;
 		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
 
-		auto dispatcher = doFindDispatcher<PrototypeInfo>();
+		auto dispatcher = doGetDispatcher<PrototypeInfo>();
 		dispatcher->dispatch(std::forward<T>(first), std::forward<Args>(args)...);
 	}
 
-protected:
 	template <typename PrototypeInfo>
-	auto doFindDispatcher() const
+	auto doGetDispatcher() const
 		-> std::shared_ptr<HomoDispatcherType<typename PrototypeInfo::Prototype> >
 	{
 		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
@@ -246,7 +264,15 @@ class HeterEventDispatcherBase
 		return std::static_pointer_cast<HomoDispatcherType<typename PrototypeInfo::Prototype> >(dispatcherList[PrototypeInfo::index]);
 	}
 
-	// Used by mixins
+	template <typename PrototypeInfo>
+	auto doFindDispatcher() const
+		-> std::shared_ptr<HomoDispatcherType<typename PrototypeInfo::Prototype> >
+	{
+		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
+
+		return std::static_pointer_cast<HomoDispatcherType<typename PrototypeInfo::Prototype> >(dispatcherList[PrototypeInfo::index]);
+	}
+
 	std::shared_ptr<HomoDispatcherTypeBase> doGetDispatcherAt(const int index) const
 	{
 		return dispatcherList[index];
diff --git a/include/eventpp/hetereventqueue.h b/include/eventpp/hetereventqueue.h
index 3264874..56f7adb 100644
--- a/include/eventpp/hetereventqueue.h
+++ b/include/eventpp/hetereventqueue.h
@@ -60,11 +60,12 @@ class HeterEventQueueBase : public HeterEventDispatcherBase<
 
 	struct QueuedItemBase
 	{
-		QueuedItemBase(const EventType_ & event, const ItemDispatcher dispatcher)
-			: event(event), dispatcher(dispatcher)
+		QueuedItemBase(const int callableIndex, const EventType_ & event, const ItemDispatcher dispatcher)
+			: callableIndex(callableIndex), event(event), dispatcher(dispatcher)
 		{
 		}
 
+		int callableIndex;
 		EventType_ event;
 		ItemDispatcher dispatcher;
 	};
@@ -72,8 +73,8 @@ class HeterEventQueueBase : public HeterEventDispatcherBase<
 	template <typename T>
 	struct QueuedItem : public QueuedItemBase
 	{
-		QueuedItem(const EventType_ & event, const ItemDispatcher dispatcher, T && arguments)
-			: QueuedItemBase(event, dispatcher), arguments(std::move(arguments))
+		QueuedItem(const int callableIndex, const EventType_ & event, const ItemDispatcher dispatcher, T && arguments)
+			: QueuedItemBase(callableIndex, event, dispatcher), arguments(std::move(arguments))
 		{
 		}
 
@@ -87,31 +88,55 @@ class HeterEventQueueBase : public HeterEventDispatcherBase<
 
 	using BufferedItemList = std::list<BufferedQueuedItem>;
 
+	using PrototypeList = typename super::PrototypeList;
+
+	using ArgumentPassingMode = typename super::ArgumentPassingMode;
+
 public:
 	using super::Event;
 	using super::Handle;
 	using Mutex = typename super::Mutex;
 
 public:
-	template <typename T, typename ...Args>
-	void enqueue(T && first, Args ...args)
+	HeterEventQueueBase()
+		:
+		super(),
+		queueListConditionVariable(),
+		queueEmptyCounter(0),
+		queueNotifyCounter(0),
+		queueListMutex(),
+		queueList(),
+		freeListMutex(),
+		freeList()
 	{
-		using GetEvent = typename SelectGetEvent<Policies_, EventType_, HasFunctionGetEvent<Policies_, T &&, Args...>::value>::Type;
-		using PrototypeInfo = FindPrototypeByArgs<PrototypeList_, Args...>;
-		using QueuedItemType = QueuedItem<typename PrototypeInfo::ArgsTuple>;
+	}
 
-		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
-		static_assert(std::tuple_size<typename PrototypeInfo::ArgsTuple>::value == sizeof...(Args), "Arguments count mismatch.");
+	HeterEventQueueBase(const HeterEventQueueBase & other)
+		: super(other)
+	{
+	}
 
-		doEnqueue(QueuedItemType(
-			GetEvent::getEvent(std::forward<T>(first), args...),
-			&HeterEventQueueBase::doDispatchItem<typename PrototypeInfo::ArgsTuple>,
-			typename PrototypeInfo::ArgsTuple(std::forward<Args>(args)...)
-		));
+	HeterEventQueueBase(HeterEventQueueBase && other) noexcept
+		: super(std::move(other))
+	{
+	}
 
-		if(doCanProcess()) {
-			queueListConditionVariable.notify_one();
-		}
+	HeterEventQueueBase & operator = (const HeterEventQueueBase & other)
+	{
+		super::operator = (other);
+		return *this;
+	}
+
+	HeterEventQueueBase & operator = (HeterEventQueueBase && other) noexcept
+	{
+		super::operator = (std::move(other));
+		return *this;
+	}
+
+	template <typename T, typename ...Args>
+	void enqueue(T && first, Args ...args)
+	{
+		doEnqueue<ArgumentPassingMode>(std::forward<T>(first), std::forward<Args>(args)...);
 	}
 
 	bool empty() const
@@ -179,56 +204,17 @@ class HeterEventQueueBase : public HeterEventDispatcherBase<
 
 		return false;
 	}
-/*
+
 	template <typename F>
 	bool processIf(F && func)
 	{
-		if(! queueList.empty()) {
-			BufferedItemList tempList;
-			BufferedItemList idleList;
-
-			// Use a counter to tell the queue list is not empty during processing
-			// even though queueList is swapped to empty.
-			CounterGuard<decltype(queueEmptyCounter)> counterGuard(queueEmptyCounter);
-
-			{
-				std::lock_guard<Mutex> queueListLock(queueListMutex);
-				std::swap(queueList, tempList);
-			}
-
-			if(! tempList.empty()) {
-				for(auto it = tempList.begin(); it != tempList.end(); ++it) {
-					if(doInvokeFuncWithQueuedEvent(
-						func,
-						it->template get<QueuedItemBase>(),
-						typename MakeIndexSequence<sizeof...(Args)>::Type())
-						) {
-						doDispatchQueuedEvent(item.template get<QueuedItemBase>());
-						it->clear();
-
-						auto tempIt = it;
-						--it;
-						idleList.splice(idleList.end(), tempList, tempIt);
-					}
-				}
-
-				if (! tempList.empty()) {
-					std::lock_guard<Mutex> queueListLock(queueListMutex);
-					queueList.splice(queueList.begin(), tempList);
-				}
-
-				if(! idleList.empty()) {
-					std::lock_guard<Mutex> queueListLock(freeListMutex);
-					freeList.splice(freeList.end(), idleList);
-
-					return true;
-				}
-			}
+		if(queueList.empty()) {
+			return false;
 		}
 
-		return false;
+		using PrototypeInfo = FindPrototypeByCallable<PrototypeList, F>;
+		return doProcessIf<PrototypeInfo>(std::forward<F>(func));
 	}
-*/
 
 	void wait() const
 	{
@@ -265,38 +251,149 @@ class HeterEventQueueBase : public HeterEventDispatcherBase<
 		item.dispatcher(this, item);
 	}
 
-	template <typename ArgsTuple>
+	template <typename PrototypeInfo>
 	static void doDispatchItem(const HeterEventQueueBase * self, const QueuedItemBase & baseItem)
 	{
-		const QueuedItem<ArgsTuple> & item = static_cast<const QueuedItem<ArgsTuple> &>(baseItem);
-		self->doDispatchQueuedItem(
+		const auto & item = static_cast<const QueuedItem<typename PrototypeInfo::ArgsTuple> &>(baseItem);
+		self->doDispatchQueuedItem<PrototypeInfo>(
 			item,
-			typename MakeIndexSequence<std::tuple_size<ArgsTuple>::value>::Type()
+			typename MakeIndexSequence<std::tuple_size<typename PrototypeInfo::ArgsTuple>::value>::Type()
 		);
 	}
 
-	template <typename T, size_t ...Indexes>
+	template <typename PrototypeInfo, typename T, size_t ...Indexes>
 	void doDispatchQueuedItem(T && item, IndexSequence<Indexes...>) const
 	{
-		this->dispatch(item.event, std::get<Indexes>(item.arguments)...);
+		auto dispatcher = this->template doGetDispatcher<PrototypeInfo>();
+		dispatcher->directDispatch(item.event, std::get<Indexes>(item.arguments)...);
+	}
+
+	template <typename PrototypeInfo, typename F>
+	auto doProcessIf(F && func)
+		-> typename std::enable_if<(PrototypeInfo::index >= 0), bool>::type
+	{
+		BufferedItemList tempList;
+		BufferedItemList idleList;
+
+		// Use a counter to tell the queue list is not empty during processing
+		// even though queueList is swapped to empty.
+		CounterGuard<decltype(queueEmptyCounter)> counterGuard(queueEmptyCounter);
+
+		{
+			std::lock_guard<Mutex> queueListLock(queueListMutex);
+			std::swap(queueList, tempList);
+		}
+
+		if(! tempList.empty()) {
+			for(auto it = tempList.begin(); it != tempList.end(); ++it) {
+				using ArgsTuple = typename PrototypeInfo::ArgsTuple;
+				auto item = it->template get<QueuedItem<ArgsTuple> >();
+
+				if(item.callableIndex != PrototypeInfo::index) {
+					continue;
+				}
+				if(doInvokeFuncWithQueuedEvent(
+					func,
+					item,
+					typename MakeIndexSequence<std::tuple_size<ArgsTuple>::value>::Type())
+					) {
+					doDispatchQueuedEvent(item);
+					it->clear();
+
+					auto tempIt = it;
+					--it;
+					idleList.splice(idleList.end(), tempList, tempIt);
+				}
+			}
+
+			if (! tempList.empty()) {
+				std::lock_guard<Mutex> queueListLock(queueListMutex);
+				queueList.splice(queueList.begin(), tempList);
+			}
+
+			if(! idleList.empty()) {
+				std::lock_guard<Mutex> queueListLock(freeListMutex);
+				freeList.splice(freeList.end(), idleList);
+
+				return true;
+			}
+		}
+
+		using NextPrototypeInfo = FindPrototypeByCallableFromIndex<PrototypeInfo::index + 1, PrototypeList, F>;
+		if(doProcessIf<NextPrototypeInfo>(std::forward<F>(func))) {
+			return true;
+		}
+
+		return false;
+	}
+
+	template <typename PrototypeInfo, typename F>
+	auto doProcessIf(F && func)
+		-> typename std::enable_if<(PrototypeInfo::index < 0), bool>::type
+	{
+		return false;
 	}
 
-	/*
 	template <typename F, typename T, size_t ...Indexes>
 	bool doInvokeFuncWithQueuedEvent(F && func, T && item, IndexSequence<Indexes...>) const
 	{
-		return doInvokeFuncWithQueuedEventHelper(std::forward<F>(func), item.event, std::get<Indexes>(item.arguments)...);
+		return doInvokeFuncWithQueuedEventHelper(std::forward<F>(func), std::get<Indexes>(item.arguments)...);
 	}
 
 	template <typename F, typename ...Args>
-	bool doInvokeFuncWithQueuedEventHelper(F && func, const typename super::Event & e, Args ...args) const
+	bool doInvokeFuncWithQueuedEventHelper(F && func, Args ...args) const
 	{
 		return func(std::forward<Args>(args)...);
 	}
-	*/
+
+	template <typename ArgumentMode, typename T, typename ...Args>
+	auto doEnqueue(T && first, Args ...args)
+		-> typename std::enable_if<std::is_same<ArgumentMode, ArgumentPassingIncludeEvent>::value>::type
+	{
+		using GetEvent = typename SelectGetEvent<Policies_, EventType_, HasFunctionGetEvent<Policies_, T &&, Args...>::value>::Type;
+		using PrototypeInfo = FindPrototypeByArgs<PrototypeList_, T, Args...>;
+		using QueuedItemType = QueuedItem<typename PrototypeInfo::ArgsTuple>;
+
+		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
+		static_assert(std::tuple_size<typename PrototypeInfo::ArgsTuple>::value == 1 + sizeof...(Args), "Arguments count mismatch.");
+
+		doEnqueueItem(QueuedItemType(
+			PrototypeInfo::index,
+			GetEvent::getEvent(std::forward<T>(first), args...),
+			&HeterEventQueueBase::doDispatchItem<PrototypeInfo>,
+			typename PrototypeInfo::ArgsTuple(std::forward<T>(first), std::forward<Args>(args)...)
+		));
+
+		if(doCanProcess()) {
+			queueListConditionVariable.notify_one();
+		}
+	}
+
+	template <typename ArgumentMode, typename T, typename ...Args>
+	auto doEnqueue(T && first, Args ...args)
+		-> typename std::enable_if<std::is_same<ArgumentMode, ArgumentPassingExcludeEvent>::value>::type
+	{
+		using GetEvent = typename SelectGetEvent<Policies_, EventType_, HasFunctionGetEvent<Policies_, T &&, Args...>::value>::Type;
+		using PrototypeInfo = FindPrototypeByArgs<PrototypeList_, Args...>;
+		using QueuedItemType = QueuedItem<typename PrototypeInfo::ArgsTuple>;
+
+		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
+		static_assert(std::tuple_size<typename PrototypeInfo::ArgsTuple>::value == sizeof...(Args), "Arguments count mismatch.");
+
+		doEnqueueItem(QueuedItemType(
+			PrototypeInfo::index,
+			GetEvent::getEvent(std::forward<T>(first), args...),
+			&HeterEventQueueBase::doDispatchItem<PrototypeInfo>,
+			typename PrototypeInfo::ArgsTuple(std::forward<Args>(args)...)
+		));
+
+		if(doCanProcess()) {
+			queueListConditionVariable.notify_one();
+		}
+	}
 
 	template <typename T>
-	void doEnqueue(T && item)
+	void doEnqueueItem(T && item)
 	{
 		BufferedItemList tempList;
 		if(! freeList.empty()) {
diff --git a/include/eventpp/internal/eventpolicies_i.h b/include/eventpp/internal/eventpolicies_i.h
index a49b1e2..82f71f3 100644
--- a/include/eventpp/internal/eventpolicies_i.h
+++ b/include/eventpp/internal/eventpolicies_i.h
@@ -10,8 +10,8 @@ struct HasTypeArgumentPassingMode
 
 	enum { value = !! decltype(test<T>(0))() };
 };
-template <typename T, bool> struct SelectArgumentPassingMode { using Type = typename T::ArgumentPassingMode; };
-template <typename T> struct SelectArgumentPassingMode <T, false> { using Type = ArgumentPassingAutoDetect; };
+template <typename T, bool, typename Default> struct SelectArgumentPassingMode { using Type = typename T::ArgumentPassingMode; };
+template <typename T, typename Default> struct SelectArgumentPassingMode <T, false, Default> { using Type = Default; };
 
 template <typename T>
 struct HasTypeThreading
diff --git a/include/eventpp/internal/hetereventdispatcher_i.h b/include/eventpp/internal/hetereventdispatcher_i.h
index 52aa1ca..adb3c17 100644
--- a/include/eventpp/internal/hetereventdispatcher_i.h
+++ b/include/eventpp/internal/hetereventdispatcher_i.h
@@ -22,35 +22,76 @@ namespace eventpp {
 
 namespace internal_ {
 
-template <int N, typename PrototypeList_, typename Callable>
-struct FindPrototypeByCallableHelper;
+template <typename T>
+struct FindPrototypeDefaultArgTransformer
+{
+	using type = T;
+};
 
-template <int N, typename RT, typename ...Args, typename ...Others, typename Callable>
-struct FindPrototypeByCallableHelper <N, std::tuple<RT (Args...), Others...>, Callable>
+template <
+	int N,
+	typename PrototypeList_,
+	typename Callable,
+	template <typename> class ArgTransformer = FindPrototypeDefaultArgTransformer,
+	int M = std::tuple_size<PrototypeList_>::value,
+	typename Enabled = void
+>
+struct FindPrototypeByCallableFromIndex;
+
+template <
+	int N,
+	typename RT,
+	typename ...Args,
+	typename ...Others,
+	typename Callable,
+	template <typename> class ArgTransformer,
+	int M
+>
+struct FindPrototypeByCallableFromIndex <
+	N,
+	std::tuple<RT (Args...), Others...>,
+	Callable,
+	ArgTransformer,
+	M,
+	typename std::enable_if<(N < M)>::type
+>
 {
-	enum { canInvoke = CanInvoke<Callable, Args...>::value };
+	enum { canInvoke = CanInvoke<Callable, typename ArgTransformer<Args>::type...>::value };
 
 	using Prototype = typename std::conditional<
 		canInvoke,
 		RT (Args...),
-		typename FindPrototypeByCallableHelper<N + 1, std::tuple<Others...>, Callable>::Prototype
+		typename FindPrototypeByCallableFromIndex<N + 1, std::tuple<Others...>, Callable, ArgTransformer, M>::Prototype
 	>::type;
 
 	using ArgsTuple = typename std::conditional<
 		canInvoke,
 		std::tuple<typename std::remove_cv<typename std::remove_reference<Args>::type>::type...>,
-		typename FindPrototypeByCallableHelper<N + 1, std::tuple<Others...>, Callable>::ArgsTuple
+		typename FindPrototypeByCallableFromIndex<N + 1, std::tuple<Others...>, Callable, ArgTransformer, M>::ArgsTuple
 	>::type;
 
 	enum {
 		index = canInvoke
 			? N
-			: FindPrototypeByCallableHelper<N + 1, std::tuple<Others...>, Callable>::index
+			: FindPrototypeByCallableFromIndex<N + 1, std::tuple<Others...>, Callable, ArgTransformer, M>::index
 	};
 };
 
-template <int N, typename Callable>
-struct FindPrototypeByCallableHelper <N, std::tuple<>, Callable>
+template <
+	int N,
+	typename PrototypeList_,
+	typename Callable,
+	template <typename> class ArgTransformer,
+	int M
+>
+struct FindPrototypeByCallableFromIndex <
+	N,
+	PrototypeList_,
+	Callable,
+	ArgTransformer,
+	M,
+	typename std::enable_if<(N >= M)>::type
+>
 {
 	using Prototype = void;
 
@@ -61,40 +102,40 @@ struct FindPrototypeByCallableHelper <N, std::tuple<>, Callable>
 	};
 };
 
-template <typename PrototypeList_, typename Callable>
-struct FindPrototypeByCallable : public FindPrototypeByCallableHelper <0, PrototypeList_, Callable>
+template <typename PrototypeList_, typename Callable, template <typename> class ArgTransformer = FindPrototypeDefaultArgTransformer>
+struct FindPrototypeByCallable : public FindPrototypeByCallableFromIndex <0, PrototypeList_, Callable, ArgTransformer>
 {
 };
 
 template <int N, typename PrototypeList_, typename ...InArgs>
-struct FindPrototypeByArgsHelper;
+struct FindPrototypeByArgsFromIndex;
 
 template <int N, typename RT, typename ...Args, typename ...Others, typename ...InArgs>
-struct FindPrototypeByArgsHelper <N, std::tuple<RT (Args...), Others...>, InArgs...>
+struct FindPrototypeByArgsFromIndex <N, std::tuple<RT (Args...), Others...>, InArgs...>
 {
 	enum { canInvoke = CanInvoke<RT (Args...), InArgs...>::value };
 
 	using Prototype = typename std::conditional<
 		canInvoke,
 		RT (Args...),
-		typename FindPrototypeByArgsHelper<N + 1, std::tuple<Others...>, InArgs...>::Prototype
+		typename FindPrototypeByArgsFromIndex<N + 1, std::tuple<Others...>, InArgs...>::Prototype
 	>::type;
 
 	using ArgsTuple = typename std::conditional<
 		canInvoke,
 		std::tuple<typename std::remove_cv<typename std::remove_reference<Args>::type>::type...>,
-		typename FindPrototypeByArgsHelper<N + 1, std::tuple<Others...>, InArgs...>::ArgsTuple
+		typename FindPrototypeByArgsFromIndex<N + 1, std::tuple<Others...>, InArgs...>::ArgsTuple
 	>::type;
 
 	enum {
 		index = canInvoke
 		? N
-		: FindPrototypeByArgsHelper<N + 1, std::tuple<Others...>, InArgs...>::index
+		: FindPrototypeByArgsFromIndex<N + 1, std::tuple<Others...>, InArgs...>::index
 	};
 };
 
 template <int N, typename ...InArgs>
-struct FindPrototypeByArgsHelper <N, std::tuple<>, InArgs...>
+struct FindPrototypeByArgsFromIndex <N, std::tuple<>, InArgs...>
 {
 	using Prototype = void;
 
@@ -104,7 +145,7 @@ struct FindPrototypeByArgsHelper <N, std::tuple<>, InArgs...>
 };
 
 template <typename PrototypeList_, typename ...InArgs>
-struct FindPrototypeByArgs : public FindPrototypeByArgsHelper <0, PrototypeList_, InArgs...>
+struct FindPrototypeByArgs : public FindPrototypeByArgsFromIndex <0, PrototypeList_, InArgs...>
 {
 };
 
diff --git a/include/eventpp/internal/typeutil_i.h b/include/eventpp/internal/typeutil_i.h
index 76a2c55..2ae8e21 100644
--- a/include/eventpp/internal/typeutil_i.h
+++ b/include/eventpp/internal/typeutil_i.h
@@ -15,6 +15,7 @@
 #define TYPEUTIL_I_H
 
 #include <utility>
+#include <tuple>
 
 namespace eventpp {
 
@@ -86,6 +87,37 @@ struct CanInvoke
 	};
 };
 
+template <typename T>
+struct ShiftTuple;
+
+template <typename A, typename ...Args>
+struct ShiftTuple <std::tuple<A, Args...> >
+{
+	using Type = std::tuple<Args...>;
+};
+
+template <>
+struct ShiftTuple <std::tuple<> >
+{
+	using Type = std::tuple<>;
+};
+
+// for compile time debug
+template<typename T>
+void printTypeInCompileTime(T * = 0)
+{
+	static_assert(std::is_same<T, int>::value && ! std::is_same<T, int>::value, "The error shows the type name.");
+}
+template<int N>
+void printIntInCompileTime()
+{
+	int n = 0;
+	switch(n) {
+	case N:
+	case N:
+		break;
+	};
+}
 
 } //namespace internal_
 
diff --git a/include/eventpp/mixins/mixinheterfilter.h b/include/eventpp/mixins/mixinheterfilter.h
index 5248a3d..c8cb19e 100644
--- a/include/eventpp/mixins/mixinheterfilter.h
+++ b/include/eventpp/mixins/mixinheterfilter.h
@@ -49,7 +49,7 @@ class MixinHeterFilter : public Base
 			}
 
 			using PrototypeInfo = internal_::FindPrototypeByIndex<PrototypeList, N>;
-			auto dispatcher = self->template doFindDispatcher<PrototypeInfo>();
+			auto dispatcher = self->template doGetDispatcher<PrototypeInfo>();
 			if(! dispatcher) {
 				return false;
 			}
@@ -68,10 +68,10 @@ class MixinHeterFilter : public Base
 	template <typename C>
 	FilterHandle appendFilter(const C & callback) const
 	{
-		using PrototypeInfo = internal_::FindPrototypeByCallable<typename super::PrototypeList, C>;
+		using PrototypeInfo = internal_::FindPrototypeByCallable<typename super::PrototypeList, C, std::add_lvalue_reference>;
 		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
 
-		auto dispatcher = this->template doFindDispatcher<PrototypeInfo>();
+		auto dispatcher = this->template doGetDispatcher<PrototypeInfo>();
 		return FilterHandle {
 			PrototypeInfo::index,
 			dispatcher->appendFilter(callback)
diff --git a/tests/unittest/test_heterdispatcher_basic.cpp b/tests/unittest/test_heterdispatcher_basic.cpp
index 6a03f51..04300ed 100644
--- a/tests/unittest/test_heterdispatcher_basic.cpp
+++ b/tests/unittest/test_heterdispatcher_basic.cpp
@@ -16,6 +16,10 @@
 #include "eventpp/mixins/mixinfilter.h"
 #include "eventpp/mixins/mixinheterfilter.h"
 
+using namespace eventpp;
+using namespace eventpp::internal_;
+static_assert(FindPrototypeByCallable<std::tuple<void(), void(int)>, void(int)>::index == 1, "aaa");
+
 TEST_CASE("xxx HeterEventDispatcher, 1")
 {
 	eventpp::HeterEventDispatcher<int, std::tuple<void (), void (int, int, int)> > dispatcher;
@@ -57,8 +61,9 @@ TEST_CASE("xxx HeterEventDispatcher, event filter")
 {
 	struct MyPolicies {
 		using Mixins = eventpp::MixinList<eventpp::MixinHeterFilter>;
+		using ArgumentPassingMode = eventpp::ArgumentPassingIncludeEvent;
 	};
-	using ED = eventpp::HeterEventDispatcher<int, std::tuple<void (int, int), void ()>, MyPolicies>;
+	using ED = eventpp::HeterEventDispatcher<int, std::tuple<void (int, int), void (int)>, MyPolicies>;
 	ED dispatcher;
 
 	constexpr int itemCount = 5;
@@ -78,13 +83,13 @@ TEST_CASE("xxx HeterEventDispatcher, event filter")
 			++filterData[0];
 			return true;
 		});
-		auto handle2 = dispatcher.appendFilter([&filterData]() -> bool {
+		auto handle2 = dispatcher.appendFilter([&filterData](int) -> bool {
 			++filterData[1];
 			return true;
 		});
 
 		for(int i = 0; i < itemCount; ++i) {
-			dispatcher.dispatch(i, i, 58);
+			dispatcher.dispatch(i, 58);
 			dispatcher.dispatch(i);
 		}
 
@@ -94,7 +99,7 @@ TEST_CASE("xxx HeterEventDispatcher, event filter")
 		dispatcher.removeFilter(handle1);
 
 		for(int i = 0; i < itemCount; ++i) {
-			dispatcher.dispatch(i, i, 38);
+			dispatcher.dispatch(i, 38);
 			dispatcher.dispatch(i);
 		}
 
@@ -104,13 +109,13 @@ TEST_CASE("xxx HeterEventDispatcher, event filter")
 		dispatcher.removeFilter(handle2);
 
 		for(int i = 0; i < itemCount; ++i) {
-			dispatcher.dispatch(i, i, 38);
+			dispatcher.dispatch(i, 38);
 			dispatcher.dispatch(i);
 		}
 
 		REQUIRE(filterData == std::vector<int>{ itemCount, itemCount * 2 });
 	}
-#if 0
+
 	SECTION("First filter blocks all other filters and listeners") {
 		dispatcher.appendFilter([&filterData](int e, int /*index*/) -> bool {
 			++filterData[0];
@@ -173,6 +178,6 @@ TEST_CASE("xxx HeterEventDispatcher, event filter")
 		REQUIRE(filterData == std::vector<int>{ itemCount, itemCount });
 		REQUIRE(dataList == std::vector<int>{ 58, 58, 59, 59, 59 });
 	}
-#endif
+
 }
 
diff --git a/tests/unittest/test_heterqueue_basic.cpp b/tests/unittest/test_heterqueue_basic.cpp
index 74057b8..2a2fda9 100644
--- a/tests/unittest/test_heterqueue_basic.cpp
+++ b/tests/unittest/test_heterqueue_basic.cpp
@@ -14,7 +14,7 @@
 #include "test.h"
 #include "eventpp/hetereventqueue.h"
 
-TEST_CASE("xxx HeterEventQueue 1")
+TEST_CASE("HeterEventQueue 1")
 {
 	eventpp::HeterEventQueue<std::string, std::tuple<void (), void (const std::string &)> > queue;
 
@@ -42,3 +42,57 @@ TEST_CASE("xxx HeterEventQueue 1")
 	REQUIRE(b == 8);
 }
 
+TEST_CASE("xxx HeterEventQueue, processIf")
+{
+	struct MyEventPolicies
+	{
+		using ArgumentPassingMode = eventpp::ArgumentPassingIncludeEvent;
+	};
+
+	eventpp::HeterEventQueue<int, std::tuple<void (int), void (int, int)>, MyEventPolicies> queue;
+
+	std::vector<int> dataList(3);
+
+	queue.appendListener(5, [&dataList](int) {
+		++dataList[0];
+	});
+	queue.appendListener(6, [&dataList](int) {
+		++dataList[1];
+	});
+	queue.appendListener(7, [&dataList](int, int) {
+		++dataList[2];
+	});
+
+	REQUIRE(dataList == std::vector<int>{ 0, 0, 0 });
+
+	queue.enqueue(5);
+	queue.enqueue(6);
+	queue.enqueue(7, 8);
+	queue.process();
+	REQUIRE(dataList == std::vector<int>{ 1, 1, 1 });
+
+	queue.enqueue(5);
+	queue.enqueue(6);
+	queue.enqueue(7, 8);
+	queue.processIf([](const int event) -> bool { return event == 6; });
+	REQUIRE(dataList == std::vector<int>{ 1, 2, 1 });
+	// Now the queue contains 5, 7
+
+	queue.enqueue(5);
+	queue.enqueue(6);
+	queue.enqueue(7, 8);
+	queue.processIf([](const int event) -> bool { return event == 5; });
+	REQUIRE(dataList == std::vector<int>{ 3, 2, 1 });
+	// Now the queue contains 6, 7, 7
+
+	queue.enqueue(5);
+	queue.enqueue(6);
+	queue.enqueue(7, 8);
+	queue.processIf([](const int event, int) -> bool { return event == 7; });
+	REQUIRE(dataList == std::vector<int>{ 3, 2, 4 });
+	// Now the queue contains 5, 6, 6
+
+	queue.process();
+	REQUIRE(dataList == std::vector<int>{ 4, 4, 4 });
+}
+

From b3d99a3e824dcd4d278b41eb92deab2f53d23c2b Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Wed, 27 Mar 2019 22:40:13 +0800
Subject: [PATCH 19/38] Remove temporary words in test case names.

---
 tests/unittest/test_heterdispatcher_basic.cpp | 4 ++--
 tests/unittest/test_heterqueue_basic.cpp      | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/unittest/test_heterdispatcher_basic.cpp b/tests/unittest/test_heterdispatcher_basic.cpp
index 04300ed..38a6fd1 100644
--- a/tests/unittest/test_heterdispatcher_basic.cpp
+++ b/tests/unittest/test_heterdispatcher_basic.cpp
@@ -20,7 +20,7 @@ using namespace eventpp;
 using namespace eventpp::internal_;
 static_assert(FindPrototypeByCallable<std::tuple<void(), void(int)>, void(int)>::index == 1, "aaa");
 
-TEST_CASE("xxx HeterEventDispatcher, 1")
+TEST_CASE("HeterEventDispatcher, 1")
 {
 	eventpp::HeterEventDispatcher<int, std::tuple<void (), void (int, int, int)> > dispatcher;
 
@@ -57,7 +57,7 @@ TEST_CASE("xxx HeterEventDispatcher, 1")
 	REQUIRE(dataList[1] == 24);
 }
 
-TEST_CASE("xxx HeterEventDispatcher, event filter")
+TEST_CASE("HeterEventDispatcher, event filter")
 {
 	struct MyPolicies {
 		using Mixins = eventpp::MixinList<eventpp::MixinHeterFilter>;
diff --git a/tests/unittest/test_heterqueue_basic.cpp b/tests/unittest/test_heterqueue_basic.cpp
index 2a2fda9..9fe90bd 100644
--- a/tests/unittest/test_heterqueue_basic.cpp
+++ b/tests/unittest/test_heterqueue_basic.cpp
@@ -42,7 +42,7 @@ TEST_CASE("HeterEventQueue 1")
 	REQUIRE(b == 8);
 }
 
-TEST_CASE("xxx HeterEventQueue, processIf")
+TEST_CASE("HeterEventQueue, processIf")
 {
 	struct MyEventPolicies
 	{

From 89859810f4a9d177cbd75039951e1fbb4c4076e4 Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Thu, 28 Mar 2019 15:31:50 +0800
Subject: [PATCH 20/38] Fixed typos in document

---
 doc/callbacklist.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/doc/callbacklist.md b/doc/callbacklist.md
index 26f5d13..338eb3a 100644
--- a/doc/callbacklist.md
+++ b/doc/callbacklist.md
@@ -102,9 +102,9 @@ void forEach(Func && func);
 Apply `func` to all callbacks.  
 The `func` can be one of the three prototypes:  
 ```c++
-AnyReturnType func(const EventDispatcher::Handle &, const EventDispatcher::Callback &);
-AnyReturnType func(const EventDispatcher::Handle &);
-AnyReturnType func(const EventDispatcher::Callback &);
+AnyReturnType func(const CallbackList::Handle &, const CallbackList::Callback &);
+AnyReturnType func(const CallbackList::Handle &);
+AnyReturnType func(const CallbackList::Callback &);
 ```
 **Note**: the `func` can remove any callbacks, or add other callbacks, safely.
 

From b91b0b788e9f72862bc9d187b210b84fe1a2b9a4 Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Thu, 28 Mar 2019 15:32:24 +0800
Subject: [PATCH 21/38] Added HeterCallbackList

---
 include/eventpp/callbacklist.h                |   1 -
 include/eventpp/hetercallbacklist.h           | 291 ++++++++++++++++++
 tests/unittest/CMakeLists.txt                 |   1 +
 .../unittest/test_hetercallbacklist_basic.cpp | 177 +++++++++++
 4 files changed, 469 insertions(+), 1 deletion(-)
 create mode 100644 include/eventpp/hetercallbacklist.h
 create mode 100644 tests/unittest/test_hetercallbacklist_basic.cpp

diff --git a/include/eventpp/callbacklist.h b/include/eventpp/callbacklist.h
index 9197b1f..5a00806 100644
--- a/include/eventpp/callbacklist.h
+++ b/include/eventpp/callbacklist.h
@@ -23,7 +23,6 @@
 #include <memory>
 #include <mutex>
 #include <utility>
-#include <vector>
 
 namespace eventpp {
 
diff --git a/include/eventpp/hetercallbacklist.h b/include/eventpp/hetercallbacklist.h
new file mode 100644
index 0000000..d08eb78
--- /dev/null
+++ b/include/eventpp/hetercallbacklist.h
@@ -0,0 +1,291 @@
+// eventpp library
+// Copyright (C) 2018 Wang Qi (wqking)
+// Github: https://github.com/wqking/eventpp
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//   http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef HETERCALLBACKLIST_H_966730936077
+#define HETERCALLBACKLIST_H_966730936077
+
+// TODO: move to hetercallbacklist_i.h
+#include "internal/hetereventdispatcher_i.h"
+
+#include "callbacklist.h"
+
+#include <array>
+#include <functional>
+#include <type_traits>
+#include <mutex>
+#include <memory>
+#include <tuple>
+
+namespace eventpp {
+
+namespace internal_ {
+
+template <
+	typename PrototypeList_,
+	typename Policies_
+>
+class HeterCallbackListBase
+{
+protected:
+	struct HeterHandle_
+	{
+		int index;
+		std::weak_ptr<void> homoHandle;
+
+		operator bool () const noexcept {
+			return (bool)homoHandle;
+		}
+	};
+
+	struct UnderlyingPoliciesType_
+	{
+	};
+
+	class HomoCallbackListTypeBase
+	{
+	public:
+		virtual bool empty() = 0;
+		virtual bool doRemove(const HeterHandle_ & handle) = 0;
+		virtual std::shared_ptr<HomoCallbackListTypeBase> doClone() = 0;
+	};
+
+	template <typename T>
+	class HomoCallbackListType : public CallbackList<T, UnderlyingPoliciesType_>, public HomoCallbackListTypeBase
+	{
+	private:
+		using super = CallbackList<T, UnderlyingPoliciesType_>;
+
+	public:
+		virtual bool empty() override {
+			return super::empty();
+		}
+
+		virtual bool doRemove(const HeterHandle_ & handle) override {
+			auto sp = handle.homoHandle.lock();
+			if(! sp) {
+				return false;
+			}
+			return this->remove(typename super::Handle(std::static_pointer_cast<typename super::Handle::element_type>(sp)));
+		}
+
+		virtual std::shared_ptr<HomoCallbackListTypeBase> doClone() override {
+			return std::make_shared<HomoCallbackListType<T> >(*this);
+		}
+	};
+
+	using Policies = Policies_;
+	using Threading = typename SelectThreading<Policies, HasTypeThreading<Policies>::value>::Type;
+
+	using PrototypeList = PrototypeList_;
+
+public:
+	using Handle = HeterHandle_;
+	using Mutex = typename Threading::Mutex;
+
+public:
+	HeterCallbackListBase()
+		:
+		callbackListList(),
+		callbackListListMutex()
+	{
+	}
+
+	HeterCallbackListBase(const HeterCallbackListBase & other)
+	{
+		for(size_t i = 0; i < callbackListList.size(); ++i) {
+			callbackListList[i] = other.callbackListList[i]->doClone();
+		}
+	}
+
+	HeterCallbackListBase(HeterCallbackListBase && other) noexcept
+		:
+		callbackListList(std::move(other.callbackListList)),
+		callbackListListMutex()
+	{
+	}
+
+	HeterCallbackListBase & operator = (HeterCallbackListBase other)
+	{
+		swap(*this, other);
+
+		return *this;
+	}
+
+	HeterCallbackListBase & operator = (HeterCallbackListBase && other) noexcept
+	{
+		callbackListList = std::move(other.callbackListList);
+
+		return *this;
+	}
+
+	void swap(HeterCallbackListBase & other) noexcept {
+		using std::swap;
+
+		swap(callbackListList, other.callbackListList);
+	}
+
+	friend void swap(HeterCallbackListBase & first, HeterCallbackListBase & second) noexcept {
+		first.swap(second);
+	}
+
+	bool empty() const {
+		for(const auto & callbackList : callbackListList) {
+			if(callbackList && ! callbackList->empty()) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	operator bool() const {
+		return ! empty();
+	}
+
+	template <typename C>
+	Handle append(const C & callback)
+	{
+		using PrototypeInfo = FindPrototypeByCallable<PrototypeList_, C>;
+		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
+
+		auto callbackList= doGetCallbackList<PrototypeInfo>();
+		return Handle {
+			PrototypeInfo::index,
+			callbackList->append(callback)
+		};
+	}
+
+	template <typename C>
+	Handle prepend(const C & callback)
+	{
+		using PrototypeInfo = FindPrototypeByCallable<PrototypeList_, C>;
+		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
+
+		auto callbackList= doGetCallbackList<PrototypeInfo>();
+		return Handle {
+			PrototypeInfo::index,
+			callbackList->prepend(callback)
+		};
+	}
+
+	bool remove(const Handle handle)
+	{
+		auto callbackList = callbackListList[handle.index];
+		if(callbackList) {
+			return callbackList->doRemove(handle);
+		}
+
+		return false;
+	}
+
+	template <typename Prototype, typename Func>
+	void forEach(Func && func) const
+	{
+		using PrototypeInfo = FindPrototypeByCallable<PrototypeList, Prototype>;
+		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
+
+		auto callbackList= doGetCallbackList<PrototypeInfo>();
+		using CL = typename decltype(callbackList)::element_type;
+		callbackList->forEach([this, &func](const typename CL::Handle & handle, const typename CL::Callback & callback) {
+			doForEachInvoke<void, CL, PrototypeInfo::index>(func, handle, callback);
+		});
+	}
+
+	template <typename Prototype, typename Func>
+	bool forEachIf(Func && func) const
+	{
+		using PrototypeInfo = FindPrototypeByCallable<PrototypeList, Prototype>;
+		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
+
+		auto callbackList= doGetCallbackList<PrototypeInfo>();
+		using CL = typename decltype(callbackList)::element_type;
+		return callbackList->forEachIf([this, &func](const typename CL::Handle & handle, const typename CL::Callback & callback) {
+			return doForEachInvoke<bool, CL, PrototypeInfo::index>(func, handle, callback);
+		});
+	}
+
+	template <typename ...Args>
+	void operator() (Args ...args) const
+	{
+		using PrototypeInfo = FindPrototypeByArgs<PrototypeList, Args...>;
+		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
+
+		auto callbackList= doGetCallbackList<PrototypeInfo>();
+		(*callbackList)(args...);
+	}
+
+private:
+	template <typename RT, typename CL, int PrototypeIndex, typename Func>
+	auto doForEachInvoke(Func && func, const typename CL::Handle & handle, const typename CL::Callback & callback) const
+		-> typename std::enable_if<CanInvoke<Func, Handle, typename CL::Callback &>::value, RT>::type
+	{
+		return func(Handle { PrototypeIndex, handle }, callback);
+	}
+
+	template <typename RT, typename CL, int PrototypeIndex, typename Func>
+	auto doForEachInvoke(Func && func, const typename CL::Handle & handle, const typename CL::Callback & callback) const
+		-> typename std::enable_if<CanInvoke<Func, Handle>::value, RT>::type
+	{
+		return func(Handle { PrototypeIndex, handle });
+	}
+
+	template <typename RT, typename CL, int PrototypeIndex, typename Func>
+	auto doForEachInvoke(Func && func, const typename CL::Handle & handle, const typename CL::Callback & callback) const
+		-> typename std::enable_if<CanInvoke<Func, typename CL::Callback &>::value, RT>::type
+	{
+		return func(callback);
+	}
+
+	template <typename PrototypeInfo>
+	auto doGetCallbackList() const
+		-> std::shared_ptr<HomoCallbackListType<typename PrototypeInfo::Prototype> >
+	{
+		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
+
+		if(! callbackListList[PrototypeInfo::index]) {
+			std::lock_guard<Mutex> lockGuard(callbackListListMutex);
+
+			if(! callbackListList[PrototypeInfo::index]) {
+				callbackListList[PrototypeInfo::index] = std::make_shared<HomoCallbackListType<typename PrototypeInfo::Prototype> >();
+			}
+		}
+
+		return std::static_pointer_cast<HomoCallbackListType<typename PrototypeInfo::Prototype> >(callbackListList[PrototypeInfo::index]);
+	}
+
+private:
+	// 'ListList' is not good, but it's better to use consistent naming convention.
+	mutable std::array<std::shared_ptr<HomoCallbackListTypeBase>, std::tuple_size<PrototypeList_>::value> callbackListList;
+	mutable Mutex callbackListListMutex;
+};
+
+
+} //namespace internal_
+
+template <
+	typename PrototypeList_,
+	typename Policies_ = DefaultPolicies
+>
+class HeterCallbackList : public internal_::HeterCallbackListBase<PrototypeList_, Policies_>, public TagCallbackList
+{
+private:
+	using super = internal_::HeterCallbackListBase<PrototypeList_, Policies_>;
+
+public:
+	using super::super;
+};
+
+
+} //namespace eventpp
+
+#endif
diff --git a/tests/unittest/CMakeLists.txt b/tests/unittest/CMakeLists.txt
index b4cb1c0..9129680 100644
--- a/tests/unittest/CMakeLists.txt
+++ b/tests/unittest/CMakeLists.txt
@@ -13,6 +13,7 @@ set(SRC_TEST
 	test_dispatcher_multithread.cpp
 	test_queue_basic.cpp
 	test_queue_multithread.cpp
+	test_hetercallbacklist_basic.cpp
 	test_heterdispatcher_basic.cpp
 	test_heterqueue_basic.cpp
 	test_eventutil.cpp
diff --git a/tests/unittest/test_hetercallbacklist_basic.cpp b/tests/unittest/test_hetercallbacklist_basic.cpp
new file mode 100644
index 0000000..802a78e
--- /dev/null
+++ b/tests/unittest/test_hetercallbacklist_basic.cpp
@@ -0,0 +1,177 @@
+// eventpp library
+// Copyright (C) 2018 Wang Qi (wqking)
+// Github: https://github.com/wqking/eventpp
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//   http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "test.h"
+#include "eventpp/hetercallbacklist.h"
+
+#include <vector>
+
+TEST_CASE("HeterCallbackList, empty")
+{
+	using CL = eventpp::HeterCallbackList<std::tuple<void (), void (int, int, int)> >;
+	SECTION("empty") {
+		CL callbackList;
+		REQUIRE(callbackList.empty());
+	}
+
+	SECTION("append") {
+		CL callbackList;
+		callbackList.append([](){});
+		REQUIRE(! callbackList.empty());
+	}
+
+	SECTION("prepend") {
+		CL callbackList;
+		callbackList.prepend([](){});
+		REQUIRE(! callbackList.empty());
+	}
+
+	SECTION("remove") {
+		CL callbackList;
+		auto handle = callbackList.append([](){});
+		REQUIRE(! callbackList.empty());
+
+		callbackList.remove(handle);
+		REQUIRE(callbackList.empty());
+	}
+}
+
+TEST_CASE("HeterCallbackList, forEach")
+{
+	using CL = eventpp::HeterCallbackList<std::tuple<int (), int(int)> >;
+	CL callbackList;
+
+	callbackList.append([]() { return 1; });
+	callbackList.append([]() { return 2; });
+	callbackList.append([]() { return 3; });
+
+	callbackList.append([](int n) { return n + 5 + 0; });
+	callbackList.append([](int n) { return n + 5 + 1; });
+	callbackList.append([](int n) { return n + 5 + 2; });
+
+	int i = 1;
+	callbackList.forEach<int ()>([&i](const std::function<int ()> & callback) {
+		REQUIRE(callback() == i);
+		++i;
+	});
+
+	i = 0;
+	callbackList.forEach<int (int)>([&i](const std::function<int (int)> & callback) {
+		REQUIRE(callback(3) == 8 + i);
+		++i;
+	});
+}
+
+TEST_CASE("HeterCallbackList, forEachIf")
+{
+	using CL = eventpp::HeterCallbackList<std::tuple<void (), void(int)> >;
+	CL callbackList;
+
+	std::vector<int> dataListNoArg(3);
+	std::vector<int> dataListWithArg(3);
+
+	callbackList.append([&dataListNoArg]() {
+		dataListNoArg[0] += 1;
+	});
+	callbackList.append([&dataListNoArg]() {
+		dataListNoArg[1] += 2;
+	});
+	callbackList.append([&dataListNoArg]() {
+		dataListNoArg[2] += 3;
+	});
+
+	callbackList.append([&dataListWithArg](int n) {
+		dataListWithArg[0] += n;
+	});
+	callbackList.append([&dataListWithArg](int n) {
+		dataListWithArg[1] += n * 2;
+	});
+	callbackList.append([&dataListWithArg](int n) {
+		dataListWithArg[2] += n * 3;
+	});
+
+	REQUIRE(dataListNoArg == std::vector<int>{ 0, 0, 0 });
+	REQUIRE(dataListWithArg == std::vector<int>{ 0, 0, 0 });
+
+	int i = 0;
+	bool result = callbackList.forEachIf<void ()>([&i](const std::function<void ()> & callback) -> bool {
+		callback();
+		++i;
+
+		return i != 2;
+	});
+
+	REQUIRE(! result);
+	REQUIRE(dataListNoArg == std::vector<int>{ 1, 2, 0 });
+	REQUIRE(dataListWithArg == std::vector<int>{ 0, 0, 0 });
+
+	i = 0;
+	result = callbackList.forEachIf<void (int)>([&i](const std::function<void (int)> & callback) -> bool {
+		callback(3);
+		++i;
+
+		return i != 1;
+	});
+
+	REQUIRE(! result);
+	REQUIRE(dataListNoArg == std::vector<int>{ 1, 2, 0 });
+	REQUIRE(dataListWithArg == std::vector<int>{ 3, 0, 0 });
+}
+
+TEST_CASE("HeterCallbackList, invoke")
+{
+	using CL = eventpp::HeterCallbackList<std::tuple<void (), void(int)> >;
+	CL callbackList;
+
+	std::vector<int> dataListNoArg(3);
+	std::vector<int> dataListWithArg(3);
+
+	callbackList.append([&dataListNoArg]() {
+		dataListNoArg[0] += 1;
+	});
+	callbackList.append([&dataListNoArg]() {
+		dataListNoArg[1] += 2;
+	});
+	callbackList.append([&dataListNoArg]() {
+		dataListNoArg[2] += 3;
+	});
+
+	callbackList.append([&dataListWithArg](int n) {
+		dataListWithArg[0] += n;
+	});
+	callbackList.append([&dataListWithArg](int n) {
+		dataListWithArg[1] += n * 2;
+	});
+	callbackList.append([&dataListWithArg](int n) {
+		dataListWithArg[2] += n * 3;
+	});
+
+	REQUIRE(dataListNoArg == std::vector<int>{ 0, 0, 0 });
+	REQUIRE(dataListWithArg == std::vector<int>{ 0, 0, 0 });
+
+	callbackList();
+	REQUIRE(dataListNoArg == std::vector<int>{ 1, 2, 3 });
+	REQUIRE(dataListWithArg == std::vector<int>{ 0, 0, 0 });
+
+	callbackList();
+	REQUIRE(dataListNoArg == std::vector<int>{ 2, 4, 6 });
+	REQUIRE(dataListWithArg == std::vector<int>{ 0, 0, 0 });
+
+	callbackList(1);
+	REQUIRE(dataListNoArg == std::vector<int>{ 2, 4, 6 });
+	REQUIRE(dataListWithArg == std::vector<int>{ 1, 2, 3 });
+
+	callbackList(2);
+	REQUIRE(dataListNoArg == std::vector<int>{ 2, 4, 6 });
+	REQUIRE(dataListWithArg == std::vector<int>{ 3, 6, 9 });
+}

From 49ee4503b458297882833bd97e8c91e23f2ea415 Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Thu, 28 Mar 2019 20:37:56 +0800
Subject: [PATCH 22/38] Use HeterCallbackList to implement HeterEventDispatcher

---
 include/eventpp/hetercallbacklist.h           |  12 +-
 include/eventpp/hetereventdispatcher.h        | 280 ++++++++++--------
 include/eventpp/hetereventqueue.h             |   3 +-
 ...ntdispatcher_i.h => hetercallbacklist_i.h} |  73 +++--
 include/eventpp/mixins/mixinheterfilter.h     |  59 +---
 .../unittest/test_hetercallbacklist_basic.cpp |   8 +-
 tests/unittest/test_heterdispatcher_basic.cpp |  10 +-
 tests/unittest/test_heterqueue_basic.cpp      |   4 +-
 8 files changed, 237 insertions(+), 212 deletions(-)
 rename include/eventpp/internal/{hetereventdispatcher_i.h => hetercallbacklist_i.h} (71%)

diff --git a/include/eventpp/hetercallbacklist.h b/include/eventpp/hetercallbacklist.h
index d08eb78..ae9dadf 100644
--- a/include/eventpp/hetercallbacklist.h
+++ b/include/eventpp/hetercallbacklist.h
@@ -14,9 +14,7 @@
 #ifndef HETERCALLBACKLIST_H_966730936077
 #define HETERCALLBACKLIST_H_966730936077
 
-// TODO: move to hetercallbacklist_i.h
-#include "internal/hetereventdispatcher_i.h"
-
+#include "internal/hetercallbacklist_i.h"
 #include "callbacklist.h"
 
 #include <array>
@@ -215,13 +213,13 @@ class HeterCallbackListBase
 	}
 
 	template <typename ...Args>
-	void operator() (Args ...args) const
+	void operator() (Args && ...args) const
 	{
 		using PrototypeInfo = FindPrototypeByArgs<PrototypeList, Args...>;
 		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
 
 		auto callbackList= doGetCallbackList<PrototypeInfo>();
-		(*callbackList)(args...);
+		(*callbackList)(std::forward<Args>(args)...);
 	}
 
 private:
@@ -264,8 +262,8 @@ class HeterCallbackListBase
 	}
 
 private:
-	// 'ListList' is not good, but it's better to use consistent naming convention.
-	mutable std::array<std::shared_ptr<HomoCallbackListTypeBase>, std::tuple_size<PrototypeList_>::value> callbackListList;
+	// the postfix 'ListList' is not good, but it's better to use consistent naming convention.
+	mutable std::array<std::shared_ptr<HomoCallbackListTypeBase>, HeterTupleSize<PrototypeList_>::value> callbackListList;
 	mutable Mutex callbackListListMutex;
 };
 
diff --git a/include/eventpp/hetereventdispatcher.h b/include/eventpp/hetereventdispatcher.h
index 4cf23aa..8a3c5de 100644
--- a/include/eventpp/hetereventdispatcher.h
+++ b/include/eventpp/hetereventdispatcher.h
@@ -14,8 +14,8 @@
 #ifndef HETEREVENTDISPATCHER_H_127766658555
 #define HETEREVENTDISPATCHER_H_127766658555
 
-#include "internal/hetereventdispatcher_i.h"
 #include "eventdispatcher.h"
+#include "hetercallbacklist.h"
 #include "mixins/mixinheterfilter.h"
 #include "mixins/mixinfilter.h"
 
@@ -73,15 +73,20 @@ template <
 class HeterEventDispatcherBase
 {
 protected:
-	struct Handle_
-	{
-		int index;
-		std::weak_ptr<void> homoHandle;
+	using ThisType = HeterEventDispatcherBase<
+		EventType_,
+		PrototypeList_,
+		Policies_,
+		MixinRoot_
+	>;
+	using MixinRoot = typename std::conditional<
+		std::is_same<MixinRoot_, void>::value,
+		ThisType,
+		MixinRoot_
+	>::type;
+	using Policies = Policies_;
 
-		operator bool () const noexcept {
-			return (bool)homoHandle;
-		}
-	};
+	using Threading = typename SelectThreading<Policies_, HasTypeThreading<Policies_>::value>::Type;
 
 	using ArgumentPassingMode = typename SelectArgumentPassingMode<
 		Policies_,
@@ -92,195 +97,232 @@ class HeterEventDispatcherBase
 	static_assert(! std::is_same<ArgumentPassingMode, ArgumentPassingAutoDetect>::value,
 		"ArgumentPassingMode can't be ArgumentPassingAutoDetect in heterogeneous dispatcher.");
 
-	struct UnderlyingPoliciesType_
-	{
-		using Mixins = typename BuildHeterUnderlyingMixinList<
-			typename internal_::SelectMixins<Policies_, internal_::HasTypeMixins<Policies_>::value >::Type
-		>::Type;
-	};
-
-	class HomoDispatcherTypeBase
-	{
-	public:
-		virtual bool doRemoveListener(const EventType_ & event, const Handle_ & handle) = 0;
-		virtual std::shared_ptr<HomoDispatcherTypeBase> doClone() = 0;
-	};
-
-	template <typename T>
-	class HomoDispatcherType : public EventDispatcher<EventType_, T, UnderlyingPoliciesType_>, public HomoDispatcherTypeBase
-	{
-	private:
-		using super = EventDispatcher<EventType_, T, UnderlyingPoliciesType_>;
-
-	public:
-		virtual bool doRemoveListener(const EventType_ & event, const Handle_ & handle) override {
-			auto sp = handle.homoHandle.lock();
-			if(! sp) {
-				return false;
-			}
-			return this->removeListener(event, typename super::Handle(std::static_pointer_cast<typename super::Handle::element_type>(sp)));
-		}
-
-		virtual std::shared_ptr<HomoDispatcherTypeBase> doClone() override {
-			return std::make_shared<HomoDispatcherType<T> >(*this);
-		}
-	};
+	using CallbackList_ = HeterCallbackList<PrototypeList_, Policies_>;
 
-	using Policies = Policies_;
-	using Threading = typename SelectThreading<Policies, HasTypeThreading<Policies>::value>::Type;
+	using Map = typename SelectMap<
+		EventType_,
+		CallbackList_,
+		Policies_,
+		HasTemplateMap<Policies_>::value
+	>::Type;
 
-	using PrototypeList = PrototypeList_;
+	using Mixins = typename internal_::SelectMixins<
+		Policies_,
+		internal_::HasTypeMixins<Policies_>::value
+	>::Type;
 
 public:
-	using Handle = Handle_;
+	using PrototypeList = PrototypeList_;
+	using Handle = typename CallbackList_::Handle;
 	using Event = EventType_;
 	using Mutex = typename Threading::Mutex;
 
 public:
 	HeterEventDispatcherBase()
 		:
-			dispatcherList(),
-			dispatcherListMutex()
+		eventCallbackListMap(),
+		listenerMutex()
 	{
 	}
 
 	HeterEventDispatcherBase(const HeterEventDispatcherBase & other)
+		:
+		eventCallbackListMap(other.eventCallbackListMap),
+		listenerMutex()
 	{
-		for(size_t i = 0; i < dispatcherList.size(); ++i) {
-			dispatcherList[i] = other.dispatcherList[i]->doClone();
-		}
 	}
 
 	HeterEventDispatcherBase(HeterEventDispatcherBase && other) noexcept
 		:
-			dispatcherList(std::move(other.dispatcherList)),
-			dispatcherListMutex()
+		eventCallbackListMap(std::move(other.eventCallbackListMap)),
+		listenerMutex()
 	{
 	}
 
-	HeterEventDispatcherBase & operator = (HeterEventDispatcherBase other)
+	HeterEventDispatcherBase & operator = (const HeterEventDispatcherBase & other)
 	{
-		swap(*this, other);
-
-		return *this;
+		eventCallbackListMap = other;
 	}
 
 	HeterEventDispatcherBase & operator = (HeterEventDispatcherBase && other) noexcept
 	{
-		dispatcherList = std::move(other.dispatcherList);
-
-		return *this;
+		eventCallbackListMap = std::move(other);
 	}
 
 	void swap(HeterEventDispatcherBase & other) noexcept {
 		using std::swap;
-		
-		swap(dispatcherList, other.dispatcherList);
+
+		swap(eventCallbackListMap, other.eventCallbackListMap);
 	}
-	
+
 	friend void swap(HeterEventDispatcherBase & first, HeterEventDispatcherBase & second) noexcept {
 		first.swap(second);
 	}
 
-	template <typename C>
-	Handle appendListener(const Event & event, const C & callback)
+	template <typename Callback>
+	Handle appendListener(const Event & event, const Callback & callback)
 	{
-		using PrototypeInfo = FindPrototypeByCallable<PrototypeList_, C>;
-		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
-
-		auto dispatcher = doGetDispatcher<PrototypeInfo>();
-		return Handle {
-			PrototypeInfo::index,
-			dispatcher->appendListener(event, callback)
-		};
+		std::lock_guard<Mutex> lockGuard(listenerMutex);
+
+		return eventCallbackListMap[event].append(callback);
+	}
+
+	template <typename Callback>
+	Handle prependListener(const Event & event, const Callback & callback)
+	{
+		std::lock_guard<Mutex> lockGuard(listenerMutex);
+
+		return eventCallbackListMap[event].prepend(callback);
 	}
 
-	template <typename C>
-	Handle prependListener(const Event & event, const C & callback)
+	template <typename Callback>
+	Handle insertListener(const Event & event, const Callback & callback, const Handle & before)
 	{
-		using PrototypeInfo = FindPrototypeByCallable<PrototypeList_, C>;
-		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
-
-		auto dispatcher = doGetDispatcher<PrototypeInfo>();
-		return Handle {
-			PrototypeInfo::index,
-			dispatcher->prependListener(event, callback)
-		};
+		std::lock_guard<Mutex> lockGuard(listenerMutex);
+
+		return eventCallbackListMap[event].insert(callback, before);
 	}
 
-	bool removeListener(const Event & event, const Handle & handle)
+	bool removeListener(const Event & event, const Handle handle)
 	{
-		auto dispatcher = dispatcherList[handle.index];
-		if(dispatcher) {
-			return dispatcher->doRemoveListener(event, handle);
+		CallbackList_ * callableList = doFindCallableList(event);
+		if(callableList) {
+			return callableList->remove(handle);
 		}
 
 		return false;
 	}
 
+	template <typename Prototype, typename Func>
+	void forEach(const Event & event, Func && func) const
+	{
+		const CallbackList_ * callableList = doFindCallableList(event);
+		if(callableList) {
+			callableList->template forEach<Prototype>(std::forward<Func>(func));
+		}
+	}
+
+	template <typename Prototype, typename Func>
+	bool forEachIf(const Event & event, Func && func) const
+	{
+		const CallbackList_ * callableList = doFindCallableList(event);
+		if (callableList) {
+			return callableList->template forEachIf<Prototype>(std::forward<Func>(func));
+		}
+
+		return true;
+	}
+
 	template <typename T, typename ...Args>
-	void dispatch(T && first, Args ...args) const
+	void dispatch(T && first, Args && ...args) const
 	{
 		doDispatch<ArgumentPassingMode>(std::forward<T>(first), std::forward<Args>(args)...);
 	}
 
+	// Bypass any getEvent policy. The first argument is the event type.
+	// Most used for internal purpose.
+	template <typename ...Args>
+	void directDispatch(const Event & e, Args && ...args) const
+	{
+		if(! internal_::ForEachMixins<MixinRoot, Mixins, DoMixinBeforeDispatch>::forEach(
+			this, typename std::add_lvalue_reference<Args>::type(args)...)) {
+			return;
+		}
+
+		const CallbackList_ * callableList = doFindCallableList(e);
+		if(callableList) {
+			(*callableList)(std::forward<Args>(args)...);
+		}
+	}
+
 protected:
 	template <typename ArgumentMode, typename T, typename ...Args>
 	auto doDispatch(T && first, Args ...args) const
 		-> typename std::enable_if<std::is_same<ArgumentMode, ArgumentPassingIncludeEvent>::value>::type
 	{
-		using PrototypeInfo = FindPrototypeByArgs<PrototypeList_, T, Args...>;
-		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
+		if(! internal_::ForEachMixins<MixinRoot, Mixins, DoMixinBeforeDispatch>::forEach(
+			this,
+			typename std::add_lvalue_reference<Args>::type(args)...)
+		) {
+			return;
+		}
 
-		auto dispatcher = doGetDispatcher<PrototypeInfo>();
-		dispatcher->dispatch(std::forward<T>(first), std::forward<T>(first), std::forward<Args>(args)...);
+		using GetEvent = typename SelectGetEvent<Policies_, EventType_, HasFunctionGetEvent<Policies_, T &&, Args...>::value>::Type;
+		const auto e = GetEvent::getEvent(std::forward<T>(first), args...);
+		const CallbackList_ * callableList = doFindCallableList(e);
+		if(callableList) {
+			(*callableList)(std::forward<T>(first), std::forward<T>(first), std::forward<Args>(args)...);
+		}
 	}
 
 	template <typename ArgumentMode, typename T, typename ...Args>
 	auto doDispatch(T && first, Args ...args) const
 		-> typename std::enable_if<std::is_same<ArgumentMode, ArgumentPassingExcludeEvent>::value>::type
 	{
-		using PrototypeInfo = FindPrototypeByArgs<PrototypeList_, Args...>;
-		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
+		if(! internal_::ForEachMixins<MixinRoot, Mixins, DoMixinBeforeDispatch>::forEach(
+			this, typename std::add_lvalue_reference<T>::type(first),
+			typename std::add_lvalue_reference<Args>::type(args)...)
+		) {
+			return;
+		}
 
-		auto dispatcher = doGetDispatcher<PrototypeInfo>();
-		dispatcher->dispatch(std::forward<T>(first), std::forward<Args>(args)...);
+		using GetEvent = typename SelectGetEvent<Policies_, EventType_, HasFunctionGetEvent<Policies_, T &&, Args...>::value>::Type;
+		const auto e = GetEvent::getEvent(std::forward<T>(first), args...);
+		const CallbackList_ * callableList = doFindCallableList(e);
+		if(callableList) {
+			(*callableList)(std::forward<Args>(args)...);
+		}
 	}
 
-	template <typename PrototypeInfo>
-	auto doGetDispatcher() const
-		-> std::shared_ptr<HomoDispatcherType<typename PrototypeInfo::Prototype> >
+	const CallbackList_ * doFindCallableList(const Event & e) const
 	{
-		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
-
-		if(! dispatcherList[PrototypeInfo::index]) {
-			std::lock_guard<Mutex> lockGuard(dispatcherListMutex);
-
-			if(! dispatcherList[PrototypeInfo::index]) {
-				dispatcherList[PrototypeInfo::index] = std::make_shared<HomoDispatcherType<typename PrototypeInfo::Prototype> >();
-			}
-		}
+		return doFindCallableListHelper(this, e);
+	}
 
-		return std::static_pointer_cast<HomoDispatcherType<typename PrototypeInfo::Prototype> >(dispatcherList[PrototypeInfo::index]);
+	CallbackList_ * doFindCallableList(const Event & e)
+	{
+		return doFindCallableListHelper(this, e);
 	}
 
-	template <typename PrototypeInfo>
-	auto doFindDispatcher() const
-		-> std::shared_ptr<HomoDispatcherType<typename PrototypeInfo::Prototype> >
+private:
+	// template helper to avoid code duplication in doFindCallableList
+	template <typename T>
+	static auto doFindCallableListHelper(T * self, const Event & e)
+		-> typename std::conditional<std::is_const<T>::value, const CallbackList_ *, CallbackList_ *>::type
 	{
-		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
+		std::lock_guard<Mutex> lockGuard(self->listenerMutex);
 
-		return std::static_pointer_cast<HomoDispatcherType<typename PrototypeInfo::Prototype> >(dispatcherList[PrototypeInfo::index]);
+		auto it = self->eventCallbackListMap.find(e);
+		if(it != self->eventCallbackListMap.end()) {
+			return &it->second;
+		}
+		else {
+			return nullptr;
+		}
+
+		return 0;
 	}
 
-	std::shared_ptr<HomoDispatcherTypeBase> doGetDispatcherAt(const int index) const
+private:
+	// Mixin related
+	struct DoMixinBeforeDispatch
 	{
-		return dispatcherList[index];
-	}
+		template <typename T, typename Self, typename ...A>
+		static auto forEach(const Self * self, A && ...args)
+			-> typename std::enable_if<HasFunctionMixinBeforeDispatch<T, A...>::value, bool>::type {
+			return static_cast<const T *>(self)->mixinBeforeDispatch(std::forward<A>(args)...);
+		}
+
+		template <typename T, typename Self, typename ...A>
+		static auto forEach(const Self * self, A && ...args)
+			-> typename std::enable_if<! HasFunctionMixinBeforeDispatch<T, A...>::value, bool>::type {
+			return true;
+		}
+	};
 
 private:
-	mutable std::array<std::shared_ptr<HomoDispatcherTypeBase>, std::tuple_size<PrototypeList_>::value> dispatcherList;
-	mutable Mutex dispatcherListMutex;
+	Map eventCallbackListMap;
+	mutable Mutex listenerMutex;
 };
 
 } //namespace internal_
diff --git a/include/eventpp/hetereventqueue.h b/include/eventpp/hetereventqueue.h
index 56f7adb..a7c1dfa 100644
--- a/include/eventpp/hetereventqueue.h
+++ b/include/eventpp/hetereventqueue.h
@@ -264,8 +264,7 @@ class HeterEventQueueBase : public HeterEventDispatcherBase<
 	template <typename PrototypeInfo, typename T, size_t ...Indexes>
 	void doDispatchQueuedItem(T && item, IndexSequence<Indexes...>) const
 	{
-		auto dispatcher = this->template doGetDispatcher<PrototypeInfo>();
-		dispatcher->directDispatch(item.event, std::get<Indexes>(item.arguments)...);
+		this->directDispatch(item.event, std::get<Indexes>(item.arguments)...);
 	}
 
 	template <typename PrototypeInfo, typename F>
diff --git a/include/eventpp/internal/hetereventdispatcher_i.h b/include/eventpp/internal/hetercallbacklist_i.h
similarity index 71%
rename from include/eventpp/internal/hetereventdispatcher_i.h
rename to include/eventpp/internal/hetercallbacklist_i.h
index adb3c17..3edf6fc 100644
--- a/include/eventpp/internal/hetereventdispatcher_i.h
+++ b/include/eventpp/internal/hetercallbacklist_i.h
@@ -11,8 +11,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef HETEREVENTDISPATCHER_I_H
-#define HETEREVENTDISPATCHER_I_H
+#ifndef HETERCALLBACKLIST_I_H
+#define HETERCALLBACKLIST_I_H
 
 #include "typeutil_i.h"
 
@@ -20,6 +20,37 @@
 
 namespace eventpp {
 
+/*
+// We can't use std::tuple as HeterTuple because std::tuple is instantialized
+// somewhere in the Map in HeterEventDispatcherBase, that causes compile error
+// for that function type can't be declared.
+template <typename ...Types>
+using HeterTuple = std::tuple<Types...>;
+
+template <typename T>
+struct HeterTupleSize;
+
+template <typename ...Types>
+struct HeterTupleSize <HeterTuple <Types...> >
+{
+enum { value = std::tuple_size<HeterTuple <Types...> >::value };
+};
+*/
+
+template <typename ...Types>
+struct HeterTuple
+{
+};
+
+template <typename T>
+struct HeterTupleSize;
+
+template <typename ...Types>
+struct HeterTupleSize <HeterTuple <Types...> >
+{
+	enum { value = sizeof...(Types) };
+};
+
 namespace internal_ {
 
 template <typename T>
@@ -33,7 +64,7 @@ template <
 	typename PrototypeList_,
 	typename Callable,
 	template <typename> class ArgTransformer = FindPrototypeDefaultArgTransformer,
-	int M = std::tuple_size<PrototypeList_>::value,
+	int M = HeterTupleSize<PrototypeList_>::value,
 	typename Enabled = void
 >
 struct FindPrototypeByCallableFromIndex;
@@ -49,7 +80,7 @@ template <
 >
 struct FindPrototypeByCallableFromIndex <
 	N,
-	std::tuple<RT (Args...), Others...>,
+	HeterTuple<RT (Args...), Others...>,
 	Callable,
 	ArgTransformer,
 	M,
@@ -61,19 +92,19 @@ struct FindPrototypeByCallableFromIndex <
 	using Prototype = typename std::conditional<
 		canInvoke,
 		RT (Args...),
-		typename FindPrototypeByCallableFromIndex<N + 1, std::tuple<Others...>, Callable, ArgTransformer, M>::Prototype
+		typename FindPrototypeByCallableFromIndex<N + 1, HeterTuple<Others...>, Callable, ArgTransformer, M>::Prototype
 	>::type;
 
 	using ArgsTuple = typename std::conditional<
 		canInvoke,
 		std::tuple<typename std::remove_cv<typename std::remove_reference<Args>::type>::type...>,
-		typename FindPrototypeByCallableFromIndex<N + 1, std::tuple<Others...>, Callable, ArgTransformer, M>::ArgsTuple
+		typename FindPrototypeByCallableFromIndex<N + 1, HeterTuple<Others...>, Callable, ArgTransformer, M>::ArgsTuple
 	>::type;
 
 	enum {
 		index = canInvoke
 			? N
-			: FindPrototypeByCallableFromIndex<N + 1, std::tuple<Others...>, Callable, ArgTransformer, M>::index
+			: FindPrototypeByCallableFromIndex<N + 1, HeterTuple<Others...>, Callable, ArgTransformer, M>::index
 	};
 };
 
@@ -111,31 +142,31 @@ template <int N, typename PrototypeList_, typename ...InArgs>
 struct FindPrototypeByArgsFromIndex;
 
 template <int N, typename RT, typename ...Args, typename ...Others, typename ...InArgs>
-struct FindPrototypeByArgsFromIndex <N, std::tuple<RT (Args...), Others...>, InArgs...>
+struct FindPrototypeByArgsFromIndex <N, HeterTuple<RT (Args...), Others...>, InArgs...>
 {
 	enum { canInvoke = CanInvoke<RT (Args...), InArgs...>::value };
 
 	using Prototype = typename std::conditional<
 		canInvoke,
 		RT (Args...),
-		typename FindPrototypeByArgsFromIndex<N + 1, std::tuple<Others...>, InArgs...>::Prototype
+		typename FindPrototypeByArgsFromIndex<N + 1, HeterTuple<Others...>, InArgs...>::Prototype
 	>::type;
 
 	using ArgsTuple = typename std::conditional<
 		canInvoke,
 		std::tuple<typename std::remove_cv<typename std::remove_reference<Args>::type>::type...>,
-		typename FindPrototypeByArgsFromIndex<N + 1, std::tuple<Others...>, InArgs...>::ArgsTuple
+		typename FindPrototypeByArgsFromIndex<N + 1, HeterTuple<Others...>, InArgs...>::ArgsTuple
 	>::type;
 
 	enum {
 		index = canInvoke
 		? N
-		: FindPrototypeByArgsFromIndex<N + 1, std::tuple<Others...>, InArgs...>::index
+		: FindPrototypeByArgsFromIndex<N + 1, HeterTuple<Others...>, InArgs...>::index
 	};
 };
 
 template <int N, typename ...InArgs>
-struct FindPrototypeByArgsFromIndex <N, std::tuple<>, InArgs...>
+struct FindPrototypeByArgsFromIndex <N, HeterTuple<>, InArgs...>
 {
 	using Prototype = void;
 
@@ -153,9 +184,9 @@ template <int I, int N, typename PrototypeList_>
 struct FindPrototypeByIndexHelper;
 
 template <int I, int N, typename RT, typename ...Args, typename ...Others>
-struct FindPrototypeByIndexHelper <I, N, std::tuple<RT (Args...), Others...> >
+struct FindPrototypeByIndexHelper <I, N, HeterTuple<RT (Args...), Others...> >
 {
-	using NextType = FindPrototypeByIndexHelper<I + 1, N, std::tuple<Others...> >;
+	using NextType = FindPrototypeByIndexHelper<I + 1, N, HeterTuple<Others...> >;
 	using Prototype = typename NextType::Prototype;
 
 	using ArgsTuple = typename NextType::ArgsTuple;
@@ -164,21 +195,21 @@ struct FindPrototypeByIndexHelper <I, N, std::tuple<RT (Args...), Others...> >
 };
 
 template <int N, typename RT, typename ...Args, typename ...Others>
-struct FindPrototypeByIndexHelper <N, N, std::tuple<RT (Args...), Others...> >
+struct FindPrototypeByIndexHelper <N, N, HeterTuple<RT (Args...), Others...> >
 {
 	using Prototype = RT (Args...);
 
-	using ArgsTuple = std::tuple<typename std::remove_cv<typename std::remove_reference<Args>::type>::type...>;
+	using ArgsTuple = HeterTuple<typename std::remove_cv<typename std::remove_reference<Args>::type>::type...>;
 
 	enum { index = N };
 };
 
 template <int I, int N>
-struct FindPrototypeByIndexHelper <I, N, std::tuple<>>
+struct FindPrototypeByIndexHelper <I, N, HeterTuple<>>
 {
 	using Prototype = void;
 
-	using ArgsTuple = std::tuple<>;
+	using ArgsTuple = HeterTuple<>;
 
 	enum { index = -1 };
 };
@@ -192,17 +223,17 @@ template <typename PrototypeList_, template <typename ...> class Record>
 struct GetCallablePrototypeMaxSize;
 
 template <typename RT, typename ...Args, typename ...Others, template <typename ...> class Record>
-struct GetCallablePrototypeMaxSize <std::tuple<RT (Args...), Others...>, Record>
+struct GetCallablePrototypeMaxSize <HeterTuple<RT (Args...), Others...>, Record>
 {
 	enum {
 		my = sizeof(Record<Args...>),
-		other = GetCallablePrototypeMaxSize<std::tuple<Others...>, Record>::value
+		other = GetCallablePrototypeMaxSize<HeterTuple<Others...>, Record>::value
 	};
 	enum { value = (my > other ? (int)my : (int)other) };
 };
 
 template <template <typename ...> class Record>
-struct GetCallablePrototypeMaxSize <std::tuple<>, Record>
+struct GetCallablePrototypeMaxSize <HeterTuple<>, Record>
 {
 	enum { value = 1 }; // set minimum size to 1 instead of 0
 };
diff --git a/include/eventpp/mixins/mixinheterfilter.h b/include/eventpp/mixins/mixinheterfilter.h
index c8cb19e..27ed793 100644
--- a/include/eventpp/mixins/mixinheterfilter.h
+++ b/include/eventpp/mixins/mixinheterfilter.h
@@ -14,7 +14,7 @@
 #ifndef MIXINHETERFILTER_H_990158796753
 #define MIXINHETERFILTER_H_990158796753
 
-#include "../callbacklist.h"
+#include "../hetercallbacklist.h"
 #include "../internal/typeutil_i.h"
 
 #include <functional>
@@ -28,68 +28,25 @@ class MixinHeterFilter : public Base
 private:
 	using super = Base;
 
-	struct FilterHandle_
-	{
-		int index;
-		std::weak_ptr<void> homoHandle;
-
-		operator bool () const noexcept {
-			return (bool)homoHandle;
-		}
-	};
-
-	struct RemoveFilterCallback
-	{
-		template <int N, typename PrototypeList>
-		bool operator() (MixinHeterFilter * self, const PrototypeList *, const FilterHandle_ & filterHandle) const
-		{
-			auto sp = filterHandle.homoHandle.lock();
-			if(! sp) {
-				return false;
-			}
-
-			using PrototypeInfo = internal_::FindPrototypeByIndex<PrototypeList, N>;
-			auto dispatcher = self->template doGetDispatcher<PrototypeInfo>();
-			if(! dispatcher) {
-				return false;
-			}
-			return dispatcher->removeFilter(typename decltype(dispatcher)::element_type::FilterHandle(
-				std::static_pointer_cast<
-					typename decltype(dispatcher)::element_type::FilterHandle::element_type
-				>(sp)
-			));
-		}
-	};
+	using FilterList = HeterCallbackList<typename super::PrototypeList>;
 
 public:
-	using FilterHandle = FilterHandle_;
+	using FilterHandle = typename FilterList::Handle;
 
 public:
-	template <typename C>
-	FilterHandle appendFilter(const C & callback) const
+	template <typename Callback>
+	FilterHandle appendFilter(const Callback & filter)
 	{
-		using PrototypeInfo = internal_::FindPrototypeByCallable<typename super::PrototypeList, C, std::add_lvalue_reference>;
-		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
-
-		auto dispatcher = this->template doGetDispatcher<PrototypeInfo>();
-		return FilterHandle {
-			PrototypeInfo::index,
-			dispatcher->appendFilter(callback)
-		};
+		return filterList.append(filter);
 	}
 
 	bool removeFilter(const FilterHandle & filterHandle)
 	{
-		return internal_::intToConstant<std::tuple_size<typename super::PrototypeList>::value>(
-			filterHandle.index,
-			RemoveFilterCallback(),
-			this,
-			(typename super::PrototypeList *)nullptr,
-			filterHandle
-		);
+		return filterList.remove(filterHandle);
 	}
 
 private:
+	FilterList filterList;
 };
 
 
diff --git a/tests/unittest/test_hetercallbacklist_basic.cpp b/tests/unittest/test_hetercallbacklist_basic.cpp
index 802a78e..601edaf 100644
--- a/tests/unittest/test_hetercallbacklist_basic.cpp
+++ b/tests/unittest/test_hetercallbacklist_basic.cpp
@@ -18,7 +18,7 @@
 
 TEST_CASE("HeterCallbackList, empty")
 {
-	using CL = eventpp::HeterCallbackList<std::tuple<void (), void (int, int, int)> >;
+	using CL = eventpp::HeterCallbackList<eventpp::HeterTuple<void (), void (int, int, int)> >;
 	SECTION("empty") {
 		CL callbackList;
 		REQUIRE(callbackList.empty());
@@ -48,7 +48,7 @@ TEST_CASE("HeterCallbackList, empty")
 
 TEST_CASE("HeterCallbackList, forEach")
 {
-	using CL = eventpp::HeterCallbackList<std::tuple<int (), int(int)> >;
+	using CL = eventpp::HeterCallbackList<eventpp::HeterTuple<int (), int(int)> >;
 	CL callbackList;
 
 	callbackList.append([]() { return 1; });
@@ -74,7 +74,7 @@ TEST_CASE("HeterCallbackList, forEach")
 
 TEST_CASE("HeterCallbackList, forEachIf")
 {
-	using CL = eventpp::HeterCallbackList<std::tuple<void (), void(int)> >;
+	using CL = eventpp::HeterCallbackList<eventpp::HeterTuple<void (), void(int)> >;
 	CL callbackList;
 
 	std::vector<int> dataListNoArg(3);
@@ -130,7 +130,7 @@ TEST_CASE("HeterCallbackList, forEachIf")
 
 TEST_CASE("HeterCallbackList, invoke")
 {
-	using CL = eventpp::HeterCallbackList<std::tuple<void (), void(int)> >;
+	using CL = eventpp::HeterCallbackList<eventpp::HeterTuple<void (), void(int)> >;
 	CL callbackList;
 
 	std::vector<int> dataListNoArg(3);
diff --git a/tests/unittest/test_heterdispatcher_basic.cpp b/tests/unittest/test_heterdispatcher_basic.cpp
index 38a6fd1..90bef5d 100644
--- a/tests/unittest/test_heterdispatcher_basic.cpp
+++ b/tests/unittest/test_heterdispatcher_basic.cpp
@@ -16,13 +16,9 @@
 #include "eventpp/mixins/mixinfilter.h"
 #include "eventpp/mixins/mixinheterfilter.h"
 
-using namespace eventpp;
-using namespace eventpp::internal_;
-static_assert(FindPrototypeByCallable<std::tuple<void(), void(int)>, void(int)>::index == 1, "aaa");
-
 TEST_CASE("HeterEventDispatcher, 1")
 {
-	eventpp::HeterEventDispatcher<int, std::tuple<void (), void (int, int, int)> > dispatcher;
+	eventpp::HeterEventDispatcher<int, eventpp::HeterTuple<void (), void (int, int, int)> > dispatcher;
 
 	std::array<int, 2> dataList{};
 
@@ -57,13 +53,14 @@ TEST_CASE("HeterEventDispatcher, 1")
 	REQUIRE(dataList[1] == 24);
 }
 
+#if 0
 TEST_CASE("HeterEventDispatcher, event filter")
 {
 	struct MyPolicies {
 		using Mixins = eventpp::MixinList<eventpp::MixinHeterFilter>;
 		using ArgumentPassingMode = eventpp::ArgumentPassingIncludeEvent;
 	};
-	using ED = eventpp::HeterEventDispatcher<int, std::tuple<void (int, int), void (int)>, MyPolicies>;
+	using ED = eventpp::HeterEventDispatcher<int, eventpp::HeterTuple<void (int, int), void (int)>, MyPolicies>;
 	ED dispatcher;
 
 	constexpr int itemCount = 5;
@@ -181,3 +178,4 @@ TEST_CASE("HeterEventDispatcher, event filter")
 
 }
 
+#endif
diff --git a/tests/unittest/test_heterqueue_basic.cpp b/tests/unittest/test_heterqueue_basic.cpp
index 9fe90bd..1409bc9 100644
--- a/tests/unittest/test_heterqueue_basic.cpp
+++ b/tests/unittest/test_heterqueue_basic.cpp
@@ -16,7 +16,7 @@
 
 TEST_CASE("HeterEventQueue 1")
 {
-	eventpp::HeterEventQueue<std::string, std::tuple<void (), void (const std::string &)> > queue;
+	eventpp::HeterEventQueue<std::string, eventpp::HeterTuple<void (), void (const std::string &)> > queue;
 
 	int a = 1;
 	int b = 5;
@@ -49,7 +49,7 @@ TEST_CASE("HeterEventQueue, processIf")
 		using ArgumentPassingMode = eventpp::ArgumentPassingIncludeEvent;
 	};
 
-	eventpp::HeterEventQueue<int, std::tuple<void (int), void (int, int)>, MyEventPolicies> queue;
+	eventpp::HeterEventQueue<int, eventpp::HeterTuple<void (int), void (int, int)>, MyEventPolicies> queue;
 
 	std::vector<int> dataList(3);
 

From e970856b31ca4f1d9f441d848fa35445768397b5 Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Thu, 28 Mar 2019 23:15:01 +0800
Subject: [PATCH 23/38] Improved MixinHeterFilter

---
 include/eventpp/hetercallbacklist.h           | 33 +++++++++----
 include/eventpp/hetereventdispatcher.h        |  5 +-
 .../eventpp/internal/hetercallbacklist_i.h    | 46 +++++++++++++++++++
 include/eventpp/mixins/mixinheterfilter.h     | 22 ++++++++-
 .../unittest/test_hetercallbacklist_basic.cpp |  4 +-
 tests/unittest/test_heterdispatcher_basic.cpp |  2 +
 6 files changed, 97 insertions(+), 15 deletions(-)

diff --git a/include/eventpp/hetercallbacklist.h b/include/eventpp/hetercallbacklist.h
index ae9dadf..27233a9 100644
--- a/include/eventpp/hetercallbacklist.h
+++ b/include/eventpp/hetercallbacklist.h
@@ -176,6 +176,19 @@ class HeterCallbackListBase
 		};
 	}
 
+	template <typename C>
+	Handle insert(const C & callback, const Handle & before)
+	{
+		using PrototypeInfo = FindPrototypeByCallable<PrototypeList_, C>;
+		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
+
+		auto callbackList= doGetCallbackList<PrototypeInfo>();
+		return Handle {
+			PrototypeInfo::index,
+			callbackList->insert(callback, before)
+		};
+	}
+
 	bool remove(const Handle handle)
 	{
 		auto callbackList = callbackListList[handle.index];
@@ -195,7 +208,7 @@ class HeterCallbackListBase
 		auto callbackList= doGetCallbackList<PrototypeInfo>();
 		using CL = typename decltype(callbackList)::element_type;
 		callbackList->forEach([this, &func](const typename CL::Handle & handle, const typename CL::Callback & callback) {
-			doForEachInvoke<void, CL, PrototypeInfo::index>(func, handle, callback);
+			doForEachInvoke<void, PrototypeInfo::index>(func, handle, callback);
 		});
 	}
 
@@ -208,7 +221,7 @@ class HeterCallbackListBase
 		auto callbackList= doGetCallbackList<PrototypeInfo>();
 		using CL = typename decltype(callbackList)::element_type;
 		return callbackList->forEachIf([this, &func](const typename CL::Handle & handle, const typename CL::Callback & callback) {
-			return doForEachInvoke<bool, CL, PrototypeInfo::index>(func, handle, callback);
+			return doForEachInvoke<bool, PrototypeInfo::index>(func, handle, callback);
 		});
 	}
 
@@ -223,23 +236,23 @@ class HeterCallbackListBase
 	}
 
 private:
-	template <typename RT, typename CL, int PrototypeIndex, typename Func>
-	auto doForEachInvoke(Func && func, const typename CL::Handle & handle, const typename CL::Callback & callback) const
-		-> typename std::enable_if<CanInvoke<Func, Handle, typename CL::Callback &>::value, RT>::type
+	template <typename RT, int PrototypeIndex, typename Func, typename H, typename CL>
+	auto doForEachInvoke(Func && func, const H & handle, CL && callback) const
+		-> typename std::enable_if<CanInvoke<Func, Handle, CL>::value, RT>::type
 	{
 		return func(Handle { PrototypeIndex, handle }, callback);
 	}
 
-	template <typename RT, typename CL, int PrototypeIndex, typename Func>
-	auto doForEachInvoke(Func && func, const typename CL::Handle & handle, const typename CL::Callback & callback) const
+	template <typename RT, int PrototypeIndex, typename Func, typename H, typename CL>
+	auto doForEachInvoke(Func && func, const H & handle, const CL & callback) const
 		-> typename std::enable_if<CanInvoke<Func, Handle>::value, RT>::type
 	{
 		return func(Handle { PrototypeIndex, handle });
 	}
 
-	template <typename RT, typename CL, int PrototypeIndex, typename Func>
-	auto doForEachInvoke(Func && func, const typename CL::Handle & handle, const typename CL::Callback & callback) const
-		-> typename std::enable_if<CanInvoke<Func, typename CL::Callback &>::value, RT>::type
+	template <typename RT, int PrototypeIndex, typename Func, typename H, typename CL>
+	auto doForEachInvoke(Func && func, const H & handle, CL && callback) const
+		-> typename std::enable_if<CanInvoke<Func, CL>::value, RT>::type
 	{
 		return func(callback);
 	}
diff --git a/include/eventpp/hetereventdispatcher.h b/include/eventpp/hetereventdispatcher.h
index 8a3c5de..f39b0b4 100644
--- a/include/eventpp/hetereventdispatcher.h
+++ b/include/eventpp/hetereventdispatcher.h
@@ -242,6 +242,7 @@ class HeterEventDispatcherBase
 	{
 		if(! internal_::ForEachMixins<MixinRoot, Mixins, DoMixinBeforeDispatch>::forEach(
 			this,
+			typename std::add_lvalue_reference<T>::type(first),
 			typename std::add_lvalue_reference<Args>::type(args)...)
 		) {
 			return;
@@ -251,7 +252,7 @@ class HeterEventDispatcherBase
 		const auto e = GetEvent::getEvent(std::forward<T>(first), args...);
 		const CallbackList_ * callableList = doFindCallableList(e);
 		if(callableList) {
-			(*callableList)(std::forward<T>(first), std::forward<T>(first), std::forward<Args>(args)...);
+			(*callableList)(std::forward<T>(first), std::forward<Args>(args)...);
 		}
 	}
 
@@ -260,7 +261,7 @@ class HeterEventDispatcherBase
 		-> typename std::enable_if<std::is_same<ArgumentMode, ArgumentPassingExcludeEvent>::value>::type
 	{
 		if(! internal_::ForEachMixins<MixinRoot, Mixins, DoMixinBeforeDispatch>::forEach(
-			this, typename std::add_lvalue_reference<T>::type(first),
+			this,
 			typename std::add_lvalue_reference<Args>::type(args)...)
 		) {
 			return;
diff --git a/include/eventpp/internal/hetercallbacklist_i.h b/include/eventpp/internal/hetercallbacklist_i.h
index 3edf6fc..ab7e8c5 100644
--- a/include/eventpp/internal/hetercallbacklist_i.h
+++ b/include/eventpp/internal/hetercallbacklist_i.h
@@ -238,6 +238,52 @@ struct GetCallablePrototypeMaxSize <HeterTuple<>, Record>
 	enum { value = 1 }; // set minimum size to 1 instead of 0
 };
 
+template <typename List, typename Item>
+struct PrependHeterTuple;
+
+template <typename Item, typename ...Types>
+struct PrependHeterTuple <HeterTuple<Types...>, Item>
+{
+	using Type = HeterTuple<Item, Types...>;
+};
+
+template <typename List, typename Replacement>
+struct ReplaceReturnTypeList;
+
+template <typename Replacement, typename RT, typename ...Args, typename ...Others>
+struct ReplaceReturnTypeList <HeterTuple<RT (Args...), Others...>, Replacement>
+{
+	using Type = typename PrependHeterTuple<
+		typename ReplaceReturnTypeList<HeterTuple<Others...>, Replacement>::Type,
+		Replacement (Args...)
+	>::Type;
+};
+
+template <typename Replacement>
+struct ReplaceReturnTypeList <HeterTuple<>, Replacement>
+{
+	using Type = HeterTuple<>;
+};
+
+template <typename F, template <typename> class T>
+struct TransformArgumentsList;
+
+template <template <typename> class T, typename RT, typename ...Args, typename ...Others>
+struct TransformArgumentsList <HeterTuple<RT (Args...), Others...>, T>
+{
+	using Type = typename PrependHeterTuple<
+		typename TransformArgumentsList<HeterTuple<Others...>, T>::Type,
+		RT (typename T<Args>::type...)
+	>::Type;
+};
+
+template <template <typename> class T>
+struct TransformArgumentsList <HeterTuple<>, T>
+{
+	using Type = HeterTuple<>;
+};
+
+
 } //namespace internal_
 
 
diff --git a/include/eventpp/mixins/mixinheterfilter.h b/include/eventpp/mixins/mixinheterfilter.h
index 27ed793..3a71183 100644
--- a/include/eventpp/mixins/mixinheterfilter.h
+++ b/include/eventpp/mixins/mixinheterfilter.h
@@ -28,7 +28,15 @@ class MixinHeterFilter : public Base
 private:
 	using super = Base;
 
-	using FilterList = HeterCallbackList<typename super::PrototypeList>;
+	using BoolReferencePrototypeList = typename internal_::ReplaceReturnTypeList<
+		typename internal_::TransformArgumentsList<
+			typename super::PrototypeList,
+			std::add_lvalue_reference
+		>::Type,
+		bool
+	>::Type;
+
+	using FilterList = HeterCallbackList<BoolReferencePrototypeList>;
 
 public:
 	using FilterHandle = typename FilterList::Handle;
@@ -45,6 +53,18 @@ class MixinHeterFilter : public Base
 		return filterList.remove(filterHandle);
 	}
 
+	template <typename ...Args>
+	bool mixinBeforeDispatch(Args && ...args) const {
+		if(! filterList.template forEachIf<void (Args...)>([&args...](typename std::function<bool (Args...)> & callback) -> bool {
+			return callback(args...);
+		})
+			) {
+			return false;
+		}
+
+		return true;
+	}
+
 private:
 	FilterList filterList;
 };
diff --git a/tests/unittest/test_hetercallbacklist_basic.cpp b/tests/unittest/test_hetercallbacklist_basic.cpp
index 601edaf..6b6937a 100644
--- a/tests/unittest/test_hetercallbacklist_basic.cpp
+++ b/tests/unittest/test_hetercallbacklist_basic.cpp
@@ -18,7 +18,7 @@
 
 TEST_CASE("HeterCallbackList, empty")
 {
-	using CL = eventpp::HeterCallbackList<eventpp::HeterTuple<void (), void (int, int, int)> >;
+	using CL = eventpp::HeterCallbackList<eventpp::HeterTuple<void (), void (int)> >;
 	SECTION("empty") {
 		CL callbackList;
 		REQUIRE(callbackList.empty());
@@ -32,7 +32,7 @@ TEST_CASE("HeterCallbackList, empty")
 
 	SECTION("prepend") {
 		CL callbackList;
-		callbackList.prepend([](){});
+		callbackList.prepend([](int){});
 		REQUIRE(! callbackList.empty());
 	}
 
diff --git a/tests/unittest/test_heterdispatcher_basic.cpp b/tests/unittest/test_heterdispatcher_basic.cpp
index 90bef5d..244d5e4 100644
--- a/tests/unittest/test_heterdispatcher_basic.cpp
+++ b/tests/unittest/test_heterdispatcher_basic.cpp
@@ -179,3 +179,5 @@ TEST_CASE("HeterEventDispatcher, event filter")
 }
 
 #endif
+
+

From 798a71a7237f4a67c3c46bb9f8a60cac239200f7 Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Fri, 29 Mar 2019 09:19:56 +0800
Subject: [PATCH 24/38] Made MixinHeterFilter compilable.

---
 include/eventpp/mixins/mixinheterfilter.h     | 4 ++--
 tests/unittest/test_heterdispatcher_basic.cpp | 4 ----
 2 files changed, 2 insertions(+), 6 deletions(-)

diff --git a/include/eventpp/mixins/mixinheterfilter.h b/include/eventpp/mixins/mixinheterfilter.h
index 3a71183..22a42ca 100644
--- a/include/eventpp/mixins/mixinheterfilter.h
+++ b/include/eventpp/mixins/mixinheterfilter.h
@@ -55,8 +55,8 @@ class MixinHeterFilter : public Base
 
 	template <typename ...Args>
 	bool mixinBeforeDispatch(Args && ...args) const {
-		if(! filterList.template forEachIf<void (Args...)>([&args...](typename std::function<bool (Args...)> & callback) -> bool {
-			return callback(args...);
+		if(! filterList.template forEachIf<void (Args...)>([&args...](const typename std::function<bool (Args...)> & callback) -> bool {
+			return callback(std::forward<Args>(args)...);
 		})
 			) {
 			return false;
diff --git a/tests/unittest/test_heterdispatcher_basic.cpp b/tests/unittest/test_heterdispatcher_basic.cpp
index 244d5e4..66836d7 100644
--- a/tests/unittest/test_heterdispatcher_basic.cpp
+++ b/tests/unittest/test_heterdispatcher_basic.cpp
@@ -53,7 +53,6 @@ TEST_CASE("HeterEventDispatcher, 1")
 	REQUIRE(dataList[1] == 24);
 }
 
-#if 0
 TEST_CASE("HeterEventDispatcher, event filter")
 {
 	struct MyPolicies {
@@ -178,6 +177,3 @@ TEST_CASE("HeterEventDispatcher, event filter")
 
 }
 
-#endif
-
-

From 492a3f93c2965569f63b57c2dcac1255207e6736 Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Fri, 29 Mar 2019 12:28:55 +0800
Subject: [PATCH 25/38] Added unit tests

---
 include/eventpp/hetercallbacklist.h           |  15 ++-
 include/eventpp/hetereventdispatcher.h        |  34 ------
 include/eventpp/hetereventqueue.h             |   8 +-
 .../unittest/test_hetercallbacklist_basic.cpp | 103 ++++++++++++++++++
 4 files changed, 123 insertions(+), 37 deletions(-)

diff --git a/include/eventpp/hetercallbacklist.h b/include/eventpp/hetercallbacklist.h
index 27233a9..518652c 100644
--- a/include/eventpp/hetercallbacklist.h
+++ b/include/eventpp/hetercallbacklist.h
@@ -183,9 +183,22 @@ class HeterCallbackListBase
 		static_assert(PrototypeInfo::index >= 0, "Can't find invoker for the given argument types.");
 
 		auto callbackList= doGetCallbackList<PrototypeInfo>();
+
+		if(before.index != PrototypeInfo::index) {
+			return Handle {
+				PrototypeInfo::index,
+				callbackList->append(callback)
+			};
+		}
+
+		using UnderlyingHandle = typename decltype(callbackList)::element_type::Handle;
+
 		return Handle {
 			PrototypeInfo::index,
-			callbackList->insert(callback, before)
+			callbackList->insert(
+				callback,
+				UnderlyingHandle(std::static_pointer_cast<typename UnderlyingHandle::element_type>(before.homoHandle.lock()))
+			)
 		};
 	}
 
diff --git a/include/eventpp/hetereventdispatcher.h b/include/eventpp/hetereventdispatcher.h
index f39b0b4..40a324c 100644
--- a/include/eventpp/hetereventdispatcher.h
+++ b/include/eventpp/hetereventdispatcher.h
@@ -20,50 +20,16 @@
 #include "mixins/mixinfilter.h"
 
 #include <array>
-#include <string>
 #include <functional>
 #include <type_traits>
 #include <mutex>
 #include <memory>
 #include <tuple>
 
-// source code for heterogeneous dispatcher
-
 namespace eventpp {
 
 namespace internal_ {
 
-template <template <typename> class MixinA, template <typename> class MixinB>
-struct IsSameMixin
-{
-	enum { value = false };
-};
-
-template <template <typename> class MixinA>
-struct IsSameMixin <MixinA, MixinA>
-{
-	enum { value = true };
-};
-
-template <typename MList, template <typename> class ...UnderlyingMixins>
-struct BuildHeterUnderlyingMixinList;
-
-template <template <typename> class First, template <typename> class ...Mixins, template <typename> class ...UnderlyingMixins>
-struct BuildHeterUnderlyingMixinList <MixinList<First, Mixins...>, UnderlyingMixins...>
-{
-	using Type = typename std::conditional<
-		IsSameMixin<First, MixinHeterFilter>::value,
-		typename BuildHeterUnderlyingMixinList<MixinList<Mixins...>, UnderlyingMixins..., MixinFilter>::Type,
-		typename BuildHeterUnderlyingMixinList<MixinList<Mixins...>, UnderlyingMixins..., First>::Type
-	>::type;
-};
-
-template <template <typename> class ...UnderlyingMixins>
-struct BuildHeterUnderlyingMixinList <MixinList<>, UnderlyingMixins...>
-{
-	using Type = MixinList<UnderlyingMixins...>;
-};
-
 template <
 	typename EventType_,
 	typename PrototypeList_,
diff --git a/include/eventpp/hetereventqueue.h b/include/eventpp/hetereventqueue.h
index a7c1dfa..c87f026 100644
--- a/include/eventpp/hetereventqueue.h
+++ b/include/eventpp/hetereventqueue.h
@@ -284,11 +284,12 @@ class HeterEventQueueBase : public HeterEventDispatcherBase<
 		}
 
 		if(! tempList.empty()) {
-			for(auto it = tempList.begin(); it != tempList.end(); ++it) {
+			for(auto it = tempList.begin(); it != tempList.end(); ) {
 				using ArgsTuple = typename PrototypeInfo::ArgsTuple;
 				auto item = it->template get<QueuedItem<ArgsTuple> >();
 
 				if(item.callableIndex != PrototypeInfo::index) {
+					++it;
 					continue;
 				}
 				if(doInvokeFuncWithQueuedEvent(
@@ -300,9 +301,12 @@ class HeterEventQueueBase : public HeterEventDispatcherBase<
 					it->clear();
 
 					auto tempIt = it;
-					--it;
+					++it;
 					idleList.splice(idleList.end(), tempList, tempIt);
 				}
+				else {
+					++it;
+				}
 			}
 
 			if (! tempList.empty()) {
diff --git a/tests/unittest/test_hetercallbacklist_basic.cpp b/tests/unittest/test_hetercallbacklist_basic.cpp
index 6b6937a..c757fdc 100644
--- a/tests/unittest/test_hetercallbacklist_basic.cpp
+++ b/tests/unittest/test_hetercallbacklist_basic.cpp
@@ -46,6 +46,109 @@ TEST_CASE("HeterCallbackList, empty")
 	}
 }
 
+TEST_CASE("HeterCallbackList, append")
+{
+	using CL = eventpp::HeterCallbackList<eventpp::HeterTuple<void (), void (int)> >;
+	CL callbackList;
+
+	std::vector<int> orderList(5);
+
+	int order;
+
+	callbackList.append([&orderList, &order]() {
+		orderList[order++] = 1;
+	});
+	callbackList.append([&orderList, &order]() {
+		orderList[order++] = 2;
+	});
+	callbackList.append([&orderList, &order](int) {
+		orderList[order++] = 3;
+	});
+	callbackList.append([&orderList, &order](int) {
+		orderList[order++] = 4;
+	});
+	callbackList.append([&orderList, &order](int) {
+		orderList[order++] = 5;
+	});
+
+	REQUIRE(orderList == std::vector<int>{ 0, 0, 0, 0, 0 });
+
+	order = 0;
+	callbackList(3);
+	REQUIRE(orderList == std::vector<int>{ 3, 4, 5, 0, 0 });
+	callbackList();
+	REQUIRE(orderList == std::vector<int>{ 3, 4, 5, 1, 2 });
+}
+
+TEST_CASE("HeterCallbackList, prepend")
+{
+	using CL = eventpp::HeterCallbackList<eventpp::HeterTuple<void (), void (int)> >;
+	CL callbackList;
+
+	std::vector<int> orderList(5);
+
+	int order;
+
+	callbackList.prepend([&orderList, &order]() {
+		orderList[order++] = 1;
+	});
+	callbackList.prepend([&orderList, &order]() {
+		orderList[order++] = 2;
+	});
+	callbackList.prepend([&orderList, &order](int) {
+		orderList[order++] = 3;
+	});
+	callbackList.prepend([&orderList, &order](int) {
+		orderList[order++] = 4;
+	});
+	callbackList.prepend([&orderList, &order](int) {
+		orderList[order++] = 5;
+	});
+
+	REQUIRE(orderList == std::vector<int>{ 0, 0, 0, 0, 0 });
+
+	order = 0;
+	callbackList(3);
+	REQUIRE(orderList == std::vector<int>{ 5, 4, 3, 0, 0 });
+	callbackList();
+	REQUIRE(orderList == std::vector<int>{ 5, 4, 3, 2, 1 });
+}
+
+TEST_CASE("HeterCallbackList, insert")
+{
+	using CL = eventpp::HeterCallbackList<eventpp::HeterTuple<void (), void (int)> >;
+	CL callbackList;
+
+	std::vector<int> orderList(5);
+
+	int order;
+
+	auto h1 = callbackList.append([&orderList, &order]() {
+		orderList[order++] = 1;
+	});
+	callbackList.insert([&orderList, &order]() {
+		orderList[order++] = 2;
+	}, h1);
+	
+	auto h2 = callbackList.append([&orderList, &order](int) {
+		orderList[order++] = 3;
+	});
+	callbackList.insert([&orderList, &order](int) {
+		orderList[order++] = 4;
+	}, h2);
+	callbackList.insert([&orderList, &order](int) {
+		orderList[order++] = 5;
+	}, h2);
+
+	REQUIRE(orderList == std::vector<int>{ 0, 0, 0, 0, 0 });
+
+	order = 0;
+	callbackList(3);
+	REQUIRE(orderList == std::vector<int>{ 4, 5, 3, 0, 0 });
+	callbackList();
+	REQUIRE(orderList == std::vector<int>{ 4, 5, 3, 2, 1 });
+}
+
 TEST_CASE("HeterCallbackList, forEach")
 {
 	using CL = eventpp::HeterCallbackList<eventpp::HeterTuple<int (), int(int)> >;

From b10554b91991e0603b331ff84e6699090b9a519d Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Fri, 29 Mar 2019 22:32:25 +0800
Subject: [PATCH 26/38] Added unit tests

---
 include/eventpp/hetereventdispatcher.h        |   4 +-
 include/eventpp/hetereventqueue.h             |  29 +-
 .../unittest/test_hetercallbacklist_basic.cpp |  62 +++
 tests/unittest/test_heterdispatcher_basic.cpp | 359 ++++++++++++++++--
 tests/unittest/test_heterqueue_basic.cpp      | 163 +++++++-
 5 files changed, 569 insertions(+), 48 deletions(-)

diff --git a/include/eventpp/hetereventdispatcher.h b/include/eventpp/hetereventdispatcher.h
index 40a324c..65907a6 100644
--- a/include/eventpp/hetereventdispatcher.h
+++ b/include/eventpp/hetereventdispatcher.h
@@ -203,7 +203,7 @@ class HeterEventDispatcherBase
 
 protected:
 	template <typename ArgumentMode, typename T, typename ...Args>
-	auto doDispatch(T && first, Args ...args) const
+	auto doDispatch(T && first, Args && ...args) const
 		-> typename std::enable_if<std::is_same<ArgumentMode, ArgumentPassingIncludeEvent>::value>::type
 	{
 		if(! internal_::ForEachMixins<MixinRoot, Mixins, DoMixinBeforeDispatch>::forEach(
@@ -223,7 +223,7 @@ class HeterEventDispatcherBase
 	}
 
 	template <typename ArgumentMode, typename T, typename ...Args>
-	auto doDispatch(T && first, Args ...args) const
+	auto doDispatch(T && first, Args && ...args) const
 		-> typename std::enable_if<std::is_same<ArgumentMode, ArgumentPassingExcludeEvent>::value>::type
 	{
 		if(! internal_::ForEachMixins<MixinRoot, Mixins, DoMixinBeforeDispatch>::forEach(
diff --git a/include/eventpp/hetereventqueue.h b/include/eventpp/hetereventqueue.h
index c87f026..ad743c1 100644
--- a/include/eventpp/hetereventqueue.h
+++ b/include/eventpp/hetereventqueue.h
@@ -134,7 +134,7 @@ class HeterEventQueueBase : public HeterEventDispatcherBase<
 	}
 
 	template <typename T, typename ...Args>
-	void enqueue(T && first, Args ...args)
+	void enqueue(T && first, Args && ...args)
 	{
 		doEnqueue<ArgumentPassingMode>(std::forward<T>(first), std::forward<Args>(args)...);
 	}
@@ -144,6 +144,27 @@ class HeterEventQueueBase : public HeterEventDispatcherBase<
 		return queueList.empty() && (queueEmptyCounter.load(std::memory_order_acquire) == 0);
 	}
 
+	void clearEvents()
+	{
+		if(! queueList.empty()) {
+			BufferedItemList tempList;
+
+			{
+				std::lock_guard<Mutex> queueListLock(queueListMutex);
+				std::swap(queueList, tempList);
+			}
+
+			if(! tempList.empty()) {
+				for(auto & item : tempList) {
+					item.clear();
+				}
+
+				std::lock_guard<Mutex> queueListLock(freeListMutex);
+				freeList.splice(freeList.end(), tempList);
+			}
+		}
+	}
+
 	bool process()
 	{
 		if(! queueList.empty()) {
@@ -344,13 +365,13 @@ class HeterEventQueueBase : public HeterEventDispatcherBase<
 	}
 
 	template <typename F, typename ...Args>
-	bool doInvokeFuncWithQueuedEventHelper(F && func, Args ...args) const
+	bool doInvokeFuncWithQueuedEventHelper(F && func, Args && ...args) const
 	{
 		return func(std::forward<Args>(args)...);
 	}
 
 	template <typename ArgumentMode, typename T, typename ...Args>
-	auto doEnqueue(T && first, Args ...args)
+	auto doEnqueue(T && first, Args && ...args)
 		-> typename std::enable_if<std::is_same<ArgumentMode, ArgumentPassingIncludeEvent>::value>::type
 	{
 		using GetEvent = typename SelectGetEvent<Policies_, EventType_, HasFunctionGetEvent<Policies_, T &&, Args...>::value>::Type;
@@ -373,7 +394,7 @@ class HeterEventQueueBase : public HeterEventDispatcherBase<
 	}
 
 	template <typename ArgumentMode, typename T, typename ...Args>
-	auto doEnqueue(T && first, Args ...args)
+	auto doEnqueue(T && first, Args && ...args)
 		-> typename std::enable_if<std::is_same<ArgumentMode, ArgumentPassingExcludeEvent>::value>::type
 	{
 		using GetEvent = typename SelectGetEvent<Policies_, EventType_, HasFunctionGetEvent<Policies_, T &&, Args...>::value>::Type;
diff --git a/tests/unittest/test_hetercallbacklist_basic.cpp b/tests/unittest/test_hetercallbacklist_basic.cpp
index c757fdc..5607a0c 100644
--- a/tests/unittest/test_hetercallbacklist_basic.cpp
+++ b/tests/unittest/test_hetercallbacklist_basic.cpp
@@ -149,6 +149,68 @@ TEST_CASE("HeterCallbackList, insert")
 	REQUIRE(orderList == std::vector<int>{ 4, 5, 3, 2, 1 });
 }
 
+TEST_CASE("HeterCallbackList, remove")
+{
+	using CL = eventpp::HeterCallbackList<eventpp::HeterTuple<void (), void (int)> >;
+	CL callbackList;
+
+	std::vector<int> dataList(5);
+
+	auto h1 = callbackList.append([&dataList]() {
+		++dataList[0];
+	});
+	auto h2 = callbackList.append([&dataList]() {
+		++dataList[1];
+	});
+	auto h3 = callbackList.append([&dataList](int) {
+		++dataList[2];
+	});
+	auto h4 = callbackList.append([&dataList](int) {
+		++dataList[3];
+	});
+	auto h5 = callbackList.append([&dataList](int) {
+		++dataList[4];
+	});
+
+	REQUIRE(dataList == std::vector<int>{ 0, 0, 0, 0, 0 });
+
+	callbackList(3);
+	REQUIRE(dataList == std::vector<int>{ 0, 0, 1, 1, 1 });
+	callbackList();
+	REQUIRE(dataList == std::vector<int>{ 1, 1, 1, 1, 1 });
+
+	callbackList.remove(h2);
+	callbackList(3);
+	callbackList();
+	REQUIRE(dataList == std::vector<int>{ 2, 1, 2, 2, 2 });
+
+	// double remove, no effect
+	callbackList.remove(h2);
+	callbackList(3);
+	callbackList();
+	REQUIRE(dataList == std::vector<int>{ 3, 1, 3, 3, 3 });
+
+	callbackList.remove(h3);
+	callbackList(3);
+	callbackList();
+	REQUIRE(dataList == std::vector<int>{ 4, 1, 3, 4, 4 });
+
+	callbackList.remove(h5);
+	callbackList(3);
+	callbackList();
+	REQUIRE(dataList == std::vector<int>{ 5, 1, 3, 5, 4 });
+
+	callbackList.remove(h1);
+	callbackList(3);
+	callbackList();
+	REQUIRE(dataList == std::vector<int>{ 5, 1, 3, 6, 4 });
+
+	callbackList.remove(h4);
+	callbackList(3);
+	callbackList();
+	REQUIRE(dataList == std::vector<int>{ 5, 1, 3, 6, 4 });
+}
+
 TEST_CASE("HeterCallbackList, forEach")
 {
 	using CL = eventpp::HeterCallbackList<eventpp::HeterTuple<int (), int(int)> >;
diff --git a/tests/unittest/test_heterdispatcher_basic.cpp b/tests/unittest/test_heterdispatcher_basic.cpp
index 66836d7..f2c348e 100644
--- a/tests/unittest/test_heterdispatcher_basic.cpp
+++ b/tests/unittest/test_heterdispatcher_basic.cpp
@@ -16,41 +16,352 @@
 #include "eventpp/mixins/mixinfilter.h"
 #include "eventpp/mixins/mixinheterfilter.h"
 
-TEST_CASE("HeterEventDispatcher, 1")
+TEST_CASE("HeterEventDispatcher, appendListener")
 {
-	eventpp::HeterEventDispatcher<int, eventpp::HeterTuple<void (), void (int, int, int)> > dispatcher;
+	eventpp::HeterEventDispatcher<int, eventpp::HeterTuple<void (), void (int)> > dispatcher;
+	constexpr int event = 3;
 
-	std::array<int, 2> dataList{};
+	std::vector<int> orderList(5);
 
-	dispatcher.appendListener(3, [&dataList]() {
+	int order;
+
+	dispatcher.appendListener(event, [&orderList, &order]() {
+		orderList[order++] = 1;
+	});
+	dispatcher.appendListener(event, [&orderList, &order]() {
+		orderList[order++] = 2;
+	});
+	dispatcher.appendListener(event, [&orderList, &order](int) {
+		orderList[order++] = 3;
+	});
+	dispatcher.appendListener(event, [&orderList, &order](int) {
+		orderList[order++] = 4;
+	});
+	dispatcher.appendListener(event, [&orderList, &order](int) {
+		orderList[order++] = 5;
+	});
+
+	REQUIRE(orderList == std::vector<int>{ 0, 0, 0, 0, 0 });
+
+	order = 0;
+	dispatcher.dispatch(event, 3);
+	REQUIRE(orderList == std::vector<int>{ 3, 4, 5, 0, 0 });
+	dispatcher.dispatch(event);
+	REQUIRE(orderList == std::vector<int>{ 3, 4, 5, 1, 2 });
+}
+
+TEST_CASE("HeterEventDispatcher, prependListener")
+{
+	eventpp::HeterEventDispatcher<int, eventpp::HeterTuple<void (), void (int)> > dispatcher;
+	constexpr int event = 3;
+
+	std::vector<int> orderList(5);
+
+	int order;
+
+	dispatcher.prependListener(event, [&orderList, &order]() {
+		orderList[order++] = 1;
+	});
+	dispatcher.prependListener(event, [&orderList, &order]() {
+		orderList[order++] = 2;
+	});
+	dispatcher.prependListener(event, [&orderList, &order](int) {
+		orderList[order++] = 3;
+	});
+	dispatcher.prependListener(event, [&orderList, &order](int) {
+		orderList[order++] = 4;
+	});
+	dispatcher.prependListener(event, [&orderList, &order](int) {
+		orderList[order++] = 5;
+	});
+
+	REQUIRE(orderList == std::vector<int>{ 0, 0, 0, 0, 0 });
+
+	order = 0;
+	dispatcher.dispatch(event, 3);
+	REQUIRE(orderList == std::vector<int>{ 5, 4, 3, 0, 0 });
+	dispatcher.dispatch(event);
+	REQUIRE(orderList == std::vector<int>{ 5, 4, 3, 2, 1 });
+}
+
+TEST_CASE("HeterEventDispatcher, insertListener")
+{
+	eventpp::HeterEventDispatcher<int, eventpp::HeterTuple<void (), void (int)> > dispatcher;
+	constexpr int event = 3;
+
+	std::vector<int> orderList(5);
+
+	int order;
+
+	auto h1 = dispatcher.appendListener(event, [&orderList, &order]() {
+		orderList[order++] = 1;
+	});
+	dispatcher.insertListener(event, [&orderList, &order]() {
+		orderList[order++] = 2;
+	}, h1);
+
+	auto h2 = dispatcher.appendListener(event, [&orderList, &order](int) {
+		orderList[order++] = 3;
+	});
+	dispatcher.insertListener(event, [&orderList, &order](int) {
+		orderList[order++] = 4;
+	}, h2);
+	dispatcher.insertListener(event, [&orderList, &order](int) {
+		orderList[order++] = 5;
+	}, h2);
+
+	REQUIRE(orderList == std::vector<int>{ 0, 0, 0, 0, 0 });
+
+	order = 0;
+	dispatcher.dispatch(event, 3);
+	REQUIRE(orderList == std::vector<int>{ 4, 5, 3, 0, 0 });
+	dispatcher.dispatch(event);
+	REQUIRE(orderList == std::vector<int>{ 4, 5, 3, 2, 1 });
+}
+
+TEST_CASE("HeterEventDispatcher, removeListener")
+{
+	eventpp::HeterEventDispatcher<int, eventpp::HeterTuple<void (), void (int)> > dispatcher;
+	constexpr int event = 3;
+
+	std::vector<int> dataList(5);
+
+	auto h1 = dispatcher.appendListener(event, [&dataList]() {
 		++dataList[0];
 	});
-	dispatcher.appendListener(3, [&dataList](const FromInt & a, int b, int c) -> int {
-		dataList[1] += a.value + b + c;
-		return 0;
+	auto h2 = dispatcher.appendListener(event, [&dataList]() {
+		++dataList[1];
+	});
+	auto h3 = dispatcher.appendListener(event, [&dataList](int) {
+		++dataList[2];
 	});
-	dispatcher.appendListener(8, [&dataList](int a, int b, int c) {
-		dataList[1] += a + b + c;
+	auto h4 = dispatcher.appendListener(event, [&dataList](int) {
+		++dataList[3];
 	});
-	
-	REQUIRE(dataList[0] == 0);
-	REQUIRE(dataList[1] == 0);
+	auto h5 = dispatcher.appendListener(event, [&dataList](int) {
+		++dataList[4];
+	});
+
+	REQUIRE(dataList == std::vector<int>{ 0, 0, 0, 0, 0 });
+
+	dispatcher.dispatch(event, 3);
+	REQUIRE(dataList == std::vector<int>{ 0, 0, 1, 1, 1 });
+	dispatcher.dispatch(event);
+	REQUIRE(dataList == std::vector<int>{ 1, 1, 1, 1, 1 });
+
+	dispatcher.removeListener(event, h2);
+	dispatcher.dispatch(event, 3);
+	dispatcher.dispatch(event);
+	REQUIRE(dataList == std::vector<int>{ 2, 1, 2, 2, 2 });
+
+	// double remove, no effect
+	dispatcher.removeListener(event, h2);
+	dispatcher.dispatch(event, 3);
+	dispatcher.dispatch(event);
+	REQUIRE(dataList == std::vector<int>{ 3, 1, 3, 3, 3 });
+
+	dispatcher.removeListener(event, h3);
+	dispatcher.dispatch(event, 3);
+	dispatcher.dispatch(event);
+	REQUIRE(dataList == std::vector<int>{ 4, 1, 3, 4, 4 });
+
+	dispatcher.removeListener(event, h5);
+	dispatcher.dispatch(event, 3);
+	dispatcher.dispatch(event);
+	REQUIRE(dataList == std::vector<int>{ 5, 1, 3, 5, 4 });
+
+	dispatcher.removeListener(event, h1);
+	dispatcher.dispatch(event, 3);
+	dispatcher.dispatch(event);
+	REQUIRE(dataList == std::vector<int>{ 5, 1, 3, 6, 4 });
+
+	dispatcher.removeListener(event, h4);
+	dispatcher.dispatch(event, 3);
+	dispatcher.dispatch(event);
+	REQUIRE(dataList == std::vector<int>{ 5, 1, 3, 6, 4 });
+}
+
+TEST_CASE("HeterEventDispatcher, forEach")
+{
+	eventpp::HeterEventDispatcher<int, eventpp::HeterTuple<int (), int (int)> > dispatcher;
+	constexpr int event = 3;
+
+	dispatcher.appendListener(event, []() { return 1; });
+	dispatcher.appendListener(event, []() { return 2; });
+	dispatcher.appendListener(event, []() { return 3; });
+
+	dispatcher.appendListener(event, [](int n) { return n + 5 + 0; });
+	dispatcher.appendListener(event, [](int n) { return n + 5 + 1; });
+	dispatcher.appendListener(event, [](int n) { return n + 5 + 2; });
+
+	int i = 1;
+	dispatcher.forEach<int ()>(event, [&i](const std::function<int ()> & callback) {
+		REQUIRE(callback() == i);
+		++i;
+	});
+
+	i = 0;
+	dispatcher.forEach<int (int)>(event, [&i](const std::function<int (int)> & callback) {
+		REQUIRE(callback(3) == 8 + i);
+		++i;
+	});
+}
+
+TEST_CASE("HeterEventDispatcher, forEachIf")
+{
+	eventpp::HeterEventDispatcher<int, eventpp::HeterTuple<void (), void (int)> > dispatcher;
+	constexpr int event = 3;
+
+	std::vector<int> dataListNoArg(3);
+	std::vector<int> dataListWithArg(3);
+
+	dispatcher.appendListener(event, [&dataListNoArg]() {
+		dataListNoArg[0] += 1;
+	});
+	dispatcher.appendListener(event, [&dataListNoArg]() {
+		dataListNoArg[1] += 2;
+	});
+	dispatcher.appendListener(event, [&dataListNoArg]() {
+		dataListNoArg[2] += 3;
+	});
+
+	dispatcher.appendListener(event, [&dataListWithArg](int n) {
+		dataListWithArg[0] += n;
+	});
+	dispatcher.appendListener(event, [&dataListWithArg](int n) {
+		dataListWithArg[1] += n * 2;
+	});
+	dispatcher.appendListener(event, [&dataListWithArg](int n) {
+		dataListWithArg[2] += n * 3;
+	});
+
+	REQUIRE(dataListNoArg == std::vector<int>{ 0, 0, 0 });
+	REQUIRE(dataListWithArg == std::vector<int>{ 0, 0, 0 });
+
+	int i = 0;
+	bool result = dispatcher.forEachIf<void ()>(event, [&i](const std::function<void ()> & callback) -> bool {
+		callback();
+		++i;
+
+		return i != 2;
+	});
+
+	REQUIRE(! result);
+	REQUIRE(dataListNoArg == std::vector<int>{ 1, 2, 0 });
+	REQUIRE(dataListWithArg == std::vector<int>{ 0, 0, 0 });
+
+	i = 0;
+	result = dispatcher.forEachIf<void (int)>(event, [&i](const std::function<void (int)> & callback) -> bool {
+		callback(3);
+		++i;
+
+		return i != 1;
+	});
+
+	REQUIRE(! result);
+	REQUIRE(dataListNoArg == std::vector<int>{ 1, 2, 0 });
+	REQUIRE(dataListWithArg == std::vector<int>{ 3, 0, 0 });
+}
+
+TEST_CASE("HeterEventDispatcher, invoke")
+{
+	eventpp::HeterEventDispatcher<int, eventpp::HeterTuple<void (), void (int)> > dispatcher;
+	constexpr int event = 3;
+
+	std::vector<int> dataListNoArg(3);
+	std::vector<int> dataListWithArg(3);
+
+	dispatcher.appendListener(event, [&dataListNoArg]() {
+		dataListNoArg[0] += 1;
+	});
+	dispatcher.appendListener(event, [&dataListNoArg]() {
+		dataListNoArg[1] += 2;
+	});
+	dispatcher.appendListener(event, [&dataListNoArg]() {
+		dataListNoArg[2] += 3;
+	});
+
+	dispatcher.appendListener(event, [&dataListWithArg](int n) {
+		dataListWithArg[0] += n;
+	});
+	dispatcher.appendListener(event, [&dataListWithArg](int n) {
+		dataListWithArg[1] += n * 2;
+	});
+	dispatcher.appendListener(event, [&dataListWithArg](int n) {
+		dataListWithArg[2] += n * 3;
+	});
+
+	REQUIRE(dataListNoArg == std::vector<int>{ 0, 0, 0 });
+	REQUIRE(dataListWithArg == std::vector<int>{ 0, 0, 0 });
+
+	dispatcher.dispatch(event);
+	REQUIRE(dataListNoArg == std::vector<int>{ 1, 2, 3 });
+	REQUIRE(dataListWithArg == std::vector<int>{ 0, 0, 0 });
+
+	dispatcher.dispatch(event);
+	REQUIRE(dataListNoArg == std::vector<int>{ 2, 4, 6 });
+	REQUIRE(dataListWithArg == std::vector<int>{ 0, 0, 0 });
+
+	dispatcher.dispatch(event, 1);
+	REQUIRE(dataListNoArg == std::vector<int>{ 2, 4, 6 });
+	REQUIRE(dataListWithArg == std::vector<int>{ 1, 2, 3 });
+
+	dispatcher.dispatch(event, 2);
+	REQUIRE(dataListNoArg == std::vector<int>{ 2, 4, 6 });
+	REQUIRE(dataListWithArg == std::vector<int>{ 3, 6, 9 });
+}
+
+TEST_CASE("HeterEventDispatcher, invoke, ArgumentPassingIncludeEvent")
+{
+	struct EventPolicies
+	{
+		using ArgumentPassingMode = eventpp::ArgumentPassingIncludeEvent;
+	};
+
+	eventpp::HeterEventDispatcher<int, eventpp::HeterTuple<void (int), void (int, int)>, EventPolicies> dispatcher;
+	constexpr int event = 3;
+
+	std::vector<int> dataListNoArg(3);
+	std::vector<int> dataListWithArg(3);
+
+	dispatcher.appendListener(event, [&dataListNoArg](int) {
+		dataListNoArg[0] += 1;
+	});
+	dispatcher.appendListener(event, [&dataListNoArg](int) {
+		dataListNoArg[1] += 2;
+	});
+	dispatcher.appendListener(event, [&dataListNoArg](int) {
+		dataListNoArg[2] += 3;
+	});
+
+	dispatcher.appendListener(event, [&dataListWithArg](int, int n) {
+		dataListWithArg[0] += n;
+	});
+	dispatcher.appendListener(event, [&dataListWithArg](int, int n) {
+		dataListWithArg[1] += n * 2;
+	});
+	dispatcher.appendListener(event, [&dataListWithArg](int, int n) {
+		dataListWithArg[2] += n * 3;
+	});
+
+	REQUIRE(dataListNoArg == std::vector<int>{ 0, 0, 0 });
+	REQUIRE(dataListWithArg == std::vector<int>{ 0, 0, 0 });
 
-	dispatcher.dispatch(3);
-	REQUIRE(dataList[0] == 1);
-	REQUIRE(dataList[1] == 0);
+	dispatcher.dispatch(event);
+	REQUIRE(dataListNoArg == std::vector<int>{ 1, 2, 3 });
+	REQUIRE(dataListWithArg == std::vector<int>{ 0, 0, 0 });
 
-	dispatcher.dispatch(8);
-	REQUIRE(dataList[0] == 1);
-	REQUIRE(dataList[1] == 0);
+	dispatcher.dispatch(event);
+	REQUIRE(dataListNoArg == std::vector<int>{ 2, 4, 6 });
+	REQUIRE(dataListWithArg == std::vector<int>{ 0, 0, 0 });
 
-	dispatcher.dispatch(8, 5, 1, 3);
-	REQUIRE(dataList[0] == 1);
-	REQUIRE(dataList[1] == 9);
+	dispatcher.dispatch(event, 1);
+	REQUIRE(dataListNoArg == std::vector<int>{ 2, 4, 6 });
+	REQUIRE(dataListWithArg == std::vector<int>{ 1, 2, 3 });
 
-	dispatcher.dispatch(3, 2, 6, 7);
-	REQUIRE(dataList[0] == 1);
-	REQUIRE(dataList[1] == 24);
+	dispatcher.dispatch(event, 2);
+	REQUIRE(dataListNoArg == std::vector<int>{ 2, 4, 6 });
+	REQUIRE(dataListWithArg == std::vector<int>{ 3, 6, 9 });
 }
 
 TEST_CASE("HeterEventDispatcher, event filter")
diff --git a/tests/unittest/test_heterqueue_basic.cpp b/tests/unittest/test_heterqueue_basic.cpp
index 1409bc9..103f675 100644
--- a/tests/unittest/test_heterqueue_basic.cpp
+++ b/tests/unittest/test_heterqueue_basic.cpp
@@ -14,32 +14,159 @@
 #include "test.h"
 #include "eventpp/hetereventqueue.h"
 
-TEST_CASE("HeterEventQueue 1")
+TEST_CASE("HeterEventQueue, clearEvents")
 {
-	eventpp::HeterEventQueue<std::string, eventpp::HeterTuple<void (), void (const std::string &)> > queue;
+	eventpp::HeterEventQueue<int, eventpp::HeterTuple<void (), void (int)> > queue;
 
-	int a = 1;
-	int b = 5;
+	SECTION("void ()") {
+		REQUIRE(queue.empty());
 
-	queue.appendListener("event1", [&a](const std::string &) {
-		a = 2;
+		queue.enqueue(1);
+
+		REQUIRE(! queue.empty());
+
+		queue.clearEvents();
+		REQUIRE(queue.empty());
+	}
+
+	SECTION("void (int)") {
+		REQUIRE(queue.empty());
+
+		queue.enqueue(6, 3);
+
+		REQUIRE(! queue.empty());
+
+		queue.clearEvents();
+		REQUIRE(queue.empty());
+	}
+
+	SECTION("void (), more events") {
+		REQUIRE(queue.empty());
+
+		queue.enqueue(6);
+
+		REQUIRE(! queue.empty());
+
+		queue.enqueue(10);
+		queue.enqueue(99);
+
+		queue.clearEvents();
+		REQUIRE(queue.empty());
+	}
+
+	SECTION("void (int), more events") {
+		REQUIRE(queue.empty());
+
+		queue.enqueue(1, 3);
+
+		REQUIRE(! queue.empty());
+
+		queue.enqueue(2, 5);
+		queue.enqueue(8, 6);
+
+		queue.clearEvents();
+		REQUIRE(queue.empty());
+	}
+}
+
+TEST_CASE("HeterEventQueue, enqueue")
+{
+	eventpp::HeterEventQueue<int, eventpp::HeterTuple<void (), void (int)> > queue;
+	constexpr int event = 3;
+
+	SECTION("void ()") {
+		REQUIRE(queue.empty());
+
+		queue.enqueue(event);
+
+		REQUIRE(! queue.empty());
+	}
+
+	SECTION("void (int)") {
+		REQUIRE(queue.empty());
+
+		queue.enqueue(event, 3);
+
+		REQUIRE(! queue.empty());
+	}
+}
+
+TEST_CASE("HeterEventQueue, process")
+{
+	eventpp::HeterEventQueue<int, eventpp::HeterTuple<void (), void (int)> > queue;
+	constexpr int event = 3;
+
+	std::vector<int> dataList(2);
+
+	queue.appendListener(event, [&dataList]() {
+		++dataList[0];
 	});
-	queue.appendListener("event1", [&b]() {
-		b = 8;
+	queue.appendListener(event, [&dataList](int n) {
+		dataList[1] += n;
 	});
 
-	REQUIRE(a != 2);
-	REQUIRE(b != 8);
+	SECTION("0, 1") {
+		REQUIRE(dataList == std::vector<int>{ 0, 0 });
+
+		queue.enqueue(event); // 0 argument
+		queue.enqueue(event, 2); // 1 argument
+		queue.process();
+		REQUIRE(dataList == std::vector<int>{ 1, 2 });
+	}
+
+	SECTION("0, 0, 1, 1") {
+		REQUIRE(dataList == std::vector<int>{ 0, 0 });
+
+		queue.enqueue(event);
+		queue.enqueue(event);
+		queue.enqueue(event, 2);
+		queue.enqueue(event, 2);
+		queue.process();
+		REQUIRE(dataList == std::vector<int>{ 2, 4 });
+	}
+
+	SECTION("1, 0, 1, 0") {
+		REQUIRE(dataList == std::vector<int>{ 0, 0 });
+
+		queue.enqueue(event, 2);
+		queue.enqueue(event);
+		queue.enqueue(event, 2);
+		queue.enqueue(event);
+		queue.process();
+		REQUIRE(dataList == std::vector<int>{ 2, 4 });
+	}
+}
 
-	queue.enqueue("event1");
-	queue.process();
-	REQUIRE(a == 1);
-	REQUIRE(b == 8);
+TEST_CASE("HeterEventQueue, processOne")
+{
+	eventpp::HeterEventQueue<int, eventpp::HeterTuple<void (), void (int)> > queue;
+	constexpr int event = 3;
 
-	queue.enqueue("event1", "a");
-	queue.process();
-	REQUIRE(a == 2);
-	REQUIRE(b == 8);
+	std::vector<int> dataList(2);
+
+	queue.appendListener(event, [&dataList]() {
+		++dataList[0];
+	});
+	queue.appendListener(event, [&dataList](int n) {
+		dataList[1] += n;
+	});
+
+	REQUIRE(dataList == std::vector<int>{ 0, 0 });
+
+	queue.enqueue(event);
+	queue.enqueue(event, 2);
+	queue.processOne();
+	REQUIRE(dataList == std::vector<int>{ 1, 0 });
+
+	queue.enqueue(event);
+	queue.enqueue(event, 2);
+	queue.processOne();
+	REQUIRE(dataList == std::vector<int>{ 1, 2 });
+
+	queue.processOne();
+	REQUIRE(dataList == std::vector<int>{ 2, 2 });
+	queue.processOne();
+	REQUIRE(dataList == std::vector<int>{ 2, 4 });
 }
 
 TEST_CASE("HeterEventQueue, processIf")

From e682b673b600f341207ef36739edd49a933b1595 Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Sat, 30 Mar 2019 10:30:05 +0800
Subject: [PATCH 27/38] Added unit tests

---
 include/eventpp/eventpolicies.h               | 12 ++-
 include/eventpp/hetercallbacklist.h           |  2 +-
 include/eventpp/hetereventdispatcher.h        |  2 +-
 include/eventpp/hetereventqueue.h             |  2 +-
 tests/unittest/test_heterdispatcher_basic.cpp | 77 +++++++++++++++++++
 5 files changed, 89 insertions(+), 6 deletions(-)

diff --git a/include/eventpp/eventpolicies.h b/include/eventpp/eventpolicies.h
index 00fe48f..ea42a0b 100644
--- a/include/eventpp/eventpolicies.h
+++ b/include/eventpp/eventpolicies.h
@@ -24,9 +24,15 @@
 
 namespace eventpp {
 
-struct TagCallbackList {};
-struct TagEventDispatcher {};
-struct TagEventQueue {};
+struct TagHomo {};
+struct TagCallbackList : public TagHomo {};
+struct TagEventDispatcher : public TagHomo {};
+struct TagEventQueue : public TagHomo {};
+
+struct TagHeter {};
+struct TagHeterCallbackList : public TagHeter {};
+struct TagHeterEventDispatcher : public TagHeter {};
+struct TagHeterEventQueue : public TagHeter {};
 
 struct SpinLock
 {
diff --git a/include/eventpp/hetercallbacklist.h b/include/eventpp/hetercallbacklist.h
index 518652c..71c7984 100644
--- a/include/eventpp/hetercallbacklist.h
+++ b/include/eventpp/hetercallbacklist.h
@@ -300,7 +300,7 @@ template <
 	typename PrototypeList_,
 	typename Policies_ = DefaultPolicies
 >
-class HeterCallbackList : public internal_::HeterCallbackListBase<PrototypeList_, Policies_>, public TagCallbackList
+class HeterCallbackList : public internal_::HeterCallbackListBase<PrototypeList_, Policies_>, public TagCallbackList, public TagHeterCallbackList
 {
 private:
 	using super = internal_::HeterCallbackListBase<PrototypeList_, Policies_>;
diff --git a/include/eventpp/hetereventdispatcher.h b/include/eventpp/hetereventdispatcher.h
index 65907a6..094ad0b 100644
--- a/include/eventpp/hetereventdispatcher.h
+++ b/include/eventpp/hetereventdispatcher.h
@@ -303,7 +303,7 @@ template <
 class HeterEventDispatcher : public internal_::InheritMixins<
 		internal_::HeterEventDispatcherBase<Event_, PrototypeList_, Policies_, void>,
 		typename internal_::SelectMixins<Policies_, internal_::HasTypeMixins<Policies_>::value >::Type
-	>::Type, public TagEventDispatcher
+	>::Type, public TagEventDispatcher, public TagHeterEventDispatcher
 {
 private:
 	using super = typename internal_::InheritMixins<
diff --git a/include/eventpp/hetereventqueue.h b/include/eventpp/hetereventqueue.h
index ad743c1..bc5762a 100644
--- a/include/eventpp/hetereventqueue.h
+++ b/include/eventpp/hetereventqueue.h
@@ -462,7 +462,7 @@ template <
 class HeterEventQueue : public internal_::InheritMixins<
 		internal_::HeterEventQueueBase<Event_, PrototypeList_, Policies_>,
 		typename internal_::SelectMixins<Policies_, internal_::HasTypeMixins<Policies_>::value >::Type
-	>::Type, public TagEventDispatcher
+	>::Type, public TagEventDispatcher, public TagEventQueue, public TagHeterEventDispatcher, public TagHeterEventQueue
 {
 private:
 	using super = typename internal_::InheritMixins<
diff --git a/tests/unittest/test_heterdispatcher_basic.cpp b/tests/unittest/test_heterdispatcher_basic.cpp
index f2c348e..7e53469 100644
--- a/tests/unittest/test_heterdispatcher_basic.cpp
+++ b/tests/unittest/test_heterdispatcher_basic.cpp
@@ -364,6 +364,83 @@ TEST_CASE("HeterEventDispatcher, invoke, ArgumentPassingIncludeEvent")
 	REQUIRE(dataListWithArg == std::vector<int>{ 3, 6, 9 });
 }
 
+TEST_CASE("HeterEventDispatcher, getEvent")
+{
+	struct MyEvent {
+		int type;
+	};
+	struct EventPolicies
+	{
+		static int getEvent(const MyEvent & e) {
+			return e.type;
+		}
+
+		static int getEvent(const MyEvent & e, int) {
+			return e.type;
+		}
+	};
+
+
+	eventpp::HeterEventDispatcher<int, eventpp::HeterTuple<void (), void (int)>, EventPolicies> dispatcher;
+	constexpr int event = 3;
+
+	std::vector<int> dataList(2);
+
+	dispatcher.appendListener(event, [&dataList]() {
+		++dataList[0];
+	});
+	dispatcher.appendListener(event, [&dataList](int i) {
+		dataList[1] = i;
+	});
+
+	REQUIRE(dataList == std::vector<int>{ 0, 0 });
+
+	dispatcher.dispatch(MyEvent{ event });
+	REQUIRE(dataList == std::vector<int>{ 1, 0 });
+	dispatcher.dispatch(MyEvent{ event }, 3);
+	REQUIRE(dataList == std::vector<int>{ 1, 3 });
+}
+
+TEST_CASE("HeterEventDispatcher, getEvent, ArgumentPassingIncludeEvent")
+{
+	struct MyEvent {
+		int type;
+		int param;
+	};
+	struct EventPolicies
+	{
+		using ArgumentPassingMode = eventpp::ArgumentPassingIncludeEvent;
+
+		static int getEvent(const MyEvent & e) {
+			return e.type;
+		}
+
+		static int getEvent(const MyEvent & e, int) {
+			return e.type;
+		}
+	};
+
+
+	eventpp::HeterEventDispatcher<int, eventpp::HeterTuple<void (const MyEvent &), void (const MyEvent &, int)>, EventPolicies> dispatcher;
+	constexpr int event = 3;
+
+	std::vector<int> dataList(2);
+
+	dispatcher.appendListener(event, [&dataList](const MyEvent & e) {
+		dataList[0] = e.param;
+	});
+	dispatcher.appendListener(event, [&dataList](const MyEvent & e, int i) {
+		dataList[1] = e.param + i;
+	});
+
+	REQUIRE(dataList == std::vector<int>{ 0, 0 });
+
+	dispatcher.dispatch(MyEvent{ event, 5 });
+	REQUIRE(dataList == std::vector<int>{ 5, 0 });
+	dispatcher.dispatch(MyEvent{ event, 5 }, 3);
+	REQUIRE(dataList == std::vector<int>{ 5, 8 });
+}
+
 TEST_CASE("HeterEventDispatcher, event filter")
 {
 	struct MyPolicies {

From 188ddc403e3a8e70a527c475ad592849a4de9d33 Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Sun, 31 Mar 2019 11:10:21 +0800
Subject: [PATCH 28/38] Added tutorial code for HeterCallbackList

---
 doc/callbacklist.md                           |  2 +-
 doc/eventdispatcher.md                        |  2 +-
 doc/eventqueue.md                             |  2 +-
 tests/unittest/CMakeLists.txt                 |  1 +
 tests/unittest/tutorial_hetercallbacklist.cpp | 92 +++++++++++++++++++
 5 files changed, 96 insertions(+), 3 deletions(-)
 create mode 100644 tests/unittest/tutorial_hetercallbacklist.cpp

diff --git a/doc/callbacklist.md b/doc/callbacklist.md
index 338eb3a..d535759 100644
--- a/doc/callbacklist.md
+++ b/doc/callbacklist.md
@@ -21,7 +21,7 @@ The *callback* can be any callback target -- functions, pointers to functions, ,
 
 eventpp/callbacklist.h
 
-**Template parameters**
+### Template parameters
 
 ```c++
 template <
diff --git a/doc/eventdispatcher.md b/doc/eventdispatcher.md
index 84e997a..2b5676f 100644
--- a/doc/eventdispatcher.md
+++ b/doc/eventdispatcher.md
@@ -20,7 +20,7 @@ EventDispatcher holds a map of `<EventType, CallbackList>` pairs. On dispatching
 
 eventpp/eventdispatcher.h
 
-**Template parameters**
+### Template parameters
 
 ```c++
 template <
diff --git a/doc/eventqueue.md b/doc/eventqueue.md
index c7c7204..991554b 100644
--- a/doc/eventqueue.md
+++ b/doc/eventqueue.md
@@ -18,7 +18,7 @@ EventQueue is equivalent to the event system (QEvent) in Qt, or the message proc
 
 eventpp/eventqueue.h
 
-**Template parameters**
+### Template parameters
 
 ```c++
 template <
diff --git a/tests/unittest/CMakeLists.txt b/tests/unittest/CMakeLists.txt
index 9129680..63c8f52 100644
--- a/tests/unittest/CMakeLists.txt
+++ b/tests/unittest/CMakeLists.txt
@@ -5,6 +5,7 @@ set(SRC_TEST
 	tutorial_callbacklist.cpp
 	tutorial_eventdispatcher.cpp
 	tutorial_eventqueue.cpp
+	tutorial_hetercallbacklist.cpp
 	test_callbacklist_basic.cpp
 	test_callbacklist_ctors.cpp
 	test_callbacklist_multithread.cpp
diff --git a/tests/unittest/tutorial_hetercallbacklist.cpp b/tests/unittest/tutorial_hetercallbacklist.cpp
new file mode 100644
index 0000000..d2ebd1b
--- /dev/null
+++ b/tests/unittest/tutorial_hetercallbacklist.cpp
@@ -0,0 +1,92 @@
+// eventpp library
+// Copyright (C) 2018 Wang Qi (wqking)
+// Github: https://github.com/wqking/eventpp
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//   http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Include the head
+#include "eventpp/hetercallbacklist.h"
+
+#include "test.h"
+
+#include <iostream>
+
+TEST_CASE("HeterCallbackList tutorial 1, basic")
+{
+	std::cout << "HeterCallbackList tutorial 1, basic" << std::endl;
+
+	// The namespace is eventpp
+	// the first parameter is a HeterTuple of the listener prototypes.
+	eventpp::HeterCallbackList<eventpp::HeterTuple<void (), void (int)> > callbackList;
+
+	// Add a callback.
+	// []() {} is the callback.
+	// Lambda is not required, any function or std::function
+	// or whatever function object with the required prototype is fine.
+	callbackList.append([]() {
+		std::cout << "Got callback for void()." << std::endl;
+	});
+	callbackList.append([](int) {
+		std::cout << "Got callback for void(int)." << std::endl;
+	});
+
+	// Invoke the callback list
+	// Output: Got callback for void().
+	callbackList();
+	// Output: Got callback for void(int).
+	callbackList(5);
+}
+
+#if 0
+TEST_CASE("HeterCallbackList tutorial 2, for each")
+{
+	std::cout << "HeterCallbackList tutorial 4, for each" << std::endl;
+
+	using CL = eventpp::HeterCallbackList<eventpp::HeterTuple<void (), void (int), void (int, int)> >;
+	CL callbackList;
+
+	// Add some callbacks.
+	callbackList.append([]() {
+		std::cout << "Got callback void()." << std::endl;
+	});
+	callbackList.append([](int a) {
+		std::cout << "Got callback void(" << a << ")." << std::endl;
+	});
+	callbackList.append([](int a, int b) {
+		std::cout << "Got callback void(" << a << ", " << b << ")." << std::endl;
+	});
+
+	// Now call forEach to remove the second callback
+	// The forEach callback prototype is void(const HeterCallbackList::Handle & handle, const HeterCallbackList::Callback & callback)
+	int index = 0;
+	callbackList.forEach([&callbackList, &index](const CL::Handle & handle, const CL::Callback & /*callback*/) {
+		std::cout << "forEach(Handle, Callback), invoked " << index << std::endl;
+		if(index == 1) {
+			callbackList.remove(handle);
+			std::cout << "forEach(Handle, Callback), removed second callback" << std::endl;
+		}
+		++index;
+	});
+
+	// The forEach callback prototype can also be void(const HeterCallbackList::Handle & handle)
+	callbackList.forEach([&callbackList, &index](const CL::Handle & /*handle*/) {
+		std::cout << "forEach(Handle), invoked" << std::endl;
+	});
+
+	// The forEach callback prototype can also be void(const HeterCallbackList::Callback & callback)
+	callbackList.forEach([&callbackList, &index](const CL::Callback & /*callback*/) {
+		std::cout << "forEach(Callback), invoked" << std::endl;
+	});
+
+	// Invoke the callback list
+	// The "Got callback 2" callback should not be triggered.
+	callbackList();
+}
+#endif

From 9de92285b3a8fd4295e2a3ff41b164583af0969d Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Sun, 31 Mar 2019 11:22:36 +0800
Subject: [PATCH 29/38] Generate TOC using addtoc2md.pl

---
 doc/callbacklist.md             | 32 +++++++++++++++++++++++---------
 doc/conditionalremover.md       | 22 +++++++++++++++++++++-
 doc/counterremover.md           | 22 +++++++++++++++++++++-
 doc/eventdispatcher.md          | 32 +++++++++++++++++++++++---------
 doc/eventqueue.md               | 24 +++++++++++++++++++-----
 doc/eventutil.md                |  2 +-
 doc/faq.md                      | 25 +++++++++++++++++++++++++
 doc/mixins.md                   | 23 +++++++++++++++++++++++
 doc/policies.md                 | 27 +++++++++++++++++++++++++++
 doc/scopedremover.md            | 22 +++++++++++++++++++++-
 doc/tutorial_callbacklist.md    | 23 ++++++++++++++---------
 doc/tutorial_eventdispatcher.md |  8 +-------
 doc/tutorial_eventqueue.md      |  5 +----
 13 files changed, 220 insertions(+), 47 deletions(-)

diff --git a/doc/callbacklist.md b/doc/callbacklist.md
index d535759..81111fb 100644
--- a/doc/callbacklist.md
+++ b/doc/callbacklist.md
@@ -1,12 +1,22 @@
 # Class CallbackList reference
 
+<a id="a2_1"></a>
 ## Table Of Contents
 
-- [API reference](#apis)
-- [Nested callback safety](#nested-callback-safety)
-- [Time complexities](#time-complexities)
-- [Internal data structure](#internal-data-structure)
-
+<!--begintoc-->
+* [Table Of Contents](#a2_1)
+* [Description](#a2_2)
+* [API reference](#a2_3)
+  * [Header](#a3_1)
+  * [Template parameters](#a3_2)
+  * [Public types](#a3_3)
+  * [Member functions](#a3_4)
+* [Nested callback safety](#a2_4)
+* [Time complexities](#a2_5)
+* [Internal data structure](#a2_6)
+<!--endtoc-->
+
+<a id="a2_2"></a>
 ## Description
 
 CallbackList is the fundamental class in eventpp. The other classes EventDispatcher and EventQueue are built on CallbackList.  
@@ -14,13 +24,15 @@ CallbackList is the fundamental class in eventpp. The other classes EventDispatc
 CallbackList holds a list of callbacks. At the time of the call, CallbackList simply invokes each callback one by one. Consider CallbackList as the signal/slot system in Qt, or the callback function pointer in some Windows APIs (such as lpCompletionRoutine in `ReadFileEx`).  
 The *callback* can be any callback target -- functions, pointers to functions, , pointers to member functions, lambda expressions, and function objects.  
 
-<a name="apis"></a>
+<a id="a2_3"></a>
 ## API reference
 
+<a id="a3_1"></a>
 ### Header
 
 eventpp/callbacklist.h
 
+<a id="a3_2"></a>
 ### Template parameters
 
 ```c++
@@ -33,11 +45,13 @@ class CallbackList;
 `Prototype`:  the callback prototype. It's C++ function type such as `void(int, std::string, const MyClass *)`.  
 `Policies`: the policies to configure and extend the callback list. The default value is `DefaultPolicies`. See [document of policies](policies.md) for details.  
 
+<a id="a3_3"></a>
 ### Public types
 
 `Handle`: the handle type returned by appendListener, prependListener and insertListener. A handle can be used to insert a callback or remove a callback. To check if a `Handle` is empty, convert it to boolean, *false* is empty. `Handle` is copyable.  
 `Callback`: the callback storage type.
 
+<a id="a3_4"></a>
 ### Member functions
 
 ```c++
@@ -122,21 +136,21 @@ Invoke each callbacks in the callback list.
 The callbacks are called with arguments `args`.  
 The callbacks are called in the thread same as the callee of `operator()`.
 
-<a name="nested-callback-safety"></a>
+<a id="a2_4"></a>
 ## Nested callback safety
 1. If a callback adds another callback to the callback list during a invoking, the new callback is guaranteed not to be triggered within the same invoking. This is guaranteed by an unsigned 64 bits integer counter. This rule will be broken is the counter is overflowed to zero in a invoking, but this rule will continue working on the subsequence invoking.  
 2. Any callbacks that are removed during a invoking are guaranteed not triggered.  
 3. All above points are not true in multiple threading. That's to say, if one thread is invoking a callback list, the other thread add or remove a callback, the added or removed callback may be called during the invoking.
 
 
-<a name="time-complexities"></a>
+<a id="a2_5"></a>
 ## Time complexities
 - `append`: O(1)
 - `prepend`: O(1)
 - `insert`: O(1)
 - `remove`: O(1)
 
-<a name="internal-data-structure"></a>
+<a id="a2_6"></a>
 ## Internal data structure
 
 CallbackList uses doubly linked list to manage the callbacks.  
diff --git a/doc/conditionalremover.md b/doc/conditionalremover.md
index 8d6d0f3..4108263 100644
--- a/doc/conditionalremover.md
+++ b/doc/conditionalremover.md
@@ -1,17 +1,34 @@
 # Class ConditionalRemover reference
 
+<a id="a2_1"></a>
+## Table Of Contents
+
+<!--begintoc-->
+* [Table Of Contents](#a2_1)
+* [Description](#a2_2)
+* [API reference](#a2_3)
+  * [Header](#a3_1)
+  * [Template parameters](#a3_2)
+  * [Member functions](#a3_3)
+  * [Free functions](#a3_4)
+  * [Sample code](#a3_5)
+<!--endtoc-->
+
+<a id="a2_2"></a>
 ## Description
 
 ConditionalRemover is a utility class that automatically removes listeners after the listeners are triggered and certain condition is satisfied.  
 ConditionalRemover is a pure functional class. After the member functions in ConditionalRemover are invoked, the ConditionalRemover object can be destroyed safely.  
 
-<a name="apis"></a>
+<a id="a2_3"></a>
 ## API reference
 
+<a id="a3_1"></a>
 ### Header
 
 eventpp/utilities/conditionalremover.h
 
+<a id="a3_2"></a>
 ### Template parameters
 
 ```c++
@@ -21,6 +38,7 @@ class ConditionalRemover;
 
 `DispatcherType` can be CallbackList, EventDispatcher, or EventQueue.
 
+<a id="a3_3"></a>
 ### Member functions
 
 ```c++
@@ -78,6 +96,7 @@ typename CallbackListType::Handle insert(
 
 The member functions have the same names with the corresponding underlying class (CallbackList, EventDispatcher, or EventQueue), and also have the same parameters except there is one more parameter, `condition`. `condition` is a predicate function of prototype `bool()`. It's invoked after each trigger, if it returns true, the listener will be removed.  
 
+<a id="a3_4"></a>
 ### Free functions
 
 ```c++
@@ -87,6 +106,7 @@ ConditionalRemover<DispatcherType> conditionalRemover(DispatcherType & dispatche
 
 Since ConditionalRemover takes one template parameter and it's verbose to instantiate its instance, the function `conditionalRemover` is used to construct an instance of ConditionalRemover via the deduced argument.
 
+<a id="a3_5"></a>
 ### Sample code
 
 ```c++
diff --git a/doc/counterremover.md b/doc/counterremover.md
index 344116b..00ec8bd 100644
--- a/doc/counterremover.md
+++ b/doc/counterremover.md
@@ -1,17 +1,34 @@
 # Class CounterRemover reference
 
+<a id="a2_1"></a>
+## Table Of Contents
+
+<!--begintoc-->
+* [Table Of Contents](#a2_1)
+* [Description](#a2_2)
+* [API reference](#a2_3)
+  * [Header](#a3_1)
+  * [Template parameters](#a3_2)
+  * [Member functions](#a3_3)
+  * [Free functions](#a3_4)
+  * [Sample code](#a3_5)
+<!--endtoc-->
+
+<a id="a2_2"></a>
 ## Description
 
 CounterRemover is a utility class that automatically removes listeners after the listeners are triggered for certain times.  
 CounterRemover is a pure functional class. After the member functions in CounterRemover are invoked, the CounterRemover object can be destroyed safely.  
 
-<a name="apis"></a>
+<a id="a2_3"></a>
 ## API reference
 
+<a id="a3_1"></a>
 ### Header
 
 eventpp/utilities/counterremover.h
 
+<a id="a3_2"></a>
 ### Template parameters
 
 ```c++
@@ -21,6 +38,7 @@ class CounterRemover;
 
 `DispatcherType` can be CallbackList, EventDispatcher, or EventQueue.
 
+<a id="a3_3"></a>
 ### Member functions
 
 ```c++
@@ -73,6 +91,7 @@ typename CallbackListType::Handle insert(
 The member functions have the same names with the corresponding underlying class (CallbackList, EventDispatcher, or EventQueue), and also have the same parameters except there is one more parameter, `triggerCount`. `triggerCount` is decreased by one on each trigger, and when `triggerCount` is zero or negative, the listener will be removed.  
 The default value of `triggerCount` is 1, that means the listener is removed after the first trigger, which is one shot listener.
 
+<a id="a3_4"></a>
 ### Free functions
 
 ```c++
@@ -82,6 +101,7 @@ CounterRemover<DispatcherType> counterRemover(DispatcherType & dispatcher);
 
 Since CounterRemover takes one template parameter and it's verbose to instantiate its instance, the function `counterRemover` is used to construct an instance of CounterRemover via the deduced argument.
 
+<a id="a3_5"></a>
 ### Sample code
 
 ```c++
diff --git a/doc/eventdispatcher.md b/doc/eventdispatcher.md
index 2b5676f..8fea660 100644
--- a/doc/eventdispatcher.md
+++ b/doc/eventdispatcher.md
@@ -1,25 +1,37 @@
 # Class EventDispatcher reference
 
+<a id="a2_1"></a>
 ## Table Of Contents
 
-- [API reference](#apis)
-- [Nested listener safety](#nested-listener-safety)
-- [Time complexities](#time-complexities)
-- [Internal data structure](#internal-data-structure)
-
+<!--begintoc-->
+* [Table Of Contents](#a2_1)
+* [Description](#a2_2)
+* [API reference](#a2_3)
+  * [Header](#a3_1)
+  * [Template parameters](#a3_2)
+  * [Public types](#a3_3)
+  * [Member functions](#a3_4)
+* [Nested listener safety](#a2_4)
+* [Time complexities](#a2_5)
+* [Internal data structure](#a2_6)
+<!--endtoc-->
+
+<a id="a2_2"></a>
 ## Description
 
 EventDispatcher is something like std::map<EventType, CallbackList>.
 
 EventDispatcher holds a map of `<EventType, CallbackList>` pairs. On dispatching, EventDispatcher finds the CallbackList of the event type, then invoke the callback list. The invocation is always synchronous. The listeners are triggered when `EventDispatcher::dispatch` is called.  
 
-<a name="apis"></a>
+<a id="a2_3"></a>
 ## API reference
 
+<a id="a3_1"></a>
 ### Header
 
 eventpp/eventdispatcher.h
 
+<a id="a3_2"></a>
 ### Template parameters
 
 ```c++
@@ -34,12 +46,14 @@ class EventDispatcher;
 `Prototype`: the listener prototype. It's C++ function type such as `void(int, std::string, const MyClass *)`.  
 `Policies`: the policies to configure and extend the dispatcher. The default value is `DefaultPolicies`. See [document of policies](policies.md) for details.  
 
+<a id="a3_3"></a>
 ### Public types
 
 `Handle`: the handle type returned by appendListener, prependListener and insertListener. A handle can be used to insert a listener or remove a listener. To check if a `Handle` is empty, convert it to boolean, *false* is empty. `Handle` is copyable.  
 `Callback`: the callback storage type.  
 `Event`: the event type.  
 
+<a id="a3_4"></a>
 ### Member functions
 
 ```c++
@@ -116,13 +130,13 @@ bool forEachIf(const Event & event, Func && func);
 Apply `func` to all listeners of `event`. `func` must return a boolean value, and if the return value is false, forEachIf stops the looping immediately.  
 Return `true` if all listeners are invoked, or `event` is not found, `false` if `func` returns `false`.
 
-<a name="nested-listener-safety"></a>
+<a id="a2_4"></a>
 ## Nested listener safety
 1. If a listener adds another listener of the same event to the dispatcher during a dispatching, the new listener is guaranteed not to be triggered within the same dispatching. This is guaranteed by an unsigned 64 bits integer counter. This rule will be broken is the counter is overflowed to zero in a dispatching, but this rule will continue working on the subsequence dispatching.  
 2. Any listeners that are removed during a dispatching are guaranteed not triggered.  
 3. All above points are not true in multiple threading. That's to say, if one thread is invoking a callback list, the other thread add or remove a callback, the added or removed callback may be triggered during the invoking.
 
-<a name="time-complexities"></a>
+<a id="a2_5"></a>
 ## Time complexities
 The time complexities being discussed here is about when operating on the listener in the underlying list, and `n` is the number of listeners. It doesn't include the event searching in the underlying `std::map` which is always O(log n).
 - `appendListener`: O(1)
@@ -131,7 +145,7 @@ The time complexities being discussed here is about when operating on the listen
 - `removeListener`: O(1)
 - `enqueue`: O(1)
 
-<a name="internal-data-structure"></a>
+<a id="a2_6"></a>
 ## Internal data structure
 
 EventDispatcher uses [CallbackList](callbacklist.md) to manage the listener callbacks.  
diff --git a/doc/eventqueue.md b/doc/eventqueue.md
index 991554b..713fd91 100644
--- a/doc/eventqueue.md
+++ b/doc/eventqueue.md
@@ -1,23 +1,35 @@
 # Class EventQueue reference
 
+<a id="a2_1"></a>
 ## Table Of Contents
 
-- [API reference](#apis)
-- [Internal data structure](#internal-data-structure)
-
+<!--begintoc-->
+* [Table Of Contents](#a2_1)
+* [Description](#a2_2)
+* [API reference](#a2_3)
+  * [Header](#a3_1)
+  * [Template parameters](#a3_2)
+  * [Public types](#a3_3)
+  * [Member functions](#a3_4)
+* [Internal data structure](#a2_4)
+<!--endtoc-->
+
+<a id="a2_2"></a>
 ## Description
 
 EventQueue includes all features of EventDispatcher and adds event queue features. Note: EventQueue doesn't inherit from EventDispatcher, don't try to cast EventQueue to EventDispatcher.  
 EventQueue is asynchronous. Events are cached in the queue when `EventQueue::enqueue` is called, and dispatched later when `EventQueue::process` is called.  
 EventQueue is equivalent to the event system (QEvent) in Qt, or the message processing in Windows API.  
 
-<a name="apis"></a>
+<a id="a2_3"></a>
 ## API reference
 
+<a id="a3_1"></a>
 ### Header
 
 eventpp/eventqueue.h
 
+<a id="a3_2"></a>
 ### Template parameters
 
 ```c++
@@ -31,6 +43,7 @@ class EventQueue;
 
 EventQueue has the exactly same template parameters with EventDispatcher. Please reference [EventDispatcher document](eventdispatcher.md) for details.
 
+<a id="a3_3"></a>
 ### Public types
 
 `QueuedEvent`: the data type of event stored in the queue. It's declaration in pseudo code is,  
@@ -43,6 +56,7 @@ struct EventQueue::QueuedEvent
 ```
 `event` is the EventQueue::Event, `arguments` are the arguments passed in `enqueue`.  
 
+<a id="a3_4"></a>
 ### Member functions
 
 ```c++
@@ -200,7 +214,7 @@ EQ queue;
 queue.enqueue(3);
 ```
 
-<a name="internal-data-structure"></a>
+<a id="a2_4"></a>
 ## Internal data structure
 
 EventQueue uses three `std::list` to manage the event queue.  
diff --git a/doc/eventutil.md b/doc/eventutil.md
index 6c67453..7f97058 100644
--- a/doc/eventutil.md
+++ b/doc/eventutil.md
@@ -1,6 +1,6 @@
 # Utilities reference
 
-**Header**
+## Header
 
 eventpp/eventutil.h
 
diff --git a/doc/faq.md b/doc/faq.md
index 10d1c5d..dcaf195 100644
--- a/doc/faq.md
+++ b/doc/faq.md
@@ -1,5 +1,22 @@
 # Frequently Asked Questions
 
+<a id="a2_1"></a>
+## Table Of Contents
+
+<!--begintoc-->
+* [Table Of Contents](#a2_1)
+* [Why can't rvalue reference be used as callback prototype in EventDispatcher and CallbackList? Such as CallbackList<void (int &&)>](#a2_2)
+* [Can the callback prototype have return value? Such as CallbackList<std::string (const std::string &, int)>?](#a2_3)
+* [Why can't callback prototype be function pointer such as CallbackList<void (*)()>?](#a2_4)
+* [Why aren't there APIs to remove listeners directly from an EventDispatcher? Why do we have to remove by handle?](#a2_5)
+* [Isn't CallbackList equivalent to std::vector<Callback>? It's simple for me to use std::vector<Callback> directly.](#a2_6)
+* [I want to inherit my class from EventDispatcher, but EventDispatcher's destructor is not virtual?](#a2_7)
+* [How to automatically remove listeners when certain object is destroyed (aka auto disconnection)?](#a2_8)
+* [How to process all EventQueue instances in a single main loop?](#a2_9)
+* [How to integrate EventQueue with boost::asio::io_service?](#a2_10)
+<!--endtoc-->
+
+<a id="a2_2"></a>
 ## Why can't rvalue reference be used as callback prototype in EventDispatcher and CallbackList? Such as CallbackList<void (int &&)>
 
 ```c++
@@ -11,24 +28,29 @@ The above code doesn't compile. This is intended design and not a bug.
 A rvalue reference `std::string &&` means the argument can be moved by the callback and become invalid (or empty). Keep in mind CallbackList invokes many callbacks one by one. So what happens if the first callback moves the argument and the other callbacks get empty value? In above code example, that means the first callback sees the value "Hello" and moves it, then the other callbacks will see empty string, not "Hello"!  
 To avoid such potential bugs, rvalue reference is forbidden deliberately.
 
+<a id="a2_3"></a>
 ## Can the callback prototype have return value? Such as CallbackList<std::string (const std::string &, int)>?
 
 Yes you can, but both EventDispatcher and CallbackList just discard the return value. It's not efficient nor useful to return value from EventDispatcher and CallbackList.
 
+<a id="a2_4"></a>
 ## Why can't callback prototype be function pointer such as CallbackList<void (*)()>?
 
 It's rather easy to support function pointer, but it's year 2018 at the time written, and there is proposal for C++20 standard already, so let's use modern C++ features. Stick with function type `void ()` instead of function pointer `void (*)()`.
 
+<a id="a2_5"></a>
 ## Why aren't there APIs to remove listeners directly from an EventDispatcher? Why do we have to remove by handle?
 
 Both `EventDispatcher::removeListener(const Event & event, const Handle handle)` and `CallbackList::remove(const Handle handle)` requires the handle of a listener is passed in. So why can't we pass the listener object directly? The reason is, it's not guaranteed that the underlying callback storage is comparable while removing a listener object requires the comparable ability. Indeed the default callback storage, `std::function` is not comparable.  
 If we use some customized callback storage and we are sure it's comparable, there is free functions 'removeListener' in [utility APIs](eventutil.md).
 
+<a id="a2_6"></a>
 ## Isn't CallbackList equivalent to std::vector<Callback>? It's simple for me to use std::vector<Callback> directly.
 
 `CallbackList` works like a `std::vector<Callback>`. But one common usage is to implement one-shot callback that a callback removes itself from the callback list when it's invoked. In such case a simple `std::vector<Callback>` will bang and crash.  
 With `CallbackList` a callback can be removed at any time, even when the callback list is under invoking.
 
+<a id="a2_7"></a>
 ## I want to inherit my class from EventDispatcher, but EventDispatcher's destructor is not virtual?
 
 It's intended not to use any virtual functions in eventpp to avoid bloating the code size. New class can still inherit from EventDispatcher, as long as the object is not deleted via a pointer to EventDispatcher, which will cause resource leak. If you need to delete object via pointer to base class, make your own base class that inherits from EventDispatcher, and make the base class destructor virtual.  
@@ -49,10 +71,12 @@ MyEventDispatcher * myObject = new MyClass();
 delete myObject;
 ```
 
+<a id="a2_8"></a>
 ## How to automatically remove listeners when certain object is destroyed (aka auto disconnection)?  
 
 [Use utility class ScopedRemover](scopedremover.md)
 
+<a id="a2_9"></a>
 ## How to process all EventQueue instances in a single main loop?  
 
 It's common to have a single main loop in a GUI or game application, and there are various EventQueue instances in the system. How to process all the EventQueue instances? Let's see some pseudo code first,  
@@ -85,6 +109,7 @@ public:
 
 The idea is, the main loop invoke a callback list in each loop, and each event queue registers its process to the callback list.
 
+<a id="a2_10"></a>
 ## How to integrate EventQueue with boost::asio::io_service?  
 
 A common use case is there are multiple threads that executing boost::asio::io_service::run(). To integrate EventQueue with boost asio, we need to replace `run()` with `poll()` to avoid blocking. So a typical thread will look like,  
diff --git a/doc/mixins.md b/doc/mixins.md
index 4dfa837..f0bb748 100644
--- a/doc/mixins.md
+++ b/doc/mixins.md
@@ -1,5 +1,21 @@
 # Mixins
 
+<a id="a2_1"></a>
+## Table Of Contents
+
+<!--begintoc-->
+* [Table Of Contents](#a2_1)
+* [Introduction](#a2_2)
+* [Define a mixin](#a2_3)
+* [Inject(enable) mixins to EventDispatcher](#a2_4)
+* [Optional interceptor points](#a2_5)
+* [MixinFilter](#a2_6)
+  * [Public type](#a3_1)
+  * [Functions](#a3_2)
+  * [Sample code for MixinFilter](#a3_3)
+<!--endtoc-->
+
+<a id="a2_2"></a>
 ## Introduction
 
 A mixin is used to inject code in the EventDispatcher/EventQueue inheritance hierarchy to extend the functionalities. In this document we will use EventDispatcher as the example, the usage for EventQueue is exactly the same.  
@@ -15,6 +31,7 @@ EventDispatcher <- MixinA <- MixinB <- EventDispatcherBase
 ```
 The mixins can use all public and protected members (types, functions and data) in EventDispatcherBase. All public members in the mixins are visible and usable by the user.
 
+<a id="a2_3"></a>
 ## Define a mixin
 
 A mixin is a template class with one template argument. The mixin must inherit from it's template argument.  
@@ -26,6 +43,7 @@ class MyMixin : public Base
 };
 ```
 
+<a id="a2_4"></a>
 ## Inject(enable) mixins to EventDispatcher
 
 To enable mixins, add them to the `Mixins` type in the policies class. For example, to enable `MixinFilter`, define the dispatcher as,   
@@ -42,6 +60,7 @@ EventDispatcher <- MixinA <- MixinB <- MixinC <- EventDispatcherBase
 ```
 The front mixin is the lowest in the hierarchy.
 
+<a id="a2_5"></a>
 ## Optional interceptor points
 
 A mixin can have special named functions that are called at certain point. The special functions must be public.  
@@ -54,6 +73,7 @@ bool mixinBeforeDispatch(Args && ...args) const;
 The function returns `true` to continue the dispatch, `false` will stop any further dispatching.  
 For multiple mixins, this function is called in the order of they appearing in MixinList in the policies class.
 
+<a id="a2_6"></a>
 ## MixinFilter
 
 MixinFilter allows all events are filtered or modified before dispatching.
@@ -77,10 +97,12 @@ Event filter is a powerful and useful technology, below is some sample use cases
 
 2, Setup catch-all event listener. For example, in a phone book system, the system sends events based on the actions, such as adding a phone number, remove a phone number, look up a phone number, etc. A module may be only interested in special area code of a phone number, not the actions. One approach is the module can listen to all possible events (add, remove, look up), but this is very fragile -- how about a new action event is added and the module forgets to listen on it? The better approach is the module add a filter and check the area code in the filter.
 
+<a id="a3_1"></a>
 ### Public type
 
 `FilterHandle`: the handle type returned by appendFilter. A filter handle can be used to remove a filter. To check if a `FilterHandle` is empty, convert it to boolean, *false* is empty. `FilterHandle` is copyable.  
 
+<a id="a3_2"></a>
 ### Functions
 
 ```c++
@@ -95,6 +117,7 @@ bool removeFilter(const FilterHandle & filterHandle);
 Remove a filter from the dispatcher.  
 Return true if the filter is removed successfully.
 
+<a id="a3_3"></a>
 ### Sample code for MixinFilter
 
 **Code**  
diff --git a/doc/policies.md b/doc/policies.md
index f1470cd..27a440f 100644
--- a/doc/policies.md
+++ b/doc/policies.md
@@ -1,5 +1,23 @@
 # Policies
 
+<a id="a2_1"></a>
+## Table Of Contents
+
+<!--begintoc-->
+* [Table Of Contents](#a2_1)
+* [Introduction](#a2_2)
+* [Policies](#a2_3)
+  * [Function getEvent](#a3_1)
+  * [Function canContinueInvoking](#a3_2)
+  * [Type Mixins](#a3_3)
+  * [Type Callback](#a3_4)
+  * [Type Threading](#a3_5)
+* [Type ArgumentPassingMode](#a2_4)
+  * [Template Map](#a3_6)
+* [How to use policies](#a2_5)
+<!--endtoc-->
+
+<a id="a2_2"></a>
 ## Introduction
 
 eventpp uses policy based design to configure and extend each components' behavior. The last template parameter in EventDispatcher, EventQueue, and CallbackList is the policies class. All those three classes have default policies class named `DefaultPolicies`.  
@@ -7,8 +25,10 @@ A policy is either a type or a static function member in the policies class. All
 All policies are optional. If any policy is omitted, the default value is used.  In fact `DefaultPolicies` is just an empty struct.  
 The same policy mechanism applies to all three classes, EventDispatcher, EventQueue, and CallbackList, though not all classes requires the same policy.
 
+<a id="a2_3"></a>
 ## Policies
 
+<a id="a3_1"></a>
 ### Function getEvent
 
 **Prototype**: `static EventKey getEvent(const Args &...)`. The function receives same arguments as `EventDispatcher::dispatch` and `EventQueue::enqueue`, and must return an event type.  
@@ -63,6 +83,7 @@ dispatcher.appendListener(3, [](const MyEvent & e, bool b) {
 dispatcher.dispatch(MyEvent { 3, "Hello world", 38 }, true);
 ```
 
+<a id="a3_2"></a>
 ### Function canContinueInvoking
 
 **Prototype**: `static bool canContinueInvoking(const Args &...)`. The function receives same arguments as `EventDispatcher::dispatch` and `EventQueue::enqueue`, and must return true if the event dispatching or callback list invoking can continue, false if the dispatching should stop.  
@@ -107,6 +128,7 @@ dispatcher.appendListener(3, [](const MyEvent & e) {
 dispatcher.dispatch(MyEvent(3));
 ```
 
+<a id="a3_3"></a>
 ### Type Mixins
 
 **Default value**: `using Mixins = eventpp::MixinList<>`. No mixins are enabled.  
@@ -114,6 +136,7 @@ dispatcher.dispatch(MyEvent(3));
 
 A mixin is used to inject code in the EventDispatcher/EventQueue inheritance hierarchy to extend the functionalities. For more details, please read the [document of mixins](mixins.md).
 
+<a id="a3_4"></a>
 ### Type Callback
 
 **Default value**: `using Callback = std::function<Parameters of callback>`.  
@@ -121,6 +144,7 @@ A mixin is used to inject code in the EventDispatcher/EventQueue inheritance hie
 
 `Callback` is the underlying storage type to hold the callback. Default is `std::function`.  
 
+<a id="a3_5"></a>
 ### Type Threading
 
 **Default value**: `using Threading = eventpp::MultipleThreading`.  
@@ -196,6 +220,7 @@ eventpp::EventDispatcher<int, void (), MyEventPolicies> dispatcher;
 eventpp::CallbackList<void (), MyEventPolicies> callbackList;
 ```
 
+<a id="a2_4"></a>
 ## Type ArgumentPassingMode
 
 **Default value**: `using ArgumentPassingMode = ArgumentPassingAutoDetect`.  
@@ -287,6 +312,7 @@ eventpp::EventDispatcher<
 dispatcher.dispatch(3, 8, "hello"); // Compile OK
 ```
 
+<a id="a3_6"></a>
 ### Template Map
 
 **Prototype**:  
@@ -302,6 +328,7 @@ using Map = // std::map <Key, T> or other map type
 `Map` must support operations `[]`, `find()`, and `end()`.  
 If `Map` is not specified, eventpp will auto determine the type. If the event type supports `std::hash`, `std::unordered_map` is used, otherwise, `std::map` is used.
 
+<a id="a2_5"></a>
 ## How to use policies
 
 To use policies, declare a struct, define the policies in it, and pass the struct to CallbackList, EventDispatcher, or EventQueue.  
diff --git a/doc/scopedremover.md b/doc/scopedremover.md
index 9886ca3..a18f6f6 100644
--- a/doc/scopedremover.md
+++ b/doc/scopedremover.md
@@ -1,16 +1,33 @@
 # Class ScopedRemover reference
 
+<a id="a2_1"></a>
+## Table Of Contents
+
+<!--begintoc-->
+* [Table Of Contents](#a2_1)
+* [Description](#a2_2)
+* [API reference](#a2_3)
+  * [Header](#a3_1)
+  * [Template parameters](#a3_2)
+  * [Member functions](#a3_3)
+  * [Sample code](#a3_4)
+  * [Automatic disconnection](#a3_5)
+<!--endtoc-->
+
+<a id="a2_2"></a>
 ## Description
 
 ScopedRemover is a utility class that automatically removes listeners when ScopedRemover object goes out of scope.  
 
-<a name="apis"></a>
+<a id="a2_3"></a>
 ## API reference
 
+<a id="a3_1"></a>
 ### Header
 
 eventpp/utilities/scopedremover.h
 
+<a id="a3_2"></a>
 ### Template parameters
 
 ```c++
@@ -20,6 +37,7 @@ class ScopedRemover;
 
 `DispatcherType` can be CallbackList, EventDispatcher, or EventQueue.
 
+<a id="a3_3"></a>
 ### Member functions
 
 ```c++
@@ -76,6 +94,7 @@ The function `setDispatcher()` and `setCallbackList` sets the dispatcher or call
 
 The other member functions that have the same names with the corresponding underlying class (CallbackList, EventDispatcher, or EventQueue). Those functions add listener to the dispatcher.  
 
+<a id="a3_4"></a>
 ### Sample code
 
 ```c++
@@ -129,6 +148,7 @@ dispatcher.dispatch(event);
 
 ```
 
+<a id="a3_5"></a>
 ### Automatic disconnection
 
 ScopedRemover can be used to auto disconnect listeners when the object involved in the listeners is destroyed. For example, pseudo code,  
diff --git a/doc/tutorial_callbacklist.md b/doc/tutorial_callbacklist.md
index 2e2df20..51ed448 100644
--- a/doc/tutorial_callbacklist.md
+++ b/doc/tutorial_callbacklist.md
@@ -1,16 +1,21 @@
 # Tutorials of CallbackList
 
+<a id="a2_1"></a>
 ## Table Of Contents
 
-- [Tutorial 1 -- Basic usage](#tutorial1)
-- [Tutorial 2 -- Callback with parameters](#tutorial2)
-- [Tutorial 3 -- Remove](#tutorial3)
-- [Tutorial 4 -- For each](#tutorial4)
+<!--begintoc-->
+* [Table Of Contents](#a2_1)
+* [Tutorials](#a2_2)
+  * [CallbackList tutorial 1, basic](#a3_1)
+  * [CallbackList tutorial 2, callback with parameters](#a3_2)
+  * [CallbackList tutorial 3, remove](#a3_3)
+  * [CallbackList tutorial 4, for each](#a3_4)
+<!--endtoc-->
 
-<a name="tutorials"></a>
+<a id="a2_2"></a>
 ## Tutorials
 
-<a name="tutorial1"></a>
+<a id="a3_1"></a>
 ### CallbackList tutorial 1, basic
 
 **Code**  
@@ -62,7 +67,7 @@ callbackList();
 ```
 During the invoking, all callbacks will be invoked one by one in the order of they were added.
 
-<a name="tutorial2"></a>
+<a id="a3_2"></a>
 ### CallbackList tutorial 2, callback with parameters
 
 **Code**  
@@ -91,7 +96,7 @@ callbackList("Hello world", true);
 Now the callback list prototype takes two parameters, `const std::string &` and `const bool`.  
 The callback's prototype is not required to be same as the callback list, it's fine as long as the prototype is compatible with the callback list. See the second callback, `[](std::string s, int b)`, its prototype is not same as the callback list.
 
-<a name="tutorial3"></a>
+<a id="a3_3"></a>
 ### CallbackList tutorial 3, remove
 
 **Code**  
@@ -125,7 +130,7 @@ callbackList();
 
 **Remarks**  
 
-<a name="tutorial4"></a>
+<a id="a3_4"></a>
 ### CallbackList tutorial 4, for each
 
 **Code**  
diff --git a/doc/tutorial_eventdispatcher.md b/doc/tutorial_eventdispatcher.md
index 8db27ad..70d90ab 100644
--- a/doc/tutorial_eventdispatcher.md
+++ b/doc/tutorial_eventdispatcher.md
@@ -2,14 +2,10 @@
 
 ## Table Of Contents
 
-- [Tutorial 1 -- Basic usage](#tutorial1)
-- [Tutorial 2 -- Listener with parameters](#tutorial2)
-- [Tutorial 3 -- Customized event struct](#tutorial3)
+<!--toc-->
 
-<a name="tutorials"></a>
 ## Tutorials
 
-<a name="tutorial1"></a>
 ### Tutorial 1 -- Basic usage
 
 **Code**  
@@ -72,7 +68,6 @@ dispatcher.dispatch(5);
 Here we dispatched two events, one is event 3, the other is event 5.  
 During the dispatching, all listeners of that event will be invoked one by one in the order of they were added.
 
-<a name="tutorial2"></a>
 ### Tutorial 2 -- Listener with parameters
 
 **Code**  
@@ -106,7 +101,6 @@ dispatcher.dispatch(5, "World", false);
 Now the dispatcher callback prototype takes two parameters, `const std::string &` and `const bool`.  
 The listener's prototype is not required to be same as the dispatcher, it's fine as long as the prototype is compatible with the dispatcher. See the second listener, `[](std::string s, int b)`, its prototype is not same as the dispatcher.
 
-<a name="tutorial3"></a>
 ### Tutorial 3 -- Customized event struct
 
 **Code**  
diff --git a/doc/tutorial_eventqueue.md b/doc/tutorial_eventqueue.md
index d79a624..ef75a37 100644
--- a/doc/tutorial_eventqueue.md
+++ b/doc/tutorial_eventqueue.md
@@ -2,10 +2,8 @@
 
 ## Table Of Contents
 
-- [Tutorial 1 -- Basic usage](#tutorial1)
-- [Tutorial 2 -- multiple threading](#tutorial2)
+<!--toc-->
 
-<a name="tutorial1"></a>
 ### Tutorial 1 -- Basic usage
 
 **Code**  
@@ -46,7 +44,6 @@ A typical use case is in a GUI application, each components call `EventQueue<>::
 `EventQueue` supports non-copyable object as the event arguments, such as the unique pointer in the tutorial.
 
 
-<a name="tutorial2"></a>
 ### Tutorial 2 -- multiple threading
 
 **Code**  

From 0bad2cfe96d8087c96d5ca9ade42364c3165c0ef Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Sun, 31 Mar 2019 16:46:26 +0800
Subject: [PATCH 30/38] Removed one kind of forEach callback

---
 doc/callbacklist.md                        |  3 +-
 doc/eventdispatcher.md                     |  1 -
 include/eventpp/callbacklist.h             |  9 +---
 readme.md                                  |  3 +-
 tests/unittest/test_callbacklist_basic.cpp | 53 ++++++++++++++++++++++
 tests/unittest/tutorial_callbacklist.cpp   |  5 --
 6 files changed, 57 insertions(+), 17 deletions(-)

diff --git a/doc/callbacklist.md b/doc/callbacklist.md
index 81111fb..80457dd 100644
--- a/doc/callbacklist.md
+++ b/doc/callbacklist.md
@@ -48,7 +48,7 @@ class CallbackList;
 <a id="a3_3"></a>
 ### Public types
 
-`Handle`: the handle type returned by appendListener, prependListener and insertListener. A handle can be used to insert a callback or remove a callback. To check if a `Handle` is empty, convert it to boolean, *false* is empty. `Handle` is copyable.  
+`Handle`: the handle type returned by append, prepend and insert. A handle can be used to insert a callback or remove a callback. To check if a `Handle` is empty, convert it to boolean, *false* is empty. `Handle` is copyable.  
 `Callback`: the callback storage type.
 
 <a id="a3_4"></a>
@@ -117,7 +117,6 @@ Apply `func` to all callbacks.
 The `func` can be one of the three prototypes:  
 ```c++
 AnyReturnType func(const CallbackList::Handle &, const CallbackList::Callback &);
-AnyReturnType func(const CallbackList::Handle &);
 AnyReturnType func(const CallbackList::Callback &);
 ```
 **Note**: the `func` can remove any callbacks, or add other callbacks, safely.
diff --git a/doc/eventdispatcher.md b/doc/eventdispatcher.md
index 8fea660..d00d900 100644
--- a/doc/eventdispatcher.md
+++ b/doc/eventdispatcher.md
@@ -118,7 +118,6 @@ Apply `func` to all listeners of `event`.
 The `func` can be one of the three prototypes:  
 ```c++
 AnyReturnType func(const EventDispatcher::Handle &, const EventDispatcher::Callback &);
-AnyReturnType func(const EventDispatcher::Handle &);
 AnyReturnType func(const EventDispatcher::Callback &);
 ```
 **Note**: the `func` can remove any listeners, or add other listeners, safely.
diff --git a/include/eventpp/callbacklist.h b/include/eventpp/callbacklist.h
index 5a00806..d6a0686 100644
--- a/include/eventpp/callbacklist.h
+++ b/include/eventpp/callbacklist.h
@@ -236,7 +236,7 @@ class CallbackListBase<
 		return append(callback);
 	}
 
-	bool remove(const Handle handle)
+	bool remove(const Handle & handle)
 	{
 		std::lock_guard<Mutex> lockGuard(mutex);
 		auto node = handle.lock();
@@ -309,13 +309,6 @@ class CallbackListBase<
 		return func(Handle(node), node->callback);
 	}
 
-	template <typename RT, typename Func>
-	auto doForEachInvoke(Func && func, NodePtr & node) const
-		-> typename std::enable_if<CanInvoke<Func, Handle>::value, RT>::type
-	{
-		return func(Handle(node));
-	}
-
 	template <typename RT, typename Func>
 	auto doForEachInvoke(Func && func, NodePtr & node) const
 		-> typename std::enable_if<CanInvoke<Func, Callback &>::value, RT>::type
diff --git a/readme.md b/readme.md
index 544eec3..174a39f 100644
--- a/readme.md
+++ b/readme.md
@@ -119,7 +119,8 @@ queue.process();
 ## Build the unit tests
 
 The library itself is header only and doesn't need building.  
-The unit test requires CMake to build, and there is a makefile to ease the building.  
+The unit tests require CMake to build, and there is a makefile to ease the building.  
+Note the unit tests require C++14 (generic lambda), the library itself only requires C++11.  
 Go to folder `tests/build`, then run `make` with different target.
 - `make vc17` #generate solution files for Microsoft Visual Studio 2017, then open eventpptest.sln in folder project_vc17
 - `make vc15` #generate solution files for Microsoft Visual Studio 2015, then open eventpptest.sln in folder project_vc15
diff --git a/tests/unittest/test_callbacklist_basic.cpp b/tests/unittest/test_callbacklist_basic.cpp
index 8823815..1cf47b5 100644
--- a/tests/unittest/test_callbacklist_basic.cpp
+++ b/tests/unittest/test_callbacklist_basic.cpp
@@ -150,6 +150,59 @@ TEST_CASE("CallbackList, no memory leak after all callbacks are removed")
 	REQUIRE(checkAllWeakPtrAreFreed(nodeList));
 }
 
+TEST_CASE("CallbackList, forEach")
+{
+	using CL = eventpp::CallbackList<int()>;
+	CL callbackList;
+
+	callbackList.append([]() { return 1; });
+	callbackList.append([]() { return 2; });
+	callbackList.append([]() { return 3; });
+
+	int i = 1;
+	callbackList.forEach([&i](auto callback) {
+		REQUIRE(callback() == i);
+		++i;
+	});
+
+	i = 1;
+	callbackList.forEach([&i, &callbackList](const CL::Handle & handle, auto callback) {
+		REQUIRE(callback() == i);
+		++i;
+	});
+}
+
+TEST_CASE("CallbackList, forEachIf")
+{
+	using CL = eventpp::CallbackList<void ()>;
+	CL callbackList;
+
+	std::vector<int> dataList(3);
+
+	callbackList.append([&dataList]() {
+		dataList[0] += 1;
+	});
+	callbackList.append([&dataList]() {
+		dataList[1] += 2;
+	});
+	callbackList.append([&dataList]() {
+		dataList[2] += 3;
+	});
+
+	REQUIRE(dataList == std::vector<int>{ 0, 0, 0 });
+
+	int i = 0;
+	bool result = callbackList.forEachIf([&i](const std::function<void ()> & callback) -> bool {
+		callback();
+		++i;
+
+		return i != 2;
+	});
+
+	REQUIRE(! result);
+	REQUIRE(dataList == std::vector<int>{ 1, 2, 0 });
+}
+
 TEST_CASE("CallbackList, forEach and forEachIf")
 {
 	using CL = eventpp::CallbackList<void()>;
diff --git a/tests/unittest/tutorial_callbacklist.cpp b/tests/unittest/tutorial_callbacklist.cpp
index c771766..e66ff8f 100644
--- a/tests/unittest/tutorial_callbacklist.cpp
+++ b/tests/unittest/tutorial_callbacklist.cpp
@@ -118,11 +118,6 @@ TEST_CASE("CallbackList tutorial 4, for each")
 		++index;
 	});
 
-	// The forEach callback prototype can also be void(const CallbackList::Handle & handle)
-	callbackList.forEach([&callbackList, &index](const CL::Handle & /*handle*/) {
-		std::cout << "forEach(Handle), invoked" << std::endl;
-	});
-
 	// The forEach callback prototype can also be void(const CallbackList::Callback & callback)
 	callbackList.forEach([&callbackList, &index](const CL::Callback & /*callback*/) {
 		std::cout << "forEach(Callback), invoked" << std::endl;

From 0d082a5249a01df681c9007785fc963bc2b48c9a Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Sun, 31 Mar 2019 19:38:49 +0800
Subject: [PATCH 31/38] Added documents for heter-classes

---
 doc/callbacklist.md                           |   8 +-
 doc/eventdispatcher.md                        |  22 +--
 doc/eventqueue.md                             |   4 +-
 doc/hetercallbacklist.md                      | 126 ++++++++++++++
 doc/hetereventdispatcher.md                   | 116 +++++++++++++
 doc/hetereventqueue.md                        | 158 ++++++++++++++++++
 doc/heterogeneous.md                          |  85 ++++++++++
 include/eventpp/eventqueue.h                  |   6 +-
 include/eventpp/hetercallbacklist.h           |   9 +-
 include/eventpp/hetereventdispatcher.h        |  12 +-
 include/eventpp/hetereventqueue.h             |   4 +-
 tests/unittest/CMakeLists.txt                 |   1 +
 .../unittest/test_hetercallbacklist_basic.cpp |   2 +-
 tests/unittest/test_heterqueue_basic.cpp      |  32 ++--
 tests/unittest/test_queue_multithread.cpp     |  10 +-
 tests/unittest/tutorial_hetercallbacklist.cpp |  33 ++--
 16 files changed, 553 insertions(+), 75 deletions(-)
 create mode 100644 doc/hetercallbacklist.md
 create mode 100644 doc/hetereventdispatcher.md
 create mode 100644 doc/hetereventqueue.md
 create mode 100644 doc/heterogeneous.md

diff --git a/doc/callbacklist.md b/doc/callbacklist.md
index 80457dd..cd0010a 100644
--- a/doc/callbacklist.md
+++ b/doc/callbacklist.md
@@ -111,10 +111,10 @@ The time complexity is O(1).
 
 ```c++
 template <typename Func>  
-void forEach(Func && func);
+void forEach(Func && func) const;
 ```  
 Apply `func` to all callbacks.  
-The `func` can be one of the three prototypes:  
+The `func` can be one of the two prototypes:  
 ```c++
 AnyReturnType func(const CallbackList::Handle &, const CallbackList::Callback &);
 AnyReturnType func(const CallbackList::Callback &);
@@ -123,13 +123,13 @@ AnyReturnType func(const CallbackList::Callback &);
 
 ```c++
 template <typename Func>  
-bool forEachIf(Func && func);
+bool forEachIf(Func && func) const;
 ```  
 Apply `func` to all callbacks. `func` must return a boolean value, and if the return value is false, forEachIf stops the looping immediately.  
 Return `true` if all callbacks are invoked, or `event` is not found, `false` if `func` returns `false`.
 
 ```c++
-void operator() (Args ...args);
+void operator() (Args ...args) const;
 ```  
 Invoke each callbacks in the callback list.  
 The callbacks are called with arguments `args`.  
diff --git a/doc/eventdispatcher.md b/doc/eventdispatcher.md
index d00d900..e24fa0c 100644
--- a/doc/eventdispatcher.md
+++ b/doc/eventdispatcher.md
@@ -100,22 +100,12 @@ Remove the listener *handle* which listens to *event* from the dispatcher.
 Return true if the listener is removed successfully, false if the listener is not found.  
 The time complexity is O(1).  
 
-```c++
-void dispatch(Args ...args);  
-
-template <typename T>  
-void dispatch(T && first, Args ...args);
-```  
-Dispatch an event. The event type is deducted from the arguments of `dispatch`.  
-In both overloads, the listeners are called with arguments `args`.  
-The function is synchronous. The listeners are called in the thread same as the caller of `dispatch`.
-
 ```c++
 template <typename Func>  
 void forEach(const Event & event, Func && func);
 ```  
 Apply `func` to all listeners of `event`.  
-The `func` can be one of the three prototypes:  
+The `func` can be one of the two prototypes:  
 ```c++
 AnyReturnType func(const EventDispatcher::Handle &, const EventDispatcher::Callback &);
 AnyReturnType func(const EventDispatcher::Callback &);
@@ -129,6 +119,16 @@ bool forEachIf(const Event & event, Func && func);
 Apply `func` to all listeners of `event`. `func` must return a boolean value, and if the return value is false, forEachIf stops the looping immediately.  
 Return `true` if all listeners are invoked, or `event` is not found, `false` if `func` returns `false`.
 
+```c++
+void dispatch(Args ...args);  
+
+template <typename T>  
+void dispatch(T && first, Args ...args);
+```  
+Dispatch an event. The event type is deducted from the arguments of `dispatch`.  
+In both overloads, the listeners are called with arguments `args`.  
+The function is synchronous. The listeners are called in the thread same as the caller of `dispatch`.
+
 <a id="a2_4"></a>
 ## Nested listener safety
 1. If a listener adds another listener of the same event to the dispatcher during a dispatching, the new listener is guaranteed not to be triggered within the same dispatching. This is guaranteed by an unsigned 64 bits integer counter. This rule will be broken is the counter is overflowed to zero in a dispatching, but this rule will continue working on the subsequence dispatching.  
diff --git a/doc/eventqueue.md b/doc/eventqueue.md
index 713fd91..b4c1756 100644
--- a/doc/eventqueue.md
+++ b/doc/eventqueue.md
@@ -117,11 +117,11 @@ Process the event queue. Before processing an event, the event is passed to `fun
 2. Process the events until certain time. For example, in a game engine, the event process may be limited to only several milliseconds, the remaining events will be process in next game loop.  
 
 ```c++
-bool empty() const;
+bool emptyQueue() const;
 ```
 Return true if there is no any event in the event queue, false if there are any events in the event queue.  
 Note: in multiple threading environment, the empty state may change immediately after the function returns.  
-Note: don't write loop as `while(! eventQueue.empty()) {}`. It's dead loop since the compiler will inline the code and the change of empty state is never seen by the loop. The safe approach is `while(eventQueue.waitFor(std::chrono::nanoseconds(0))) ;`.  
+Note: don't write loop as `while(! eventQueue.emptyQueue()) {}`. It's dead loop since the compiler will inline the code and the change of empty state is never seen by the loop. The safe approach is `while(eventQueue.waitFor(std::chrono::nanoseconds(0))) ;`.  
 
 ```c++
 void clearEvents();
diff --git a/doc/hetercallbacklist.md b/doc/hetercallbacklist.md
new file mode 100644
index 0000000..256b0d0
--- /dev/null
+++ b/doc/hetercallbacklist.md
@@ -0,0 +1,126 @@
+# Class HeterCallbackList reference
+
+## Table Of Contents
+
+<!--toc-->
+
+## Description
+
+HeterCallbackList is the heterogeneous counterpart of CallbackList in eventpp. The other classes HeterEventDispatcher and HeterEventQueue are built on HeterCallbackList.  
+
+HeterCallbackList holds a list of callbacks. The callbacks can have different prototypes. At the time of the call, HeterCallbackList invokes each callback which matches the invoking parameters.  
+The *callback* can be any callback target -- functions, pointers to functions, , pointers to member functions, lambda expressions, and function objects.  
+
+## API reference
+
+### Header
+
+eventpp/hetercallbacklist.h
+
+### Template parameters
+
+```c++
+template <
+	typename PrototypeList,
+	typename Policies = DefaultPolicies
+>
+class HeterCallbackList;
+```
+`Prototype`:  a list of function types in `eventpp::HeterTuple`, such as `eventpp::HeterTuple<void (), void (std::string), void (int, int)>`.  
+`Policies`: the policies to configure and extend the callback list. The default value is `DefaultPolicies`. See [document of policies](policies.md) for details.  
+
+### Public types
+
+`Handle`: the handle type returned by append, prepend and insert. A handle can be used to insert a callback or remove a callback. To check if a `Handle` is empty, convert it to boolean, *false* is empty. `Handle` is copyable.  
+`Callback`: the callback storage type.
+
+### Member functions
+
+```c++
+HeterCallbackList() noexcept;
+HeterCallbackList(const HeterCallbackList & other);
+HeterCallbackList(HeterCallbackList && other) noexcept;
+HeterCallbackList & operator = (const HeterCallbackList & other);
+HeterCallbackList & operator = (HeterCallbackList && other) noexcept;
+```
+
+HeterCallbackList can be copied, moved,  assigned, and move assigned.
+
+```c++
+bool empty() const;
+```
+Return true if the callback list is empty.  
+Note: in multi threading, this function returning true doesn't guarantee that the list is empty. The list may immediately become non-empty after the function returns true.
+
+```c++
+operator bool() const;
+```
+Return true if the callback list is not empty.  
+This operator allows a HeterCallbackList instance be used in condition statement.
+
+```c++
+template <typename C>
+Handle append(const C & callback);
+```  
+Add the `callback` to the callback list.  
+The callback is added to the end of the callback list.  
+The callback type `C` must be specified in `PrototypeList`.  
+Return a handle that represents the callback. The handle can be used to remove this callback or to insert additional callbacks before this callback.  
+If `append` is called in another callback during the invoking of the callback list, the new callback is guaranteed not to be triggered during the same callback list invoking.  
+The time complexity is O(1).
+
+```c++
+template <typename C>
+Handle prepend(const C & callback);
+```  
+Add the *callback* to the callback list.  
+The callback is added to the beginning of the callback list.  
+The callback type `C` must be specified in `PrototypeList`.  
+Return a handle that represents the callback. The handle can be used to remove this callback or to insert additional callbacks before this callback.  
+If `prepend` is called in another callback during the invoking of the callback list, the new callback is guaranteed not to be triggered during the same callback list invoking.  
+The time complexity is O(1).
+
+```c++
+template <typename C>
+Handle insert(const C & callback, const Handle & before);
+```  
+Insert the *callback* to the callback list before the callback handle *before*. If *before* is not found, *callback* is added at the end of the callback list.  
+The callback type `C` must be specified in `PrototypeList`.  
+Return a handle that represents the callback. The handle can be used to remove this callback or to insert additional callbacks before this callback.  
+If `insert` is called in another callback during the invoking of the callback list, the new callback is guaranteed not to be triggered during the same callback list invoking.  
+The time complexity is O(1).  
+
+```c++
+bool remove(const Handle & handle);
+```  
+Remove the callback *handle* from the callback list.  
+Return true if the callback is removed successfully, false if the callback is not found.  
+The time complexity is O(1).  
+
+```c++
+template <typename Prototype, typename Func>
+void forEach(Func && func) const;
+```  
+Apply `func` to all callbacks which has the `Prototype`.  
+The `func` can be one of the two prototypes:  
+```c++
+AnyReturnType func(const HeterCallbackList::Handle &, const std::function<Prototype> &);
+AnyReturnType func(const std::function<Prototype> &);
+```
+**Note**: the `func` can remove any callbacks, or add other callbacks, safely.
+
+```c++
+template <typename Prototype, typename Func>
+bool forEachIf(Func && func) const;
+```  
+Apply `func` to all callbacks. `func` must return a boolean value, and if the return value is false, forEachIf stops the looping immediately.  
+Return `true` if all callbacks are invoked, or `event` is not found, `false` if `func` returns `false`.
+
+```c++
+template <typename ...Args>
+void operator() (Args && ...args) const;
+```  
+Invoke each callbacks that can be called with `Args` in the callback list.  
+The callbacks are called with arguments `args`.  
+The callbacks are called in the thread same as the callee of `operator()`.
+
diff --git a/doc/hetereventdispatcher.md b/doc/hetereventdispatcher.md
new file mode 100644
index 0000000..e724b20
--- /dev/null
+++ b/doc/hetereventdispatcher.md
@@ -0,0 +1,116 @@
+# Class HeterEventDispatcher reference
+
+## Table Of Contents
+
+<!--toc-->
+
+## Description
+
+HeterEventDispatcher is something like std::map<EventType, HeterCallbackList>.
+
+HeterEventDispatcher holds a map of `<EventType, HeterCallbackList>` pairs. On dispatching, HeterEventDispatcher finds the HeterCallbackList of the event type, then invoke the callback list. The invocation is always synchronous. The listeners are triggered when `HeterEventDispatcher::dispatch` is called.  
+
+## API reference
+
+### Header
+
+eventpp/hetereventdispatcher.h
+
+### Template parameters
+
+```c++
+template <
+	typename Event,
+	typename PrototypeList,
+	typename Policies = DefaultPolicies
+>
+class HeterEventDispatcher;
+```
+`Event`: the *event type*. The type used to identify the event. Events with same type are the same event. The event type must be able to be used as the key in `std::map` or `std::unordered_map`, so it must be either comparable with `operator <` or has specialization of `std::hash`.  
+`Prototype`:  a list of function types in `eventpp::HeterTuple`, such as `eventpp::HeterTuple<void (), void (std::string), void (int, int)>`.  
+`Policies`: the policies to configure and extend the dispatcher. The default value is `DefaultPolicies`. See [document of policies](policies.md) for details.  
+
+### Public types
+
+`Handle`: the handle type returned by appendListener, prependListener and insertListener. A handle can be used to insert a listener or remove a listener. To check if a `Handle` is empty, convert it to boolean, *false* is empty. `Handle` is copyable.  
+`Event`: the event type.  
+
+### Member functions
+
+```c++
+HeterEventDispatcher();
+HeterEventDispatcher(const HeterEventDispatcher & other);
+HeterEventDispatcher(HeterEventDispatcher && other) noexcept;
+HeterEventDispatcher & operator = (const HeterEventDispatcher & other);
+HeterEventDispatcher & operator = (HeterEventDispatcher && other) noexcept;
+```
+
+HeterEventDispatcher can be copied, moved,  assigned, and move assigned.
+
+```c++
+template <typename C>
+Handle appendListener(const Event & event, const C & callback);
+```  
+Add the *callback* to the dispatcher to listen to *event*.  
+The listener is added to the end of the listener list.  
+The callback type `C` must be specified in `PrototypeList`.  
+Return a handle which represents the listener. The handle can be used to remove this listener or insert other listener before this listener.  
+If `appendListener` is called in another listener during a dispatching, the new listener is guaranteed not triggered during the same dispatching.  
+If the same callback is added twice, it results duplicated listeners.  
+The time complexity is O(1).
+
+```c++
+template <typename C>
+Handle prependListener(const Event & event, const C & callback);
+```  
+Add the *callback* to the dispatcher to listen to *event*.  
+The listener is added to the beginning of the listener list.  
+The callback type `C` must be specified in `PrototypeList`.  
+Return a handle which represents the listener. The handle can be used to remove this listener or insert other listener before this listener.  
+If `prependListener` is called in another listener during a dispatching, the new listener is guaranteed not triggered during the same dispatching.  
+The time complexity is O(1).
+
+```c++
+template <typename C>
+Handle insertListener(const Event & event, const C & callback, const Handle & before);
+```  
+Insert the *callback* to the dispatcher to listen to *event* before the listener handle *before*. If *before* is not found, *callback* is added at the end of the listener list.  
+The callback type `C` must be specified in `PrototypeList`.  
+Return a handle which represents the listener. The handle can be used to remove this listener or insert other listener before this listener.  
+If `insertListener` is called in another listener during a dispatching, the new listener is guaranteed not triggered during the same dispatching.  
+The time complexity is O(1).  
+
+```c++
+bool removeListener(const Event & event, const Handle handle);
+```  
+Remove the listener *handle* which listens to *event* from the dispatcher.  
+Return true if the listener is removed successfully, false if the listener is not found.  
+The time complexity is O(1).  
+
+```c++
+template <typename Prototype, typename Func>
+void forEach(const Event & event, Func && func) const;
+```  
+Apply `func` to all callbacks which has the `Prototype`.  
+The `func` can be one of the two prototypes:  
+```c++
+AnyReturnType func(const HeterEventDispatcher::Handle &, const HeterEventDispatcher::Callback &);
+AnyReturnType func(const HeterEventDispatcher::Callback &);
+```
+**Note**: the `func` can remove any listeners, or add other listeners, safely.
+
+```c++
+template <typename Prototype, typename Func>
+bool forEachIf(const Event & event, Func && func) const;
+```  
+Apply `func` to all listeners of `event`. `func` must return a boolean value, and if the return value is false, forEachIf stops the looping immediately.  
+Return `true` if all listeners are invoked, or `event` is not found, `false` if `func` returns `false`.
+
+```c++
+template <typename T, typename ...Args>
+void dispatch(T && first, Args && ...args) const
+```  
+Dispatch an event. The event type is deducted from the arguments of `dispatch`.  
+Invoke each callbacks that can be called with `Args` in the callback list.  
+The listeners are called with arguments `args`.  
+The function is synchronous. The listeners are called in the thread same as the caller of `dispatch`.
diff --git a/doc/hetereventqueue.md b/doc/hetereventqueue.md
new file mode 100644
index 0000000..0b5ceec
--- /dev/null
+++ b/doc/hetereventqueue.md
@@ -0,0 +1,158 @@
+# Class HeterEventQueue reference
+
+## Table Of Contents
+
+<!--toc-->
+
+## Description
+
+HeterEventQueue includes all features of HeterEventDispatcher and adds event queue features. Note: HeterEventQueue doesn't inherit from HeterEventDispatcher, don't try to cast HeterEventQueue to HeterEventDispatcher.  
+HeterEventQueue is asynchronous. Events are cached in the queue when `HeterEventQueue::enqueue` is called, and dispatched later when `HeterEventQueue::process` is called.  
+HeterEventQueue is equivalent to the event system (QEvent) in Qt, or the message processing in Windows API.  
+
+## API reference
+
+### Header
+
+eventpp/eventqueue.h
+
+### Template parameters
+
+```c++
+template <
+	typename Event,
+	typename PrototypeList,
+	typename Policies = DefaultPolicies
+>
+class HeterEventQueue;
+```
+
+HeterEventQueue has the exactly same template parameters with EventDispatcher. Please reference [HeterEventDispatcher document](hetereventdispatcher.md) for details.
+
+### Public types
+
+### Member functions
+
+```c++
+HeterEventQueue();
+HeterEventQueue(const HeterEventQueue & other);
+HeterEventQueue(HeterEventQueue && other) noexcept;
+HeterEventQueue & operator = (const HeterEventQueue & other);
+HeterEventQueue & operator = (HeterEventQueue && other) noexcept;
+```
+
+EventDispatcher can be copied, moved,  assigned, and move assigned.  
+Note: the queued events are not copied, moved, assigned, or move assigned, only the listeners are performed these operations.
+
+```c++
+template <typename T, typename ...Args>
+void enqueue(T && first, Args && ...args);
+```  
+Put an event into the event queue. The event type is deducted from the arguments of `enqueue`.  
+All copyable arguments are copied to internal data structure. All non-copyable but movable arguments are moved.  
+HeterEventQueue requires the arguments either copyable or movable.  
+If an argument is a reference to a base class and a derived object is passed in, only the base object will be stored and the derived object is lost. Usually shared pointer should be used in such situation.  
+If an argument is a pointer, only the pointer will be stored. The object it points to must be available until the event is processed.  
+`enqueue` wakes up any threads that are blocked by `wait` or `waitFor`.  
+The time complexity is O(1).  
+
+```c++
+bool process();
+```  
+Process the event queue. All events in the event queue are dispatched once and then removed from the queue.  
+The function returns true if any events were processed, false if no event was processed.  
+The listeners are called in the thread same as the caller of `process`.  
+Any new events added to the queue during `process()` are not dispatched during current `process()`.  
+`process()` is efficient in single thread event processing, it processes all events in the queue in current thread. To process events from multiple threads efficiently, use `processOne()`.  
+Note: if `process()` is called from multiple threads simultaneously, the events in the event queue are guaranteed dispatched only once.  
+
+```c++
+bool processOne();
+```  
+Process one event in the event queue. The first event in the event queue is dispatched once and then removed from the queue.  
+The function returns true if one event was processed, false if no event was processed.  
+The listener is called in the thread same as the caller of `processOne`.  
+Any new events added to the queue during `processOne()` are not dispatched during current `processOne()`.  
+If there are multiple threads processing events, `processOne()` is more efficient than `process()` because it can split the events processing to different threads. However, if there is only one thread processing events, 'process()' is more efficient.  
+Note: if `processOne()` is called from multiple threads simultaneously, the events in the event queue are guaranteed dispatched only once.  
+
+```c++
+template <typename F>
+bool processIf(F && func);
+```
+Process the event queue. Before processing an event, the event is passed to `func` and the event will be processed only if `func` returns true.  
+`func` takes exactly the same arguments as `HeterEventQueue::enqueue`, and returns a boolean value.  
+`processIf` returns true if any event was dispatched, false if no event was dispatched.  
+`processIf` has some good use scenarios:  
+1. Process certain events in certain thread. For example, in a GUI application, the UI related events may be only desired to processed in the main thread.  
+2. Process the events until certain time. For example, in a game engine, the event process may be limited to only several milliseconds, the remaining events will be process in next game loop.  
+
+```c++
+bool emptyQueue() const;
+```
+Return true if there is no any event in the event queue, false if there are any events in the event queue.  
+Note: in multiple threading environment, the empty state may change immediately after the function returns.  
+Note: don't write loop as `while(! eventQueue.emptyQueue()) {}`. It's dead loop since the compiler will inline the code and the change of empty state is never seen by the loop. The safe approach is `while(eventQueue.waitFor(std::chrono::nanoseconds(0))) ;`.  
+
+```c++
+void clearEvents();
+```
+Clear all queued events without dispatching them.  
+This is useful to clear any references such as shared pointer in the queued events to avoid cyclic reference.
+
+```c++
+void wait() const;
+```
+`wait` causes the current thread to block until there is new event arrives in the queue.  
+Note: though `wait` has work around with spurious wakeup internally, the queue is not guaranteed not empty after `wait` returns.  
+`wait` is useful when a thread processes the event queue. A sampel usage is,
+```c++
+for(;;) {
+	eventQueue.wait();
+	eventQueue.process();
+}
+```
+The code works event if it doesn't `wait`, but doing that will waste CPU power resource.
+
+```c++
+template <class Rep, class Period>
+bool waitFor(const std::chrono::duration<Rep, Period> & duration) const;
+```
+Wait for no longer than *duration* time out.  
+Return true if the queue is not empty, false if the return is caused by time out.  
+`waitFor` is useful when a event queue processing thread has other condition to check. For example,
+```c++
+std::atomic<bool> shouldStop(false);
+for(;;) {
+	while(! eventQueue.waitFor(std::chrono::milliseconds(10)) && ! shouldStop.load()) ;
+	if(shouldStop.load()) {
+		break;
+	}
+
+	eventQueue.process();
+}
+```
+
+**Inner class HeterEventQueue::DisableQueueNotify**  
+
+`HeterEventQueue::DisableQueueNotify` is a RAII class that temporarily prevents the event queue from waking up any waiting threads. When any `DisableQueueNotify` object exist, calling `enqueue` doesn't wake up any threads that are blocked by `wait`. When the `DisableQueueNotify` object is out of scope, the waking up is resumed. If there are more than one `DisableQueueNotify` objects, the waking up is only resumed after all `DisableQueueNotify` objects are destroyed.  
+`DisableQueueNotify` is useful to improve performance when batching adding events to the queue. For example, in a main loop of a game engine, `DisableQueueNotify` can be created on the start in a frame, then the game adding events to the queue, and the `DisableQueueNotify` is destroyed at the end of a frame and the events are processed.
+
+To use `DisableQueueNotify`, construct it with a pointer to event queue.
+
+Sample code
+```c++
+using EQ = eventpp::HeterEventQueue<int, void ()>;
+EQ queue;
+{
+	EQ::DisableQueueNotify disableNotify(&queue);
+	// any blocking threads will not be waken up by the below two lines.
+	queue.enqueue(1);
+	queue.enqueue(2);
+}
+// any blocking threads are waken up here immediately.
+
+// any blocking threads will be waken up by below line since there is no DisableQueueNotify.
+queue.enqueue(3);
+```
+
diff --git a/doc/heterogeneous.md b/doc/heterogeneous.md
new file mode 100644
index 0000000..6c068b8
--- /dev/null
+++ b/doc/heterogeneous.md
@@ -0,0 +1,85 @@
+# Heterogeneous classes
+
+## Description
+
+'CallbackList', 'EventDispatcher', and 'EventQueue' are homogeneous. All listeners must have the same prototype. For example,
+
+```c++
+eventpp::EventDispatcher<int, void ()> dispatcher;
+dispatcher.appendListener(3, []() {}); // OK
+dispatcher.appendListener(3, [](std::string) {}); // wrong, can't listen for void(std::string)
+```
+
+There are heterogeneous counterparts, 'HeterCallbackList', 'HeterEventDispatcher', and 'HeterEventQueue'. These classes allow listeners having different prototypes. For example,
+
+```c++
+eventpp::HeterEventDispatcher<int, eventpp::HeterTuple<void (), void (std::string)> > dispatcher;
+dispatcher.appendListener(3, []() {}); // OK
+dispatcher.appendListener(3, [](std::string) {}); // OK
+```
+
+## Usage
+
+### Headers
+
+eventpp/hetercallbacklist.h  
+eventpp/hetereventdispatcher.h  
+eventpp/hetereventqueue.h  
+
+### Template parameters
+
+```c++
+template <
+	typename PrototypeList,
+	typename Policies = DefaultPolicies
+>
+class HeterCallbackList;
+
+template <
+	typename Event,
+	typename PrototypeList,
+	typename Policies = DefaultPolicies
+>
+class HeterEventDispatcher;
+
+template <
+	typename Event,
+	typename PrototypeList,
+	typename Policies = DefaultPolicies
+>
+class HeterEventQueue;
+```
+
+For comparison, below are the template parameters for the homogeneous counterparts
+
+```c++
+template <
+	typename Prototype,
+	typename Policies = DefaultPolicies
+>
+class CallbackList;
+
+template <
+	typename Event,
+	typename Prototype,
+	typename Policies = DefaultPolicies
+>
+class EventDispatcher;
+
+template <
+	typename Event,
+	typename Prototype,
+	typename Policies = DefaultPolicies
+>
+class EventQueue;
+```
+
+The only difference is the `Prototype` in homo-classes becomes `PrototypeList` in heter-classes.  
+In the homo-classes, `Prototype` is a single function type such as `void ()`.  
+In the heter-classes, `PrototypeList` is a list of function types in `eventpp::HeterTuple`, such as `eventpp::HeterTuple<void (), void (std::string), void (int, int)>`.  
+Note: Ideally it would be better to use `std::tuple` instead of `eventpp::HeterTuple`, but the problem is that the tuple is instantiated in HeterEventDispatcher which cause compile error that function type can't be instantiated.
+
+### Member functions and types
+
+The heter-classes have similar functions and types as the homo-classes. The major difference is, in the homo-classes, listeners can have only one prototype, while in the heter-classes, listeners can have any prototypes which are in the `PrototypeList` specified in the class template parameters.
+
diff --git a/include/eventpp/eventqueue.h b/include/eventpp/eventqueue.h
index d875b32..cb382b1 100644
--- a/include/eventpp/eventqueue.h
+++ b/include/eventpp/eventqueue.h
@@ -98,7 +98,7 @@ class EventQueueBase <
 		{
 			--queue->queueNotifyCounter;
 
-			if(queue->doCanNotifyQueueAvailable() && ! queue->empty()) {
+			if(queue->doCanNotifyQueueAvailable() && ! queue->emptyQueue()) {
 				queue->queueListConditionVariable.notify_one();
 			}
 		}
@@ -176,7 +176,7 @@ class EventQueueBase <
 		}
 	}
 
-	bool empty() const
+	bool emptyQueue() const
 	{
 		return queueList.empty() && (queueEmptyCounter.load(std::memory_order_acquire) == 0);
 	}
@@ -397,7 +397,7 @@ class EventQueueBase <
 protected:
 	bool doCanProcess() const
 	{
-		return ! empty() && doCanNotifyQueueAvailable();
+		return ! emptyQueue() && doCanNotifyQueueAvailable();
 	}
 
 	bool doCanNotifyQueueAvailable() const
diff --git a/include/eventpp/hetercallbacklist.h b/include/eventpp/hetercallbacklist.h
index 71c7984..6e3bec5 100644
--- a/include/eventpp/hetercallbacklist.h
+++ b/include/eventpp/hetercallbacklist.h
@@ -202,7 +202,7 @@ class HeterCallbackListBase
 		};
 	}
 
-	bool remove(const Handle handle)
+	bool remove(const Handle & handle)
 	{
 		auto callbackList = callbackListList[handle.index];
 		if(callbackList) {
@@ -256,13 +256,6 @@ class HeterCallbackListBase
 		return func(Handle { PrototypeIndex, handle }, callback);
 	}
 
-	template <typename RT, int PrototypeIndex, typename Func, typename H, typename CL>
-	auto doForEachInvoke(Func && func, const H & handle, const CL & callback) const
-		-> typename std::enable_if<CanInvoke<Func, Handle>::value, RT>::type
-	{
-		return func(Handle { PrototypeIndex, handle });
-	}
-
 	template <typename RT, int PrototypeIndex, typename Func, typename H, typename CL>
 	auto doForEachInvoke(Func && func, const H & handle, CL && callback) const
 		-> typename std::enable_if<CanInvoke<Func, CL>::value, RT>::type
diff --git a/include/eventpp/hetereventdispatcher.h b/include/eventpp/hetereventdispatcher.h
index 094ad0b..f6e1418 100644
--- a/include/eventpp/hetereventdispatcher.h
+++ b/include/eventpp/hetereventdispatcher.h
@@ -125,24 +125,24 @@ class HeterEventDispatcherBase
 		first.swap(second);
 	}
 
-	template <typename Callback>
-	Handle appendListener(const Event & event, const Callback & callback)
+	template <typename C>
+	Handle appendListener(const Event & event, const C & callback)
 	{
 		std::lock_guard<Mutex> lockGuard(listenerMutex);
 
 		return eventCallbackListMap[event].append(callback);
 	}
 
-	template <typename Callback>
-	Handle prependListener(const Event & event, const Callback & callback)
+	template <typename C>
+	Handle prependListener(const Event & event, const C & callback)
 	{
 		std::lock_guard<Mutex> lockGuard(listenerMutex);
 
 		return eventCallbackListMap[event].prepend(callback);
 	}
 
-	template <typename Callback>
-	Handle insertListener(const Event & event, const Callback & callback, const Handle & before)
+	template <typename C>
+	Handle insertListener(const Event & event, const C & callback, const Handle & before)
 	{
 		std::lock_guard<Mutex> lockGuard(listenerMutex);
 
diff --git a/include/eventpp/hetereventqueue.h b/include/eventpp/hetereventqueue.h
index bc5762a..5ab26c6 100644
--- a/include/eventpp/hetereventqueue.h
+++ b/include/eventpp/hetereventqueue.h
@@ -139,7 +139,7 @@ class HeterEventQueueBase : public HeterEventDispatcherBase<
 		doEnqueue<ArgumentPassingMode>(std::forward<T>(first), std::forward<Args>(args)...);
 	}
 
-	bool empty() const
+	bool emptyQueue() const
 	{
 		return queueList.empty() && (queueEmptyCounter.load(std::memory_order_acquire) == 0);
 	}
@@ -259,7 +259,7 @@ class HeterEventQueueBase : public HeterEventDispatcherBase<
 private:
 	bool doCanProcess() const
 	{
-		return ! empty() && doCanNotifyQueueAvailable();
+		return ! emptyQueue() && doCanNotifyQueueAvailable();
 	}
 
 	bool doCanNotifyQueueAvailable() const
diff --git a/tests/unittest/CMakeLists.txt b/tests/unittest/CMakeLists.txt
index 63c8f52..8b4ab64 100644
--- a/tests/unittest/CMakeLists.txt
+++ b/tests/unittest/CMakeLists.txt
@@ -32,3 +32,4 @@ set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads REQUIRED)
 target_link_libraries(${TARGET_TEST} Threads::Threads)
 
+set_target_properties(${TARGET_TEST} PROPERTIES CXX_STANDARD 14)
diff --git a/tests/unittest/test_hetercallbacklist_basic.cpp b/tests/unittest/test_hetercallbacklist_basic.cpp
index 5607a0c..edaef12 100644
--- a/tests/unittest/test_hetercallbacklist_basic.cpp
+++ b/tests/unittest/test_hetercallbacklist_basic.cpp
@@ -225,7 +225,7 @@ TEST_CASE("HeterCallbackList, forEach")
 	callbackList.append([](int n) { return n + 5 + 2; });
 
 	int i = 1;
-	callbackList.forEach<int ()>([&i](const std::function<int ()> & callback) {
+	callbackList.forEach<int ()>([&i](auto callback) {
 		REQUIRE(callback() == i);
 		++i;
 	});
diff --git a/tests/unittest/test_heterqueue_basic.cpp b/tests/unittest/test_heterqueue_basic.cpp
index 103f675..0698805 100644
--- a/tests/unittest/test_heterqueue_basic.cpp
+++ b/tests/unittest/test_heterqueue_basic.cpp
@@ -19,53 +19,53 @@ TEST_CASE("HeterEventQueue, clearEvents")
 	eventpp::HeterEventQueue<int, eventpp::HeterTuple<void (), void (int)> > queue;
 
 	SECTION("void ()") {
-		REQUIRE(queue.empty());
+		REQUIRE(queue.emptyQueue());
 
 		queue.enqueue(1);
 
-		REQUIRE(! queue.empty());
+		REQUIRE(! queue.emptyQueue());
 
 		queue.clearEvents();
-		REQUIRE(queue.empty());
+		REQUIRE(queue.emptyQueue());
 	}
 
 	SECTION("void (int)") {
-		REQUIRE(queue.empty());
+		REQUIRE(queue.emptyQueue());
 
 		queue.enqueue(6, 3);
 
-		REQUIRE(! queue.empty());
+		REQUIRE(! queue.emptyQueue());
 
 		queue.clearEvents();
-		REQUIRE(queue.empty());
+		REQUIRE(queue.emptyQueue());
 	}
 
 	SECTION("void (), more events") {
-		REQUIRE(queue.empty());
+		REQUIRE(queue.emptyQueue());
 
 		queue.enqueue(6);
 
-		REQUIRE(! queue.empty());
+		REQUIRE(! queue.emptyQueue());
 
 		queue.enqueue(10);
 		queue.enqueue(99);
 
 		queue.clearEvents();
-		REQUIRE(queue.empty());
+		REQUIRE(queue.emptyQueue());
 	}
 
 	SECTION("void (int), more events") {
-		REQUIRE(queue.empty());
+		REQUIRE(queue.emptyQueue());
 
 		queue.enqueue(1, 3);
 
-		REQUIRE(! queue.empty());
+		REQUIRE(! queue.emptyQueue());
 
 		queue.enqueue(2, 5);
 		queue.enqueue(8, 6);
 
 		queue.clearEvents();
-		REQUIRE(queue.empty());
+		REQUIRE(queue.emptyQueue());
 	}
 }
 
@@ -75,19 +75,19 @@ TEST_CASE("HeterEventQueue, enqueue")
 	constexpr int event = 3;
 
 	SECTION("void ()") {
-		REQUIRE(queue.empty());
+		REQUIRE(queue.emptyQueue());
 
 		queue.enqueue(event);
 
-		REQUIRE(! queue.empty());
+		REQUIRE(! queue.emptyQueue());
 	}
 
 	SECTION("void (int)") {
-		REQUIRE(queue.empty());
+		REQUIRE(queue.emptyQueue());
 
 		queue.enqueue(event, 3);
 
-		REQUIRE(! queue.empty());
+		REQUIRE(! queue.emptyQueue());
 	}
 }
 
diff --git a/tests/unittest/test_queue_multithread.cpp b/tests/unittest/test_queue_multithread.cpp
index 2fad3b3..51adca6 100644
--- a/tests/unittest/test_queue_multithread.cpp
+++ b/tests/unittest/test_queue_multithread.cpp
@@ -103,13 +103,13 @@ TEST_CASE("EventQueue, multi threading, one thread waits")
 		queue.enqueue(otherEvent, 1);
 		waitUntilQueueEmpty();
 		REQUIRE(threadProcessCount.load() == 1);
-		REQUIRE(queue.empty());
+		REQUIRE(queue.emptyQueue());
 		REQUIRE(dataList == std::vector<int>{ 0, 2, 0, 0, 0 });
 
 		queue.enqueue(otherEvent, 3);
 		waitUntilQueueEmpty();
 		REQUIRE(threadProcessCount.load() == 2);
-		REQUIRE(queue.empty());
+		REQUIRE(queue.emptyQueue());
 		REQUIRE(dataList == std::vector<int>{ 0, 2, 0, 4, 0 });
 	}
 
@@ -117,7 +117,7 @@ TEST_CASE("EventQueue, multi threading, one thread waits")
 		queue.enqueue(otherEvent, 1);
 		std::this_thread::sleep_for(std::chrono::milliseconds(10));
 		REQUIRE(threadProcessCount.load() == 1);
-		REQUIRE(queue.empty());
+		REQUIRE(queue.emptyQueue());
 
 		queue.enqueue(otherEvent, 3);
 		waitUntilQueueEmpty();
@@ -133,12 +133,12 @@ TEST_CASE("EventQueue, multi threading, one thread waits")
 			queue.enqueue(otherEvent, 2);
 			std::this_thread::sleep_for(std::chrono::milliseconds(10));
 			REQUIRE(threadProcessCount.load() == 0);
-			REQUIRE(! queue.empty());
+			REQUIRE(! queue.emptyQueue());
 
 			queue.enqueue(otherEvent, 4);
 			std::this_thread::sleep_for(std::chrono::milliseconds(10));
 			REQUIRE(threadProcessCount.load() == 0);
-			REQUIRE(! queue.empty());
+			REQUIRE(! queue.emptyQueue());
 		}
 
 		waitUntilQueueEmpty();
diff --git a/tests/unittest/tutorial_hetercallbacklist.cpp b/tests/unittest/tutorial_hetercallbacklist.cpp
index d2ebd1b..0d7864a 100644
--- a/tests/unittest/tutorial_hetercallbacklist.cpp
+++ b/tests/unittest/tutorial_hetercallbacklist.cpp
@@ -44,29 +44,32 @@ TEST_CASE("HeterCallbackList tutorial 1, basic")
 	callbackList(5);
 }
 
-#if 0
 TEST_CASE("HeterCallbackList tutorial 2, for each")
 {
-	std::cout << "HeterCallbackList tutorial 4, for each" << std::endl;
+	std::cout << "HeterCallbackList tutorial 2, for each" << std::endl;
 
-	using CL = eventpp::HeterCallbackList<eventpp::HeterTuple<void (), void (int), void (int, int)> >;
+	using CL = eventpp::HeterCallbackList<eventpp::HeterTuple<void (), void (int)> >;
 	CL callbackList;
 
 	// Add some callbacks.
 	callbackList.append([]() {
 		std::cout << "Got callback void()." << std::endl;
 	});
+	callbackList.append([]() {
+		std::cout << "Got callback void() again." << std::endl;
+	});
 	callbackList.append([](int a) {
-		std::cout << "Got callback void(" << a << ")." << std::endl;
+		std::cout << "Got callback void(int a)." << std::endl;
 	});
-	callbackList.append([](int a, int b) {
-		std::cout << "Got callback void(" << a << ", " << b << ")." << std::endl;
+	callbackList.append([](int a) {
+		std::cout << "Got callback void(int a) again." << std::endl;
 	});
 
 	// Now call forEach to remove the second callback
-	// The forEach callback prototype is void(const HeterCallbackList::Handle & handle, const HeterCallbackList::Callback & callback)
+	// forEach has one template parameter, here is void(). It's which prototype to iterate for.
+	// The forEach callback prototype is void(const HeterCallbackList::Handle & handle, const std::function<prototype> & callback)
 	int index = 0;
-	callbackList.forEach([&callbackList, &index](const CL::Handle & handle, const CL::Callback & /*callback*/) {
+	callbackList.forEach<void()>([&callbackList, &index](const CL::Handle & handle, const std::function<void()> & /*callback*/) {
 		std::cout << "forEach(Handle, Callback), invoked " << index << std::endl;
 		if(index == 1) {
 			callbackList.remove(handle);
@@ -75,18 +78,14 @@ TEST_CASE("HeterCallbackList tutorial 2, for each")
 		++index;
 	});
 
-	// The forEach callback prototype can also be void(const HeterCallbackList::Handle & handle)
-	callbackList.forEach([&callbackList, &index](const CL::Handle & /*handle*/) {
-		std::cout << "forEach(Handle), invoked" << std::endl;
-	});
-
-	// The forEach callback prototype can also be void(const HeterCallbackList::Callback & callback)
-	callbackList.forEach([&callbackList, &index](const CL::Callback & /*callback*/) {
+	// The forEach callback prototype can also be void(const std::function<prototype> & callback)
+	// Here uses C++14 generic lambda to simplify the callback.
+	callbackList.forEach<void (int)>([&callbackList, &index](const auto & callback) {
 		std::cout << "forEach(Callback), invoked" << std::endl;
+		callback(3);
 	});
 
 	// Invoke the callback list
-	// The "Got callback 2" callback should not be triggered.
 	callbackList();
 }
-#endif
+

From d4d298b1918b2ea19b0343e501bb2bb609c00ee4 Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Sun, 31 Mar 2019 21:58:02 +0800
Subject: [PATCH 32/38] Added unit tests

---
 tests/unittest/test_callbacklist_basic.cpp    | 27 ++++++++++++++++++
 .../unittest/test_hetercallbacklist_basic.cpp | 28 +++++++++++++++++++
 2 files changed, 55 insertions(+)

diff --git a/tests/unittest/test_callbacklist_basic.cpp b/tests/unittest/test_callbacklist_basic.cpp
index 1cf47b5..cdfe9db 100644
--- a/tests/unittest/test_callbacklist_basic.cpp
+++ b/tests/unittest/test_callbacklist_basic.cpp
@@ -447,4 +447,31 @@ TEST_CASE("CallbackList, remove")
 	}
 }
 
+TEST_CASE("CallbackList, prototype convert")
+{
+	struct MyClass
+	{
+		MyClass(int) {}
+	};
+
+	using CL = eventpp::CallbackList<void (int)>;
+	CL callbackList;
+
+	std::vector<int> dataList(2);
+
+	callbackList.append([&dataList](int) {
+		++dataList[0];
+	});
+	callbackList.append([&dataList](const MyClass &) {
+		++dataList[1];
+	});
+
+	REQUIRE(dataList == std::vector<int>{ 0, 0 });
+
+	callbackList((int)5);
+	REQUIRE(dataList == std::vector<int>{ 1, 1 });
+
+	callbackList((char)5);
+	REQUIRE(dataList == std::vector<int>{ 2, 2 });
+}
 
diff --git a/tests/unittest/test_hetercallbacklist_basic.cpp b/tests/unittest/test_hetercallbacklist_basic.cpp
index edaef12..9be02c9 100644
--- a/tests/unittest/test_hetercallbacklist_basic.cpp
+++ b/tests/unittest/test_hetercallbacklist_basic.cpp
@@ -340,3 +340,31 @@ TEST_CASE("HeterCallbackList, invoke")
 	REQUIRE(dataListNoArg == std::vector<int>{ 2, 4, 6 });
 	REQUIRE(dataListWithArg == std::vector<int>{ 3, 6, 9 });
 }
+
+TEST_CASE("HeterCallbackList, prototype convert")
+{
+	struct MyClass
+	{
+		MyClass(int) {}
+	};
+
+	using CL = eventpp::HeterCallbackList<eventpp::HeterTuple<void (int)> >;
+	CL callbackList;
+
+	std::vector<int> dataList(2);
+
+	callbackList.append([&dataList](int) {
+		++dataList[0];
+	});
+	callbackList.append([&dataList](const MyClass &) {
+		++dataList[1];
+	});
+
+	REQUIRE(dataList == std::vector<int>{ 0, 0 });
+
+	callbackList((int)5);
+	REQUIRE(dataList == std::vector<int>{ 1, 1 });
+
+	callbackList((char)5);
+	REQUIRE(dataList == std::vector<int>{ 2, 2 });
+}

From bf62d50a3442be883e7c8d26f971c610e1b581d7 Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Sun, 31 Mar 2019 22:32:04 +0800
Subject: [PATCH 33/38] Improved TOC generating.

---
 doc/callbacklist.md             | 22 +++++++++----------
 doc/conditionalremover.md       | 10 ++++-----
 doc/counterremover.md           | 10 ++++-----
 doc/eventdispatcher.md          | 22 +++++++++----------
 doc/eventqueue.md               | 15 +++++--------
 doc/faq.md                      | 39 +++++++++++++++------------------
 doc/hetercallbacklist.md        | 18 ++++++++++++---
 doc/hetereventdispatcher.md     | 17 ++++++++++++--
 doc/hetereventqueue.md          | 18 ++++++++++++---
 doc/heterogeneous.md            |  1 -
 doc/introduction.md             |  2 --
 doc/mixins.md                   | 22 +++++++++----------
 doc/policies.md                 | 18 +++++++--------
 doc/scopedremover.md            | 11 ++++------
 doc/tutorial_callbacklist.md    | 20 ++---------------
 doc/tutorial_eventdispatcher.md |  3 ---
 doc/tutorial_eventqueue.md      |  2 --
 17 files changed, 121 insertions(+), 129 deletions(-)

diff --git a/doc/callbacklist.md b/doc/callbacklist.md
index cd0010a..5f4858f 100644
--- a/doc/callbacklist.md
+++ b/doc/callbacklist.md
@@ -1,22 +1,20 @@
 # Class CallbackList reference
 
-<a id="a2_1"></a>
 ## Table Of Contents
 
 <!--begintoc-->
-* [Table Of Contents](#a2_1)
-* [Description](#a2_2)
-* [API reference](#a2_3)
+* [Description](#a2_1)
+* [API reference](#a2_2)
   * [Header](#a3_1)
   * [Template parameters](#a3_2)
   * [Public types](#a3_3)
   * [Member functions](#a3_4)
-* [Nested callback safety](#a2_4)
-* [Time complexities](#a2_5)
-* [Internal data structure](#a2_6)
+* [Nested callback safety](#a2_3)
+* [Time complexities](#a2_4)
+* [Internal data structure](#a2_5)
 <!--endtoc-->
 
-<a id="a2_2"></a>
+<a id="a2_1"></a>
 ## Description
 
 CallbackList is the fundamental class in eventpp. The other classes EventDispatcher and EventQueue are built on CallbackList.  
@@ -24,7 +22,7 @@ CallbackList is the fundamental class in eventpp. The other classes EventDispatc
 CallbackList holds a list of callbacks. At the time of the call, CallbackList simply invokes each callback one by one. Consider CallbackList as the signal/slot system in Qt, or the callback function pointer in some Windows APIs (such as lpCompletionRoutine in `ReadFileEx`).  
 The *callback* can be any callback target -- functions, pointers to functions, , pointers to member functions, lambda expressions, and function objects.  
 
-<a id="a2_3"></a>
+<a id="a2_2"></a>
 ## API reference
 
 <a id="a3_1"></a>
@@ -135,21 +133,21 @@ Invoke each callbacks in the callback list.
 The callbacks are called with arguments `args`.  
 The callbacks are called in the thread same as the callee of `operator()`.
 
-<a id="a2_4"></a>
+<a id="a2_3"></a>
 ## Nested callback safety
 1. If a callback adds another callback to the callback list during a invoking, the new callback is guaranteed not to be triggered within the same invoking. This is guaranteed by an unsigned 64 bits integer counter. This rule will be broken is the counter is overflowed to zero in a invoking, but this rule will continue working on the subsequence invoking.  
 2. Any callbacks that are removed during a invoking are guaranteed not triggered.  
 3. All above points are not true in multiple threading. That's to say, if one thread is invoking a callback list, the other thread add or remove a callback, the added or removed callback may be called during the invoking.
 
 
-<a id="a2_5"></a>
+<a id="a2_4"></a>
 ## Time complexities
 - `append`: O(1)
 - `prepend`: O(1)
 - `insert`: O(1)
 - `remove`: O(1)
 
-<a id="a2_6"></a>
+<a id="a2_5"></a>
 ## Internal data structure
 
 CallbackList uses doubly linked list to manage the callbacks.  
diff --git a/doc/conditionalremover.md b/doc/conditionalremover.md
index 4108263..e89890d 100644
--- a/doc/conditionalremover.md
+++ b/doc/conditionalremover.md
@@ -1,12 +1,10 @@
 # Class ConditionalRemover reference
 
-<a id="a2_1"></a>
 ## Table Of Contents
 
 <!--begintoc-->
-* [Table Of Contents](#a2_1)
-* [Description](#a2_2)
-* [API reference](#a2_3)
+* [Description](#a2_1)
+* [API reference](#a2_2)
   * [Header](#a3_1)
   * [Template parameters](#a3_2)
   * [Member functions](#a3_3)
@@ -14,13 +12,13 @@
   * [Sample code](#a3_5)
 <!--endtoc-->
 
-<a id="a2_2"></a>
+<a id="a2_1"></a>
 ## Description
 
 ConditionalRemover is a utility class that automatically removes listeners after the listeners are triggered and certain condition is satisfied.  
 ConditionalRemover is a pure functional class. After the member functions in ConditionalRemover are invoked, the ConditionalRemover object can be destroyed safely.  
 
-<a id="a2_3"></a>
+<a id="a2_2"></a>
 ## API reference
 
 <a id="a3_1"></a>
diff --git a/doc/counterremover.md b/doc/counterremover.md
index 00ec8bd..fe1f8e1 100644
--- a/doc/counterremover.md
+++ b/doc/counterremover.md
@@ -1,12 +1,10 @@
 # Class CounterRemover reference
 
-<a id="a2_1"></a>
 ## Table Of Contents
 
 <!--begintoc-->
-* [Table Of Contents](#a2_1)
-* [Description](#a2_2)
-* [API reference](#a2_3)
+* [Description](#a2_1)
+* [API reference](#a2_2)
   * [Header](#a3_1)
   * [Template parameters](#a3_2)
   * [Member functions](#a3_3)
@@ -14,13 +12,13 @@
   * [Sample code](#a3_5)
 <!--endtoc-->
 
-<a id="a2_2"></a>
+<a id="a2_1"></a>
 ## Description
 
 CounterRemover is a utility class that automatically removes listeners after the listeners are triggered for certain times.  
 CounterRemover is a pure functional class. After the member functions in CounterRemover are invoked, the CounterRemover object can be destroyed safely.  
 
-<a id="a2_3"></a>
+<a id="a2_2"></a>
 ## API reference
 
 <a id="a3_1"></a>
diff --git a/doc/eventdispatcher.md b/doc/eventdispatcher.md
index e24fa0c..0a72b96 100644
--- a/doc/eventdispatcher.md
+++ b/doc/eventdispatcher.md
@@ -1,29 +1,27 @@
 # Class EventDispatcher reference
 
-<a id="a2_1"></a>
 ## Table Of Contents
 
 <!--begintoc-->
-* [Table Of Contents](#a2_1)
-* [Description](#a2_2)
-* [API reference](#a2_3)
+* [Description](#a2_1)
+* [API reference](#a2_2)
   * [Header](#a3_1)
   * [Template parameters](#a3_2)
   * [Public types](#a3_3)
   * [Member functions](#a3_4)
-* [Nested listener safety](#a2_4)
-* [Time complexities](#a2_5)
-* [Internal data structure](#a2_6)
+* [Nested listener safety](#a2_3)
+* [Time complexities](#a2_4)
+* [Internal data structure](#a2_5)
 <!--endtoc-->
 
-<a id="a2_2"></a>
+<a id="a2_1"></a>
 ## Description
 
 EventDispatcher is something like std::map<EventType, CallbackList>.
 
 EventDispatcher holds a map of `<EventType, CallbackList>` pairs. On dispatching, EventDispatcher finds the CallbackList of the event type, then invoke the callback list. The invocation is always synchronous. The listeners are triggered when `EventDispatcher::dispatch` is called.  
 
-<a id="a2_3"></a>
+<a id="a2_2"></a>
 ## API reference
 
 <a id="a3_1"></a>
@@ -129,13 +127,13 @@ Dispatch an event. The event type is deducted from the arguments of `dispatch`.
 In both overloads, the listeners are called with arguments `args`.  
 The function is synchronous. The listeners are called in the thread same as the caller of `dispatch`.
 
-<a id="a2_4"></a>
+<a id="a2_3"></a>
 ## Nested listener safety
 1. If a listener adds another listener of the same event to the dispatcher during a dispatching, the new listener is guaranteed not to be triggered within the same dispatching. This is guaranteed by an unsigned 64 bits integer counter. This rule will be broken is the counter is overflowed to zero in a dispatching, but this rule will continue working on the subsequence dispatching.  
 2. Any listeners that are removed during a dispatching are guaranteed not triggered.  
 3. All above points are not true in multiple threading. That's to say, if one thread is invoking a callback list, the other thread add or remove a callback, the added or removed callback may be triggered during the invoking.
 
-<a id="a2_5"></a>
+<a id="a2_4"></a>
 ## Time complexities
 The time complexities being discussed here is about when operating on the listener in the underlying list, and `n` is the number of listeners. It doesn't include the event searching in the underlying `std::map` which is always O(log n).
 - `appendListener`: O(1)
@@ -144,7 +142,7 @@ The time complexities being discussed here is about when operating on the listen
 - `removeListener`: O(1)
 - `enqueue`: O(1)
 
-<a id="a2_6"></a>
+<a id="a2_5"></a>
 ## Internal data structure
 
 EventDispatcher uses [CallbackList](callbacklist.md) to manage the listener callbacks.  
diff --git a/doc/eventqueue.md b/doc/eventqueue.md
index b4c1756..d120b2b 100644
--- a/doc/eventqueue.md
+++ b/doc/eventqueue.md
@@ -1,27 +1,25 @@
 # Class EventQueue reference
 
-<a id="a2_1"></a>
 ## Table Of Contents
 
 <!--begintoc-->
-* [Table Of Contents](#a2_1)
-* [Description](#a2_2)
-* [API reference](#a2_3)
+* [Description](#a2_1)
+* [API reference](#a2_2)
   * [Header](#a3_1)
   * [Template parameters](#a3_2)
   * [Public types](#a3_3)
   * [Member functions](#a3_4)
-* [Internal data structure](#a2_4)
+* [Internal data structure](#a2_3)
 <!--endtoc-->
 
-<a id="a2_2"></a>
+<a id="a2_1"></a>
 ## Description
 
 EventQueue includes all features of EventDispatcher and adds event queue features. Note: EventQueue doesn't inherit from EventDispatcher, don't try to cast EventQueue to EventDispatcher.  
 EventQueue is asynchronous. Events are cached in the queue when `EventQueue::enqueue` is called, and dispatched later when `EventQueue::process` is called.  
 EventQueue is equivalent to the event system (QEvent) in Qt, or the message processing in Windows API.  
 
-<a id="a2_3"></a>
+<a id="a2_2"></a>
 ## API reference
 
 <a id="a3_1"></a>
@@ -214,11 +212,10 @@ EQ queue;
 queue.enqueue(3);
 ```
 
-<a id="a2_4"></a>
+<a id="a2_3"></a>
 ## Internal data structure
 
 EventQueue uses three `std::list` to manage the event queue.  
 The first busy list holds all nodes of queued events.  
 The second idle list holds all idle nodes. After an event is dispatched and removed from the queue, instead of freeing the memory, EventQueue moves the unused node to the idle list. This can improve performance and avoid memory fragment.  
 The third list is a local temporary list used in function `process()`. During processing, the busy list is swapped to the temporary list, all events are dispatched from the temporary list, then the temporary list is returned and appended to the idle list.
-
diff --git a/doc/faq.md b/doc/faq.md
index dcaf195..80842be 100644
--- a/doc/faq.md
+++ b/doc/faq.md
@@ -1,22 +1,20 @@
 # Frequently Asked Questions
 
-<a id="a2_1"></a>
 ## Table Of Contents
 
 <!--begintoc-->
-* [Table Of Contents](#a2_1)
-* [Why can't rvalue reference be used as callback prototype in EventDispatcher and CallbackList? Such as CallbackList<void (int &&)>](#a2_2)
-* [Can the callback prototype have return value? Such as CallbackList<std::string (const std::string &, int)>?](#a2_3)
-* [Why can't callback prototype be function pointer such as CallbackList<void (*)()>?](#a2_4)
-* [Why aren't there APIs to remove listeners directly from an EventDispatcher? Why do we have to remove by handle?](#a2_5)
-* [Isn't CallbackList equivalent to std::vector<Callback>? It's simple for me to use std::vector<Callback> directly.](#a2_6)
-* [I want to inherit my class from EventDispatcher, but EventDispatcher's destructor is not virtual?](#a2_7)
-* [How to automatically remove listeners when certain object is destroyed (aka auto disconnection)?](#a2_8)
-* [How to process all EventQueue instances in a single main loop?](#a2_9)
-* [How to integrate EventQueue with boost::asio::io_service?](#a2_10)
+* [Why can't rvalue reference be used as callback prototype in EventDispatcher and CallbackList? Such as CallbackList<void (int &&)>](#a2_1)
+* [Can the callback prototype have return value? Such as CallbackList<std::string (const std::string &, int)>?](#a2_2)
+* [Why can't callback prototype be function pointer such as CallbackList<void (*)()>?](#a2_3)
+* [Why aren't there APIs to remove listeners directly from an EventDispatcher? Why do we have to remove by handle?](#a2_4)
+* [Isn't CallbackList equivalent to std::vector<Callback>? It's simple for me to use std::vector<Callback> directly.](#a2_5)
+* [I want to inherit my class from EventDispatcher, but EventDispatcher's destructor is not virtual?](#a2_6)
+* [How to automatically remove listeners when certain object is destroyed (aka auto disconnection)?](#a2_7)
+* [How to process all EventQueue instances in a single main loop?](#a2_8)
+* [How to integrate EventQueue with boost::asio::io_service?](#a2_9)
 <!--endtoc-->
 
-<a id="a2_2"></a>
+<a id="a2_1"></a>
 ## Why can't rvalue reference be used as callback prototype in EventDispatcher and CallbackList? Such as CallbackList<void (int &&)>
 
 ```c++
@@ -28,29 +26,29 @@ The above code doesn't compile. This is intended design and not a bug.
 A rvalue reference `std::string &&` means the argument can be moved by the callback and become invalid (or empty). Keep in mind CallbackList invokes many callbacks one by one. So what happens if the first callback moves the argument and the other callbacks get empty value? In above code example, that means the first callback sees the value "Hello" and moves it, then the other callbacks will see empty string, not "Hello"!  
 To avoid such potential bugs, rvalue reference is forbidden deliberately.
 
-<a id="a2_3"></a>
+<a id="a2_2"></a>
 ## Can the callback prototype have return value? Such as CallbackList<std::string (const std::string &, int)>?
 
 Yes you can, but both EventDispatcher and CallbackList just discard the return value. It's not efficient nor useful to return value from EventDispatcher and CallbackList.
 
-<a id="a2_4"></a>
+<a id="a2_3"></a>
 ## Why can't callback prototype be function pointer such as CallbackList<void (*)()>?
 
 It's rather easy to support function pointer, but it's year 2018 at the time written, and there is proposal for C++20 standard already, so let's use modern C++ features. Stick with function type `void ()` instead of function pointer `void (*)()`.
 
-<a id="a2_5"></a>
+<a id="a2_4"></a>
 ## Why aren't there APIs to remove listeners directly from an EventDispatcher? Why do we have to remove by handle?
 
 Both `EventDispatcher::removeListener(const Event & event, const Handle handle)` and `CallbackList::remove(const Handle handle)` requires the handle of a listener is passed in. So why can't we pass the listener object directly? The reason is, it's not guaranteed that the underlying callback storage is comparable while removing a listener object requires the comparable ability. Indeed the default callback storage, `std::function` is not comparable.  
 If we use some customized callback storage and we are sure it's comparable, there is free functions 'removeListener' in [utility APIs](eventutil.md).
 
-<a id="a2_6"></a>
+<a id="a2_5"></a>
 ## Isn't CallbackList equivalent to std::vector<Callback>? It's simple for me to use std::vector<Callback> directly.
 
 `CallbackList` works like a `std::vector<Callback>`. But one common usage is to implement one-shot callback that a callback removes itself from the callback list when it's invoked. In such case a simple `std::vector<Callback>` will bang and crash.  
 With `CallbackList` a callback can be removed at any time, even when the callback list is under invoking.
 
-<a id="a2_7"></a>
+<a id="a2_6"></a>
 ## I want to inherit my class from EventDispatcher, but EventDispatcher's destructor is not virtual?
 
 It's intended not to use any virtual functions in eventpp to avoid bloating the code size. New class can still inherit from EventDispatcher, as long as the object is not deleted via a pointer to EventDispatcher, which will cause resource leak. If you need to delete object via pointer to base class, make your own base class that inherits from EventDispatcher, and make the base class destructor virtual.  
@@ -71,12 +69,12 @@ MyEventDispatcher * myObject = new MyClass();
 delete myObject;
 ```
 
-<a id="a2_8"></a>
+<a id="a2_7"></a>
 ## How to automatically remove listeners when certain object is destroyed (aka auto disconnection)?  
 
 [Use utility class ScopedRemover](scopedremover.md)
 
-<a id="a2_9"></a>
+<a id="a2_8"></a>
 ## How to process all EventQueue instances in a single main loop?  
 
 It's common to have a single main loop in a GUI or game application, and there are various EventQueue instances in the system. How to process all the EventQueue instances? Let's see some pseudo code first,  
@@ -109,7 +107,7 @@ public:
 
 The idea is, the main loop invoke a callback list in each loop, and each event queue registers its process to the callback list.
 
-<a id="a2_10"></a>
+<a id="a2_9"></a>
 ## How to integrate EventQueue with boost::asio::io_service?  
 
 A common use case is there are multiple threads that executing boost::asio::io_service::run(). To integrate EventQueue with boost asio, we need to replace `run()` with `poll()` to avoid blocking. So a typical thread will look like,  
@@ -143,4 +141,3 @@ public:
 ```
 
 Note that after the while loop is finished, the ioService is still run and mainLoopTasks is still invoked, that's to clean up any remaining tasks.
-
diff --git a/doc/hetercallbacklist.md b/doc/hetercallbacklist.md
index 256b0d0..5b52378 100644
--- a/doc/hetercallbacklist.md
+++ b/doc/hetercallbacklist.md
@@ -2,8 +2,16 @@
 
 ## Table Of Contents
 
-<!--toc-->
-
+<!--begintoc-->
+* [Description](#a2_1)
+* [API reference](#a2_2)
+  * [Header](#a3_1)
+  * [Template parameters](#a3_2)
+  * [Public types](#a3_3)
+  * [Member functions](#a3_4)
+<!--endtoc-->
+
+<a id="a2_1"></a>
 ## Description
 
 HeterCallbackList is the heterogeneous counterpart of CallbackList in eventpp. The other classes HeterEventDispatcher and HeterEventQueue are built on HeterCallbackList.  
@@ -11,12 +19,15 @@ HeterCallbackList is the heterogeneous counterpart of CallbackList in eventpp. T
 HeterCallbackList holds a list of callbacks. The callbacks can have different prototypes. At the time of the call, HeterCallbackList invokes each callback which matches the invoking parameters.  
 The *callback* can be any callback target -- functions, pointers to functions, , pointers to member functions, lambda expressions, and function objects.  
 
+<a id="a2_2"></a>
 ## API reference
 
+<a id="a3_1"></a>
 ### Header
 
 eventpp/hetercallbacklist.h
 
+<a id="a3_2"></a>
 ### Template parameters
 
 ```c++
@@ -29,11 +40,13 @@ class HeterCallbackList;
 `Prototype`:  a list of function types in `eventpp::HeterTuple`, such as `eventpp::HeterTuple<void (), void (std::string), void (int, int)>`.  
 `Policies`: the policies to configure and extend the callback list. The default value is `DefaultPolicies`. See [document of policies](policies.md) for details.  
 
+<a id="a3_3"></a>
 ### Public types
 
 `Handle`: the handle type returned by append, prepend and insert. A handle can be used to insert a callback or remove a callback. To check if a `Handle` is empty, convert it to boolean, *false* is empty. `Handle` is copyable.  
 `Callback`: the callback storage type.
 
+<a id="a3_4"></a>
 ### Member functions
 
 ```c++
@@ -123,4 +136,3 @@ void operator() (Args && ...args) const;
 Invoke each callbacks that can be called with `Args` in the callback list.  
 The callbacks are called with arguments `args`.  
 The callbacks are called in the thread same as the callee of `operator()`.
-
diff --git a/doc/hetereventdispatcher.md b/doc/hetereventdispatcher.md
index e724b20..962b18c 100644
--- a/doc/hetereventdispatcher.md
+++ b/doc/hetereventdispatcher.md
@@ -2,20 +2,31 @@
 
 ## Table Of Contents
 
-<!--toc-->
-
+<!--begintoc-->
+* [Description](#a2_1)
+* [API reference](#a2_2)
+  * [Header](#a3_1)
+  * [Template parameters](#a3_2)
+  * [Public types](#a3_3)
+  * [Member functions](#a3_4)
+<!--endtoc-->
+
+<a id="a2_1"></a>
 ## Description
 
 HeterEventDispatcher is something like std::map<EventType, HeterCallbackList>.
 
 HeterEventDispatcher holds a map of `<EventType, HeterCallbackList>` pairs. On dispatching, HeterEventDispatcher finds the HeterCallbackList of the event type, then invoke the callback list. The invocation is always synchronous. The listeners are triggered when `HeterEventDispatcher::dispatch` is called.  
 
+<a id="a2_2"></a>
 ## API reference
 
+<a id="a3_1"></a>
 ### Header
 
 eventpp/hetereventdispatcher.h
 
+<a id="a3_2"></a>
 ### Template parameters
 
 ```c++
@@ -30,11 +41,13 @@ class HeterEventDispatcher;
 `Prototype`:  a list of function types in `eventpp::HeterTuple`, such as `eventpp::HeterTuple<void (), void (std::string), void (int, int)>`.  
 `Policies`: the policies to configure and extend the dispatcher. The default value is `DefaultPolicies`. See [document of policies](policies.md) for details.  
 
+<a id="a3_3"></a>
 ### Public types
 
 `Handle`: the handle type returned by appendListener, prependListener and insertListener. A handle can be used to insert a listener or remove a listener. To check if a `Handle` is empty, convert it to boolean, *false* is empty. `Handle` is copyable.  
 `Event`: the event type.  
 
+<a id="a3_4"></a>
 ### Member functions
 
 ```c++
diff --git a/doc/hetereventqueue.md b/doc/hetereventqueue.md
index 0b5ceec..5d2ea43 100644
--- a/doc/hetereventqueue.md
+++ b/doc/hetereventqueue.md
@@ -2,20 +2,31 @@
 
 ## Table Of Contents
 
-<!--toc-->
-
+<!--begintoc-->
+* [Description](#a2_1)
+* [API reference](#a2_2)
+  * [Header](#a3_1)
+  * [Template parameters](#a3_2)
+  * [Public types](#a3_3)
+  * [Member functions](#a3_4)
+<!--endtoc-->
+
+<a id="a2_1"></a>
 ## Description
 
 HeterEventQueue includes all features of HeterEventDispatcher and adds event queue features. Note: HeterEventQueue doesn't inherit from HeterEventDispatcher, don't try to cast HeterEventQueue to HeterEventDispatcher.  
 HeterEventQueue is asynchronous. Events are cached in the queue when `HeterEventQueue::enqueue` is called, and dispatched later when `HeterEventQueue::process` is called.  
 HeterEventQueue is equivalent to the event system (QEvent) in Qt, or the message processing in Windows API.  
 
+<a id="a2_2"></a>
 ## API reference
 
+<a id="a3_1"></a>
 ### Header
 
 eventpp/eventqueue.h
 
+<a id="a3_2"></a>
 ### Template parameters
 
 ```c++
@@ -29,8 +40,10 @@ class HeterEventQueue;
 
 HeterEventQueue has the exactly same template parameters with EventDispatcher. Please reference [HeterEventDispatcher document](hetereventdispatcher.md) for details.
 
+<a id="a3_3"></a>
 ### Public types
 
+<a id="a3_4"></a>
 ### Member functions
 
 ```c++
@@ -155,4 +168,3 @@ EQ queue;
 // any blocking threads will be waken up by below line since there is no DisableQueueNotify.
 queue.enqueue(3);
 ```
-
diff --git a/doc/heterogeneous.md b/doc/heterogeneous.md
index 6c068b8..d8127a2 100644
--- a/doc/heterogeneous.md
+++ b/doc/heterogeneous.md
@@ -82,4 +82,3 @@ Note: Ideally it would be better to use `std::tuple` instead of `eventpp::HeterT
 ### Member functions and types
 
 The heter-classes have similar functions and types as the homo-classes. The major difference is, in the homo-classes, listeners can have only one prototype, while in the heter-classes, listeners can have any prototypes which are in the `PrototypeList` specified in the class template parameters.
-
diff --git a/doc/introduction.md b/doc/introduction.md
index 1410d97..0267ad7 100644
--- a/doc/introduction.md
+++ b/doc/introduction.md
@@ -81,5 +81,3 @@ Exceptions may be thrown by underlying code when,
 
 Almost all operations guarantee strong exception safety, which means the underlying data remains original value on exception is thrown.  
 An except is `EventQueue::process`, on exception, the remaining events will not be dispatched, and the queue becomes empty.
-
-
diff --git a/doc/mixins.md b/doc/mixins.md
index f0bb748..da3b5e2 100644
--- a/doc/mixins.md
+++ b/doc/mixins.md
@@ -1,21 +1,19 @@
 # Mixins
 
-<a id="a2_1"></a>
 ## Table Of Contents
 
 <!--begintoc-->
-* [Table Of Contents](#a2_1)
-* [Introduction](#a2_2)
-* [Define a mixin](#a2_3)
-* [Inject(enable) mixins to EventDispatcher](#a2_4)
-* [Optional interceptor points](#a2_5)
-* [MixinFilter](#a2_6)
+* [Introduction](#a2_1)
+* [Define a mixin](#a2_2)
+* [Inject(enable) mixins to EventDispatcher](#a2_3)
+* [Optional interceptor points](#a2_4)
+* [MixinFilter](#a2_5)
   * [Public type](#a3_1)
   * [Functions](#a3_2)
   * [Sample code for MixinFilter](#a3_3)
 <!--endtoc-->
 
-<a id="a2_2"></a>
+<a id="a2_1"></a>
 ## Introduction
 
 A mixin is used to inject code in the EventDispatcher/EventQueue inheritance hierarchy to extend the functionalities. In this document we will use EventDispatcher as the example, the usage for EventQueue is exactly the same.  
@@ -31,7 +29,7 @@ EventDispatcher <- MixinA <- MixinB <- EventDispatcherBase
 ```
 The mixins can use all public and protected members (types, functions and data) in EventDispatcherBase. All public members in the mixins are visible and usable by the user.
 
-<a id="a2_3"></a>
+<a id="a2_2"></a>
 ## Define a mixin
 
 A mixin is a template class with one template argument. The mixin must inherit from it's template argument.  
@@ -43,7 +41,7 @@ class MyMixin : public Base
 };
 ```
 
-<a id="a2_4"></a>
+<a id="a2_3"></a>
 ## Inject(enable) mixins to EventDispatcher
 
 To enable mixins, add them to the `Mixins` type in the policies class. For example, to enable `MixinFilter`, define the dispatcher as,   
@@ -60,7 +58,7 @@ EventDispatcher <- MixinA <- MixinB <- MixinC <- EventDispatcherBase
 ```
 The front mixin is the lowest in the hierarchy.
 
-<a id="a2_5"></a>
+<a id="a2_4"></a>
 ## Optional interceptor points
 
 A mixin can have special named functions that are called at certain point. The special functions must be public.  
@@ -73,7 +71,7 @@ bool mixinBeforeDispatch(Args && ...args) const;
 The function returns `true` to continue the dispatch, `false` will stop any further dispatching.  
 For multiple mixins, this function is called in the order of they appearing in MixinList in the policies class.
 
-<a id="a2_6"></a>
+<a id="a2_5"></a>
 ## MixinFilter
 
 MixinFilter allows all events are filtered or modified before dispatching.
diff --git a/doc/policies.md b/doc/policies.md
index 27a440f..2733c11 100644
--- a/doc/policies.md
+++ b/doc/policies.md
@@ -1,23 +1,21 @@
 # Policies
 
-<a id="a2_1"></a>
 ## Table Of Contents
 
 <!--begintoc-->
-* [Table Of Contents](#a2_1)
-* [Introduction](#a2_2)
-* [Policies](#a2_3)
+* [Introduction](#a2_1)
+* [Policies](#a2_2)
   * [Function getEvent](#a3_1)
   * [Function canContinueInvoking](#a3_2)
   * [Type Mixins](#a3_3)
   * [Type Callback](#a3_4)
   * [Type Threading](#a3_5)
-* [Type ArgumentPassingMode](#a2_4)
+* [Type ArgumentPassingMode](#a2_3)
   * [Template Map](#a3_6)
-* [How to use policies](#a2_5)
+* [How to use policies](#a2_4)
 <!--endtoc-->
 
-<a id="a2_2"></a>
+<a id="a2_1"></a>
 ## Introduction
 
 eventpp uses policy based design to configure and extend each components' behavior. The last template parameter in EventDispatcher, EventQueue, and CallbackList is the policies class. All those three classes have default policies class named `DefaultPolicies`.  
@@ -25,7 +23,7 @@ A policy is either a type or a static function member in the policies class. All
 All policies are optional. If any policy is omitted, the default value is used.  In fact `DefaultPolicies` is just an empty struct.  
 The same policy mechanism applies to all three classes, EventDispatcher, EventQueue, and CallbackList, though not all classes requires the same policy.
 
-<a id="a2_3"></a>
+<a id="a2_2"></a>
 ## Policies
 
 <a id="a3_1"></a>
@@ -220,7 +218,7 @@ eventpp::EventDispatcher<int, void (), MyEventPolicies> dispatcher;
 eventpp::CallbackList<void (), MyEventPolicies> callbackList;
 ```
 
-<a id="a2_4"></a>
+<a id="a2_3"></a>
 ## Type ArgumentPassingMode
 
 **Default value**: `using ArgumentPassingMode = ArgumentPassingAutoDetect`.  
@@ -328,7 +326,7 @@ using Map = // std::map <Key, T> or other map type
 `Map` must support operations `[]`, `find()`, and `end()`.  
 If `Map` is not specified, eventpp will auto determine the type. If the event type supports `std::hash`, `std::unordered_map` is used, otherwise, `std::map` is used.
 
-<a id="a2_5"></a>
+<a id="a2_4"></a>
 ## How to use policies
 
 To use policies, declare a struct, define the policies in it, and pass the struct to CallbackList, EventDispatcher, or EventQueue.  
diff --git a/doc/scopedremover.md b/doc/scopedremover.md
index a18f6f6..ae0e8fc 100644
--- a/doc/scopedremover.md
+++ b/doc/scopedremover.md
@@ -1,12 +1,10 @@
 # Class ScopedRemover reference
 
-<a id="a2_1"></a>
 ## Table Of Contents
 
 <!--begintoc-->
-* [Table Of Contents](#a2_1)
-* [Description](#a2_2)
-* [API reference](#a2_3)
+* [Description](#a2_1)
+* [API reference](#a2_2)
   * [Header](#a3_1)
   * [Template parameters](#a3_2)
   * [Member functions](#a3_3)
@@ -14,12 +12,12 @@
   * [Automatic disconnection](#a3_5)
 <!--endtoc-->
 
-<a id="a2_2"></a>
+<a id="a2_1"></a>
 ## Description
 
 ScopedRemover is a utility class that automatically removes listeners when ScopedRemover object goes out of scope.  
 
-<a id="a2_3"></a>
+<a id="a2_2"></a>
 ## API reference
 
 <a id="a3_1"></a>
@@ -190,4 +188,3 @@ class MyClass
 ```
 
 In above code, when the object of MyClass is destroyed, `myListener` is automatically removed from `someDispatcher`, `someDispatcher` will not invoke on any dangling pointer.
-
diff --git a/doc/tutorial_callbacklist.md b/doc/tutorial_callbacklist.md
index 51ed448..685c8d1 100644
--- a/doc/tutorial_callbacklist.md
+++ b/doc/tutorial_callbacklist.md
@@ -1,21 +1,9 @@
 # Tutorials of CallbackList
 
-<a id="a2_1"></a>
-## Table Of Contents
-
-<!--begintoc-->
-* [Table Of Contents](#a2_1)
-* [Tutorials](#a2_2)
-  * [CallbackList tutorial 1, basic](#a3_1)
-  * [CallbackList tutorial 2, callback with parameters](#a3_2)
-  * [CallbackList tutorial 3, remove](#a3_3)
-  * [CallbackList tutorial 4, for each](#a3_4)
-<!--endtoc-->
-
-<a id="a2_2"></a>
+<!--toc-->
+
 ## Tutorials
 
-<a id="a3_1"></a>
 ### CallbackList tutorial 1, basic
 
 **Code**  
@@ -67,7 +55,6 @@ callbackList();
 ```
 During the invoking, all callbacks will be invoked one by one in the order of they were added.
 
-<a id="a3_2"></a>
 ### CallbackList tutorial 2, callback with parameters
 
 **Code**  
@@ -96,7 +83,6 @@ callbackList("Hello world", true);
 Now the callback list prototype takes two parameters, `const std::string &` and `const bool`.  
 The callback's prototype is not required to be same as the callback list, it's fine as long as the prototype is compatible with the callback list. See the second callback, `[](std::string s, int b)`, its prototype is not same as the callback list.
 
-<a id="a3_3"></a>
 ### CallbackList tutorial 3, remove
 
 **Code**  
@@ -130,7 +116,6 @@ callbackList();
 
 **Remarks**  
 
-<a id="a3_4"></a>
 ### CallbackList tutorial 4, for each
 
 **Code**  
@@ -181,4 +166,3 @@ callbackList();
 > Got callback 3.  
 
 **Remarks**  
-
diff --git a/doc/tutorial_eventdispatcher.md b/doc/tutorial_eventdispatcher.md
index 70d90ab..abccdbe 100644
--- a/doc/tutorial_eventdispatcher.md
+++ b/doc/tutorial_eventdispatcher.md
@@ -1,7 +1,5 @@
 # Tutorials of EventDispatcher
 
-## Table Of Contents
-
 <!--toc-->
 
 ## Tutorials
@@ -157,4 +155,3 @@ dispatcher.dispatch(MyEvent { 3, "Hello world", 38 }, true);
 
 **Remarks**
 A common situation is an Event class is defined as the base class, all other events derive from Event, and the actual event type is a data member of Event (think QEvent in Qt). To let EventDispatcher knows how to get the event type from class Event, policies (the third template parameter) is used.  
-
diff --git a/doc/tutorial_eventqueue.md b/doc/tutorial_eventqueue.md
index ef75a37..aca6f73 100644
--- a/doc/tutorial_eventqueue.md
+++ b/doc/tutorial_eventqueue.md
@@ -1,7 +1,5 @@
 # Tutorials of EventQueue
 
-## Table Of Contents
-
 <!--toc-->
 
 ### Tutorial 1 -- Basic usage

From da7dacce1ea510504c988694577250913703541b Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Tue, 2 Apr 2019 19:33:01 +0800
Subject: [PATCH 34/38] Improved TOC generating.

---
 doc/callbacklist.md         | 21 ++++++++++++++++++++-
 doc/conditionalremover.md   |  2 +-
 doc/counterremover.md       |  2 +-
 doc/eventdispatcher.md      | 18 +++++++++++++++++-
 doc/eventqueue.md           | 30 ++++++++++++++++++++++++++++--
 doc/faq.md                  |  2 +-
 doc/hetercallbacklist.md    | 25 ++++++++++++++++++++++---
 doc/hetereventdispatcher.md | 22 +++++++++++++++++++---
 doc/hetereventqueue.md      | 25 ++++++++++++++++++++++---
 doc/heterogeneous.md        |  6 +-----
 doc/mixins.md               |  2 +-
 doc/policies.md             |  2 +-
 doc/scopedremover.md        |  2 +-
 readme.md                   |  4 ++++
 14 files changed, 139 insertions(+), 24 deletions(-)

diff --git a/doc/callbacklist.md b/doc/callbacklist.md
index 5f4858f..f0ae7b9 100644
--- a/doc/callbacklist.md
+++ b/doc/callbacklist.md
@@ -1,8 +1,8 @@
 # Class CallbackList reference
 
+<!--begintoc-->
 ## Table Of Contents
 
-<!--begintoc-->
 * [Description](#a2_1)
 * [API reference](#a2_2)
   * [Header](#a3_1)
@@ -52,6 +52,8 @@ class CallbackList;
 <a id="a3_4"></a>
 ### Member functions
 
+#### constructors
+
 ```c++
 CallbackList() noexcept;
 CallbackList(const CallbackList & other);
@@ -62,18 +64,24 @@ CallbackList & operator = (CallbackList && other) noexcept;
 
 CallbackList can be copied, moved,  assigned, and move assigned.
 
+#### empty
+
 ```c++
 bool empty() const;
 ```
 Return true if the callback list is empty.  
 Note: in multi threading, this function returning true doesn't guarantee that the list is empty. The list may immediately become non-empty after the function returns true.
 
+#### bool casting operator
+
 ```c++
 operator bool() const;
 ```
 Return true if the callback list is not empty.  
 This operator allows a CallbackList instance be used in condition statement.
 
+#### append
+
 ```c++
 Handle append(const Callback & callback);
 ```  
@@ -83,6 +91,8 @@ Return a handle that represents the callback. The handle can be used to remove t
 If `append` is called in another callback during the invoking of the callback list, the new callback is guaranteed not to be triggered during the same callback list invoking.  
 The time complexity is O(1).
 
+#### prepend
+
 ```c++
 Handle prepend(const Callback & callback);
 ```  
@@ -92,6 +102,8 @@ Return a handle that represents the callback. The handle can be used to remove t
 If `prepend` is called in another callback during the invoking of the callback list, the new callback is guaranteed not to be triggered during the same callback list invoking.  
 The time complexity is O(1).
 
+#### insert
+
 ```c++
 Handle insert(const Callback & callback, const Handle before);
 ```  
@@ -100,6 +112,7 @@ Return a handle that represents the callback. The handle can be used to remove t
 If `insert` is called in another callback during the invoking of the callback list, the new callback is guaranteed not to be triggered during the same callback list invoking.  
 The time complexity is O(1).  
 
+#### remove
 ```c++
 bool remove(const Handle handle);
 ```  
@@ -107,6 +120,8 @@ Remove the callback *handle* from the callback list.
 Return true if the callback is removed successfully, false if the callback is not found.  
 The time complexity is O(1).  
 
+#### forEach
+
 ```c++
 template <typename Func>  
 void forEach(Func && func) const;
@@ -119,6 +134,8 @@ AnyReturnType func(const CallbackList::Callback &);
 ```
 **Note**: the `func` can remove any callbacks, or add other callbacks, safely.
 
+#### forEachIf
+
 ```c++
 template <typename Func>  
 bool forEachIf(Func && func) const;
@@ -126,6 +143,8 @@ bool forEachIf(Func && func) const;
 Apply `func` to all callbacks. `func` must return a boolean value, and if the return value is false, forEachIf stops the looping immediately.  
 Return `true` if all callbacks are invoked, or `event` is not found, `false` if `func` returns `false`.
 
+#### invoking operator
+
 ```c++
 void operator() (Args ...args) const;
 ```  
diff --git a/doc/conditionalremover.md b/doc/conditionalremover.md
index e89890d..7d315da 100644
--- a/doc/conditionalremover.md
+++ b/doc/conditionalremover.md
@@ -1,8 +1,8 @@
 # Class ConditionalRemover reference
 
+<!--begintoc-->
 ## Table Of Contents
 
-<!--begintoc-->
 * [Description](#a2_1)
 * [API reference](#a2_2)
   * [Header](#a3_1)
diff --git a/doc/counterremover.md b/doc/counterremover.md
index fe1f8e1..cf81139 100644
--- a/doc/counterremover.md
+++ b/doc/counterremover.md
@@ -1,8 +1,8 @@
 # Class CounterRemover reference
 
+<!--begintoc-->
 ## Table Of Contents
 
-<!--begintoc-->
 * [Description](#a2_1)
 * [API reference](#a2_2)
   * [Header](#a3_1)
diff --git a/doc/eventdispatcher.md b/doc/eventdispatcher.md
index 0a72b96..c90e418 100644
--- a/doc/eventdispatcher.md
+++ b/doc/eventdispatcher.md
@@ -1,8 +1,8 @@
 # Class EventDispatcher reference
 
+<!--begintoc-->
 ## Table Of Contents
 
-<!--begintoc-->
 * [Description](#a2_1)
 * [API reference](#a2_2)
   * [Header](#a3_1)
@@ -54,6 +54,8 @@ class EventDispatcher;
 <a id="a3_4"></a>
 ### Member functions
 
+#### constructors
+
 ```c++
 EventDispatcher();
 EventDispatcher(const EventDispatcher & other);
@@ -64,6 +66,8 @@ EventDispatcher & operator = (EventDispatcher && other) noexcept;
 
 EventDispatcher can be copied, moved,  assigned, and move assigned.
 
+#### appendListener
+
 ```c++
 Handle appendListener(const Event & event, const Callback & callback);
 ```  
@@ -74,6 +78,8 @@ If `appendListener` is called in another listener during a dispatching, the new
 If the same callback is added twice, it results duplicated listeners.  
 The time complexity is O(1).
 
+#### prependListener
+
 ```c++
 Handle prependListener(const Event & event, const Callback & callback);
 ```  
@@ -83,6 +89,8 @@ Return a handle which represents the listener. The handle can be used to remove
 If `prependListener` is called in another listener during a dispatching, the new listener is guaranteed not triggered during the same dispatching.  
 The time complexity is O(1).
 
+#### insertListener
+
 ```c++
 Handle insertListener(const Event & event, const Callback & callback, const Handle before);
 ```  
@@ -91,6 +99,8 @@ Return a handle which represents the listener. The handle can be used to remove
 If `insertListener` is called in another listener during a dispatching, the new listener is guaranteed not triggered during the same dispatching.  
 The time complexity is O(1).  
 
+#### removeListener
+
 ```c++
 bool removeListener(const Event & event, const Handle handle);
 ```  
@@ -98,6 +108,8 @@ Remove the listener *handle* which listens to *event* from the dispatcher.
 Return true if the listener is removed successfully, false if the listener is not found.  
 The time complexity is O(1).  
 
+#### forEach
+
 ```c++
 template <typename Func>  
 void forEach(const Event & event, Func && func);
@@ -110,6 +122,8 @@ AnyReturnType func(const EventDispatcher::Callback &);
 ```
 **Note**: the `func` can remove any listeners, or add other listeners, safely.
 
+#### forEachIf
+
 ```c++
 template <typename Func>  
 bool forEachIf(const Event & event, Func && func);
@@ -117,6 +131,8 @@ bool forEachIf(const Event & event, Func && func);
 Apply `func` to all listeners of `event`. `func` must return a boolean value, and if the return value is false, forEachIf stops the looping immediately.  
 Return `true` if all listeners are invoked, or `event` is not found, `false` if `func` returns `false`.
 
+#### dispatch
+
 ```c++
 void dispatch(Args ...args);  
 
diff --git a/doc/eventqueue.md b/doc/eventqueue.md
index d120b2b..ddae8d0 100644
--- a/doc/eventqueue.md
+++ b/doc/eventqueue.md
@@ -1,14 +1,15 @@
 # Class EventQueue reference
 
+<!--begintoc-->
 ## Table Of Contents
 
-<!--begintoc-->
 * [Description](#a2_1)
 * [API reference](#a2_2)
   * [Header](#a3_1)
   * [Template parameters](#a3_2)
   * [Public types](#a3_3)
   * [Member functions](#a3_4)
+  * [Inner class EventQueue::DisableQueueNotify](#a3_5)
 * [Internal data structure](#a2_3)
 <!--endtoc-->
 
@@ -57,6 +58,8 @@ struct EventQueue::QueuedEvent
 <a id="a3_4"></a>
 ### Member functions
 
+#### constructors
+
 ```c++
 EventQueue();
 EventQueue(const EventQueue & other);
@@ -68,6 +71,8 @@ EventQueue & operator = (EventQueue && other) noexcept;
 EventDispatcher can be copied, moved,  assigned, and move assigned.  
 Note: the queued events are not copied, moved, assigned, or move assigned, only the listeners are performed these operations.
 
+#### enqueue
+
 ```c++
 template <typename ...A>
 void enqueue(A ...args);
@@ -83,6 +88,8 @@ If an argument is a pointer, only the pointer will be stored. The object it poin
 `enqueue` wakes up any threads that are blocked by `wait` or `waitFor`.  
 The time complexity is O(1).  
 
+#### process
+
 ```c++
 bool process();
 ```  
@@ -93,6 +100,8 @@ Any new events added to the queue during `process()` are not dispatched during c
 `process()` is efficient in single thread event processing, it processes all events in the queue in current thread. To process events from multiple threads efficiently, use `processOne()`.  
 Note: if `process()` is called from multiple threads simultaneously, the events in the event queue are guaranteed dispatched only once.  
 
+#### processOne
+
 ```c++
 bool processOne();
 ```  
@@ -103,6 +112,8 @@ Any new events added to the queue during `processOne()` are not dispatched durin
 If there are multiple threads processing events, `processOne()` is more efficient than `process()` because it can split the events processing to different threads. However, if there is only one thread processing events, 'process()' is more efficient.  
 Note: if `processOne()` is called from multiple threads simultaneously, the events in the event queue are guaranteed dispatched only once.  
 
+#### processIf
+
 ```c++
 template <typename F>
 bool processIf(F && func);
@@ -114,6 +125,8 @@ Process the event queue. Before processing an event, the event is passed to `fun
 1. Process certain events in certain thread. For example, in a GUI application, the UI related events may be only desired to processed in the main thread.  
 2. Process the events until certain time. For example, in a game engine, the event process may be limited to only several milliseconds, the remaining events will be process in next game loop.  
 
+#### emptyQueue
+
 ```c++
 bool emptyQueue() const;
 ```
@@ -121,12 +134,16 @@ Return true if there is no any event in the event queue, false if there are any
 Note: in multiple threading environment, the empty state may change immediately after the function returns.  
 Note: don't write loop as `while(! eventQueue.emptyQueue()) {}`. It's dead loop since the compiler will inline the code and the change of empty state is never seen by the loop. The safe approach is `while(eventQueue.waitFor(std::chrono::nanoseconds(0))) ;`.  
 
+#### clearEvents
+
 ```c++
 void clearEvents();
 ```
 Clear all queued events without dispatching them.  
 This is useful to clear any references such as shared pointer in the queued events to avoid cyclic reference.
 
+#### wait
+
 ```c++
 void wait() const;
 ```
@@ -141,6 +158,8 @@ for(;;) {
 ```
 The code works event if it doesn't `wait`, but doing that will waste CPU power resource.
 
+#### waitFor
+
 ```c++
 template <class Rep, class Period>
 bool waitFor(const std::chrono::duration<Rep, Period> & duration) const;
@@ -160,6 +179,8 @@ for(;;) {
 }
 ```
 
+#### peekEvent
+
 ```c++
 bool peekEvent(EventQueue::QueuedEvent * queuedEvent);
 ```
@@ -176,6 +197,8 @@ If the queue is empty, the function returns false, otherwise true if an event is
 After the function returns, the original even is still in the queue.  
 Note: `peekEvent` doesn't work with any non-copyable event arguments. If `peekEvent` is called when any arguments are non-copyable, compile fails.
 
+#### takeEvent
+
 ```c++
 bool takeEvent(EventQueue::QueuedEvent * queuedEvent);
 ```
@@ -184,12 +207,15 @@ If the queue is empty, the function returns false, otherwise true if an event is
 After the function returns, the original even is removed from the queue.  
 Note: `takeEvent` works with non-copyable event arguments.
 
+#### dispatch
+
 ```c++
 void dispatch(const QueuedEvent & queuedEvent);
 ```
 Dispatch an event which was returned by `peekEvent` or `takeEvent`.  
 
-**Inner class EventQueue::DisableQueueNotify**  
+<a id="a3_5"></a>
+### Inner class EventQueue::DisableQueueNotify  
 
 `EventQueue::DisableQueueNotify` is a RAII class that temporarily prevents the event queue from waking up any waiting threads. When any `DisableQueueNotify` object exist, calling `enqueue` doesn't wake up any threads that are blocked by `wait`. When the `DisableQueueNotify` object is out of scope, the waking up is resumed. If there are more than one `DisableQueueNotify` objects, the waking up is only resumed after all `DisableQueueNotify` objects are destroyed.  
 `DisableQueueNotify` is useful to improve performance when batching adding events to the queue. For example, in a main loop of a game engine, `DisableQueueNotify` can be created on the start in a frame, then the game adding events to the queue, and the `DisableQueueNotify` is destroyed at the end of a frame and the events are processed.
diff --git a/doc/faq.md b/doc/faq.md
index 80842be..7d0afa2 100644
--- a/doc/faq.md
+++ b/doc/faq.md
@@ -1,8 +1,8 @@
 # Frequently Asked Questions
 
+<!--begintoc-->
 ## Table Of Contents
 
-<!--begintoc-->
 * [Why can't rvalue reference be used as callback prototype in EventDispatcher and CallbackList? Such as CallbackList<void (int &&)>](#a2_1)
 * [Can the callback prototype have return value? Such as CallbackList<std::string (const std::string &, int)>?](#a2_2)
 * [Why can't callback prototype be function pointer such as CallbackList<void (*)()>?](#a2_3)
diff --git a/doc/hetercallbacklist.md b/doc/hetercallbacklist.md
index 5b52378..d50ddae 100644
--- a/doc/hetercallbacklist.md
+++ b/doc/hetercallbacklist.md
@@ -1,8 +1,8 @@
 # Class HeterCallbackList reference
 
+<!--begintoc-->
 ## Table Of Contents
 
-<!--begintoc-->
 * [Description](#a2_1)
 * [API reference](#a2_2)
   * [Header](#a3_1)
@@ -49,6 +49,8 @@ class HeterCallbackList;
 <a id="a3_4"></a>
 ### Member functions
 
+#### constructors
+
 ```c++
 HeterCallbackList() noexcept;
 HeterCallbackList(const HeterCallbackList & other);
@@ -59,18 +61,24 @@ HeterCallbackList & operator = (HeterCallbackList && other) noexcept;
 
 HeterCallbackList can be copied, moved,  assigned, and move assigned.
 
+#### empty
+
 ```c++
 bool empty() const;
 ```
 Return true if the callback list is empty.  
 Note: in multi threading, this function returning true doesn't guarantee that the list is empty. The list may immediately become non-empty after the function returns true.
 
+#### bool casting operator
+
 ```c++
 operator bool() const;
 ```
 Return true if the callback list is not empty.  
 This operator allows a HeterCallbackList instance be used in condition statement.
 
+#### append
+
 ```c++
 template <typename C>
 Handle append(const C & callback);
@@ -82,6 +90,8 @@ Return a handle that represents the callback. The handle can be used to remove t
 If `append` is called in another callback during the invoking of the callback list, the new callback is guaranteed not to be triggered during the same callback list invoking.  
 The time complexity is O(1).
 
+#### prepend
+
 ```c++
 template <typename C>
 Handle prepend(const C & callback);
@@ -93,6 +103,8 @@ Return a handle that represents the callback. The handle can be used to remove t
 If `prepend` is called in another callback during the invoking of the callback list, the new callback is guaranteed not to be triggered during the same callback list invoking.  
 The time complexity is O(1).
 
+#### insert
+
 ```c++
 template <typename C>
 Handle insert(const C & callback, const Handle & before);
@@ -103,6 +115,8 @@ Return a handle that represents the callback. The handle can be used to remove t
 If `insert` is called in another callback during the invoking of the callback list, the new callback is guaranteed not to be triggered during the same callback list invoking.  
 The time complexity is O(1).  
 
+#### remove
+
 ```c++
 bool remove(const Handle & handle);
 ```  
@@ -110,6 +124,8 @@ Remove the callback *handle* from the callback list.
 Return true if the callback is removed successfully, false if the callback is not found.  
 The time complexity is O(1).  
 
+#### forEach
+
 ```c++
 template <typename Prototype, typename Func>
 void forEach(Func && func) const;
@@ -117,11 +133,12 @@ void forEach(Func && func) const;
 Apply `func` to all callbacks which has the `Prototype`.  
 The `func` can be one of the two prototypes:  
 ```c++
-AnyReturnType func(const HeterCallbackList::Handle &, const std::function<Prototype> &);
-AnyReturnType func(const std::function<Prototype> &);
+AnyReturnType func(const HeterCallbackList::Handle & handle, const std::function<Prototype> & callback);
+AnyReturnType func(const std::function<Prototype> & callback);
 ```
 **Note**: the `func` can remove any callbacks, or add other callbacks, safely.
 
+#### forEachIf
 ```c++
 template <typename Prototype, typename Func>
 bool forEachIf(Func && func) const;
@@ -129,6 +146,8 @@ bool forEachIf(Func && func) const;
 Apply `func` to all callbacks. `func` must return a boolean value, and if the return value is false, forEachIf stops the looping immediately.  
 Return `true` if all callbacks are invoked, or `event` is not found, `false` if `func` returns `false`.
 
+#### invoking operator
+
 ```c++
 template <typename ...Args>
 void operator() (Args && ...args) const;
diff --git a/doc/hetereventdispatcher.md b/doc/hetereventdispatcher.md
index 962b18c..7e042db 100644
--- a/doc/hetereventdispatcher.md
+++ b/doc/hetereventdispatcher.md
@@ -1,8 +1,8 @@
 # Class HeterEventDispatcher reference
 
+<!--begintoc-->
 ## Table Of Contents
 
-<!--begintoc-->
 * [Description](#a2_1)
 * [API reference](#a2_2)
   * [Header](#a3_1)
@@ -50,6 +50,8 @@ class HeterEventDispatcher;
 <a id="a3_4"></a>
 ### Member functions
 
+#### constructors
+
 ```c++
 HeterEventDispatcher();
 HeterEventDispatcher(const HeterEventDispatcher & other);
@@ -60,6 +62,8 @@ HeterEventDispatcher & operator = (HeterEventDispatcher && other) noexcept;
 
 HeterEventDispatcher can be copied, moved,  assigned, and move assigned.
 
+#### appendListener
+
 ```c++
 template <typename C>
 Handle appendListener(const Event & event, const C & callback);
@@ -72,6 +76,8 @@ If `appendListener` is called in another listener during a dispatching, the new
 If the same callback is added twice, it results duplicated listeners.  
 The time complexity is O(1).
 
+#### prependListener
+
 ```c++
 template <typename C>
 Handle prependListener(const Event & event, const C & callback);
@@ -83,6 +89,8 @@ Return a handle which represents the listener. The handle can be used to remove
 If `prependListener` is called in another listener during a dispatching, the new listener is guaranteed not triggered during the same dispatching.  
 The time complexity is O(1).
 
+#### insertListener
+
 ```c++
 template <typename C>
 Handle insertListener(const Event & event, const C & callback, const Handle & before);
@@ -93,6 +101,8 @@ Return a handle which represents the listener. The handle can be used to remove
 If `insertListener` is called in another listener during a dispatching, the new listener is guaranteed not triggered during the same dispatching.  
 The time complexity is O(1).  
 
+#### removeListener
+
 ```c++
 bool removeListener(const Event & event, const Handle handle);
 ```  
@@ -100,6 +110,8 @@ Remove the listener *handle* which listens to *event* from the dispatcher.
 Return true if the listener is removed successfully, false if the listener is not found.  
 The time complexity is O(1).  
 
+#### forEach
+
 ```c++
 template <typename Prototype, typename Func>
 void forEach(const Event & event, Func && func) const;
@@ -107,11 +119,13 @@ void forEach(const Event & event, Func && func) const;
 Apply `func` to all callbacks which has the `Prototype`.  
 The `func` can be one of the two prototypes:  
 ```c++
-AnyReturnType func(const HeterEventDispatcher::Handle &, const HeterEventDispatcher::Callback &);
-AnyReturnType func(const HeterEventDispatcher::Callback &);
+AnyReturnType func(const HeterEventDispatcher::Handle & handle, const std::function<Prototype> & callback);
+AnyReturnType func(const std::function<Prototype> & callback);
 ```
 **Note**: the `func` can remove any listeners, or add other listeners, safely.
 
+#### forEachIf
+
 ```c++
 template <typename Prototype, typename Func>
 bool forEachIf(const Event & event, Func && func) const;
@@ -119,6 +133,8 @@ bool forEachIf(const Event & event, Func && func) const;
 Apply `func` to all listeners of `event`. `func` must return a boolean value, and if the return value is false, forEachIf stops the looping immediately.  
 Return `true` if all listeners are invoked, or `event` is not found, `false` if `func` returns `false`.
 
+#### dispatch
+
 ```c++
 template <typename T, typename ...Args>
 void dispatch(T && first, Args && ...args) const
diff --git a/doc/hetereventqueue.md b/doc/hetereventqueue.md
index 5d2ea43..8d9c538 100644
--- a/doc/hetereventqueue.md
+++ b/doc/hetereventqueue.md
@@ -1,14 +1,15 @@
 # Class HeterEventQueue reference
 
+<!--begintoc-->
 ## Table Of Contents
 
-<!--begintoc-->
 * [Description](#a2_1)
 * [API reference](#a2_2)
   * [Header](#a3_1)
   * [Template parameters](#a3_2)
   * [Public types](#a3_3)
   * [Member functions](#a3_4)
+  * [Inner class HeterEventQueue::DisableQueueNotify](#a3_5)
 <!--endtoc-->
 
 <a id="a2_1"></a>
@@ -16,7 +17,6 @@
 
 HeterEventQueue includes all features of HeterEventDispatcher and adds event queue features. Note: HeterEventQueue doesn't inherit from HeterEventDispatcher, don't try to cast HeterEventQueue to HeterEventDispatcher.  
 HeterEventQueue is asynchronous. Events are cached in the queue when `HeterEventQueue::enqueue` is called, and dispatched later when `HeterEventQueue::process` is called.  
-HeterEventQueue is equivalent to the event system (QEvent) in Qt, or the message processing in Windows API.  
 
 <a id="a2_2"></a>
 ## API reference
@@ -46,6 +46,8 @@ HeterEventQueue has the exactly same template parameters with EventDispatcher. P
 <a id="a3_4"></a>
 ### Member functions
 
+#### constructors
+
 ```c++
 HeterEventQueue();
 HeterEventQueue(const HeterEventQueue & other);
@@ -57,6 +59,8 @@ HeterEventQueue & operator = (HeterEventQueue && other) noexcept;
 EventDispatcher can be copied, moved,  assigned, and move assigned.  
 Note: the queued events are not copied, moved, assigned, or move assigned, only the listeners are performed these operations.
 
+#### enqueue
+
 ```c++
 template <typename T, typename ...Args>
 void enqueue(T && first, Args && ...args);
@@ -69,6 +73,8 @@ If an argument is a pointer, only the pointer will be stored. The object it poin
 `enqueue` wakes up any threads that are blocked by `wait` or `waitFor`.  
 The time complexity is O(1).  
 
+#### process
+
 ```c++
 bool process();
 ```  
@@ -79,6 +85,8 @@ Any new events added to the queue during `process()` are not dispatched during c
 `process()` is efficient in single thread event processing, it processes all events in the queue in current thread. To process events from multiple threads efficiently, use `processOne()`.  
 Note: if `process()` is called from multiple threads simultaneously, the events in the event queue are guaranteed dispatched only once.  
 
+#### processOne
+
 ```c++
 bool processOne();
 ```  
@@ -89,6 +97,8 @@ Any new events added to the queue during `processOne()` are not dispatched durin
 If there are multiple threads processing events, `processOne()` is more efficient than `process()` because it can split the events processing to different threads. However, if there is only one thread processing events, 'process()' is more efficient.  
 Note: if `processOne()` is called from multiple threads simultaneously, the events in the event queue are guaranteed dispatched only once.  
 
+#### processIf
+
 ```c++
 template <typename F>
 bool processIf(F && func);
@@ -100,6 +110,8 @@ Process the event queue. Before processing an event, the event is passed to `fun
 1. Process certain events in certain thread. For example, in a GUI application, the UI related events may be only desired to processed in the main thread.  
 2. Process the events until certain time. For example, in a game engine, the event process may be limited to only several milliseconds, the remaining events will be process in next game loop.  
 
+#### emptyQueue
+
 ```c++
 bool emptyQueue() const;
 ```
@@ -107,12 +119,16 @@ Return true if there is no any event in the event queue, false if there are any
 Note: in multiple threading environment, the empty state may change immediately after the function returns.  
 Note: don't write loop as `while(! eventQueue.emptyQueue()) {}`. It's dead loop since the compiler will inline the code and the change of empty state is never seen by the loop. The safe approach is `while(eventQueue.waitFor(std::chrono::nanoseconds(0))) ;`.  
 
+#### clearEvents
+
 ```c++
 void clearEvents();
 ```
 Clear all queued events without dispatching them.  
 This is useful to clear any references such as shared pointer in the queued events to avoid cyclic reference.
 
+#### wait
+
 ```c++
 void wait() const;
 ```
@@ -127,6 +143,8 @@ for(;;) {
 ```
 The code works event if it doesn't `wait`, but doing that will waste CPU power resource.
 
+#### waitFor
+
 ```c++
 template <class Rep, class Period>
 bool waitFor(const std::chrono::duration<Rep, Period> & duration) const;
@@ -146,7 +164,8 @@ for(;;) {
 }
 ```
 
-**Inner class HeterEventQueue::DisableQueueNotify**  
+<a id="a3_5"></a>
+### Inner class HeterEventQueue::DisableQueueNotify  
 
 `HeterEventQueue::DisableQueueNotify` is a RAII class that temporarily prevents the event queue from waking up any waiting threads. When any `DisableQueueNotify` object exist, calling `enqueue` doesn't wake up any threads that are blocked by `wait`. When the `DisableQueueNotify` object is out of scope, the waking up is resumed. If there are more than one `DisableQueueNotify` objects, the waking up is only resumed after all `DisableQueueNotify` objects are destroyed.  
 `DisableQueueNotify` is useful to improve performance when batching adding events to the queue. For example, in a main loop of a game engine, `DisableQueueNotify` can be created on the start in a frame, then the game adding events to the queue, and the `DisableQueueNotify` is destroyed at the end of a frame and the events are processed.
diff --git a/doc/heterogeneous.md b/doc/heterogeneous.md
index d8127a2..41f05ff 100644
--- a/doc/heterogeneous.md
+++ b/doc/heterogeneous.md
@@ -1,4 +1,4 @@
-# Heterogeneous classes
+# Overview of heterogeneous classes
 
 ## Description
 
@@ -78,7 +78,3 @@ The only difference is the `Prototype` in homo-classes becomes `PrototypeList` i
 In the homo-classes, `Prototype` is a single function type such as `void ()`.  
 In the heter-classes, `PrototypeList` is a list of function types in `eventpp::HeterTuple`, such as `eventpp::HeterTuple<void (), void (std::string), void (int, int)>`.  
 Note: Ideally it would be better to use `std::tuple` instead of `eventpp::HeterTuple`, but the problem is that the tuple is instantiated in HeterEventDispatcher which cause compile error that function type can't be instantiated.
-
-### Member functions and types
-
-The heter-classes have similar functions and types as the homo-classes. The major difference is, in the homo-classes, listeners can have only one prototype, while in the heter-classes, listeners can have any prototypes which are in the `PrototypeList` specified in the class template parameters.
diff --git a/doc/mixins.md b/doc/mixins.md
index da3b5e2..84d7ccb 100644
--- a/doc/mixins.md
+++ b/doc/mixins.md
@@ -1,8 +1,8 @@
 # Mixins
 
+<!--begintoc-->
 ## Table Of Contents
 
-<!--begintoc-->
 * [Introduction](#a2_1)
 * [Define a mixin](#a2_2)
 * [Inject(enable) mixins to EventDispatcher](#a2_3)
diff --git a/doc/policies.md b/doc/policies.md
index 2733c11..4deadf9 100644
--- a/doc/policies.md
+++ b/doc/policies.md
@@ -1,8 +1,8 @@
 # Policies
 
+<!--begintoc-->
 ## Table Of Contents
 
-<!--begintoc-->
 * [Introduction](#a2_1)
 * [Policies](#a2_2)
   * [Function getEvent](#a3_1)
diff --git a/doc/scopedremover.md b/doc/scopedremover.md
index ae0e8fc..105670f 100644
--- a/doc/scopedremover.md
+++ b/doc/scopedremover.md
@@ -1,8 +1,8 @@
 # Class ScopedRemover reference
 
+<!--begintoc-->
 ## Table Of Contents
 
-<!--begintoc-->
 * [Description](#a2_1)
 * [API reference](#a2_2)
   * [Header](#a3_1)
diff --git a/readme.md b/readme.md
index 174a39f..926d226 100644
--- a/readme.md
+++ b/readme.md
@@ -106,6 +106,10 @@ queue.process();
 * [Class CallbackList](doc/callbacklist.md)
 * [Class EventDispatcher](doc/eventdispatcher.md)
 * [Class EventQueue](doc/eventqueue.md)
+* [Overview of heterogeneous classes](doc/heterogeneous.md)
+* [Class HeterCallbackList](doc/hetercallbacklist.md)
+* [Class HeterEventDispatcher](doc/hetereventdispatcher.md)
+* [Class HeterEventQueue](doc/hetereventqueue.md)
 * [Utility class CounterRemover -- auto remove listeners after triggered certain times](doc/counterremover.md)
 * [Utility class ConditionalRemover -- auto remove listeners when certain condition is satisfied](doc/conditionalremover.md)
 * [Utility class ScopedRemover -- auto remove listeners when out of scope](doc/scopedremover.md)

From 48b77254122b00dd0fb48091f1bf1b7c66399d00 Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Thu, 30 May 2019 22:11:20 +0800
Subject: [PATCH 35/38] Fixed warnings

---
 include/eventpp/hetercallbacklist.h           | 2 +-
 include/eventpp/hetereventqueue.h             | 2 +-
 tests/unittest/test_callbacklist_basic.cpp    | 2 +-
 tests/unittest/tutorial_hetercallbacklist.cpp | 4 ++--
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/include/eventpp/hetercallbacklist.h b/include/eventpp/hetercallbacklist.h
index 6e3bec5..13d8c3d 100644
--- a/include/eventpp/hetercallbacklist.h
+++ b/include/eventpp/hetercallbacklist.h
@@ -257,7 +257,7 @@ class HeterCallbackListBase
 	}
 
 	template <typename RT, int PrototypeIndex, typename Func, typename H, typename CL>
-	auto doForEachInvoke(Func && func, const H & handle, CL && callback) const
+	auto doForEachInvoke(Func && func, const H & /*handle*/, CL && callback) const
 		-> typename std::enable_if<CanInvoke<Func, CL>::value, RT>::type
 	{
 		return func(callback);
diff --git a/include/eventpp/hetereventqueue.h b/include/eventpp/hetereventqueue.h
index 5ab26c6..6315461 100644
--- a/include/eventpp/hetereventqueue.h
+++ b/include/eventpp/hetereventqueue.h
@@ -352,7 +352,7 @@ class HeterEventQueueBase : public HeterEventDispatcherBase<
 	}
 
 	template <typename PrototypeInfo, typename F>
-	auto doProcessIf(F && func)
+	auto doProcessIf(F && /*func*/)
 		-> typename std::enable_if<(PrototypeInfo::index < 0), bool>::type
 	{
 		return false;
diff --git a/tests/unittest/test_callbacklist_basic.cpp b/tests/unittest/test_callbacklist_basic.cpp
index cdfe9db..7011d35 100644
--- a/tests/unittest/test_callbacklist_basic.cpp
+++ b/tests/unittest/test_callbacklist_basic.cpp
@@ -166,7 +166,7 @@ TEST_CASE("CallbackList, forEach")
 	});
 
 	i = 1;
-	callbackList.forEach([&i, &callbackList](const CL::Handle & handle, auto callback) {
+	callbackList.forEach([&i, &callbackList](const CL::Handle & /*handle*/, auto callback) {
 		REQUIRE(callback() == i);
 		++i;
 	});
diff --git a/tests/unittest/tutorial_hetercallbacklist.cpp b/tests/unittest/tutorial_hetercallbacklist.cpp
index 0d7864a..56557f4 100644
--- a/tests/unittest/tutorial_hetercallbacklist.cpp
+++ b/tests/unittest/tutorial_hetercallbacklist.cpp
@@ -58,10 +58,10 @@ TEST_CASE("HeterCallbackList tutorial 2, for each")
 	callbackList.append([]() {
 		std::cout << "Got callback void() again." << std::endl;
 	});
-	callbackList.append([](int a) {
+	callbackList.append([](int /*a*/) {
 		std::cout << "Got callback void(int a)." << std::endl;
 	});
-	callbackList.append([](int a) {
+	callbackList.append([](int /*a*/) {
 		std::cout << "Got callback void(int a) again." << std::endl;
 	});
 

From 79d89ad06e2497a073e54e77f6757c1551aecf47 Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Thu, 30 May 2019 23:01:51 +0800
Subject: [PATCH 36/38] Utilities support heter-classes

---
 .../eventpp/utilities/conditionalremover.h    |  44 ++++----
 include/eventpp/utilities/counterremover.h    |  48 ++++----
 include/eventpp/utilities/scopedremover.h     |  18 ++-
 tests/unittest/test_conditionalremover.cpp    |  54 ++++++++-
 tests/unittest/test_counterremover.cpp        |  72 ++++++++++++
 tests/unittest/test_scopedremover.cpp         | 104 +++++++++++++++++-
 6 files changed, 286 insertions(+), 54 deletions(-)

diff --git a/include/eventpp/utilities/conditionalremover.h b/include/eventpp/utilities/conditionalremover.h
index 4139de6..a7e5059 100644
--- a/include/eventpp/utilities/conditionalremover.h
+++ b/include/eventpp/utilities/conditionalremover.h
@@ -30,7 +30,7 @@ class ConditionalRemover <
 	>
 {
 private:
-	template <typename Condition>
+	template <typename Callback, typename Condition>
 	struct ItemByCondition
 	{
 		struct Data
@@ -38,7 +38,7 @@ class ConditionalRemover <
 			Condition shouldRemove;
 			DispatcherType & dispatcher;
 			typename DispatcherType::Event event;
-			typename DispatcherType::Callback listener;
+			Callback listener;
 			typename DispatcherType::Handle handle;
 		};
 
@@ -59,14 +59,14 @@ class ConditionalRemover <
 	{
 	}
 	
-	template <typename Condition>
+	template <typename Callback, typename Condition>
 	typename DispatcherType::Handle appendListener(
 			const typename DispatcherType::Event & event,
-			const typename DispatcherType::Callback & listener,
+			const Callback & listener,
 			const Condition & condition
 		)
 	{
-		using Wrapper = ItemByCondition<Condition>;
+		using Wrapper = ItemByCondition<Callback, Condition>;
 		auto data = std::make_shared<typename Wrapper::Data>(typename Wrapper::Data {
 			condition, dispatcher, event, listener, typename DispatcherType::Handle()
 		});
@@ -74,14 +74,14 @@ class ConditionalRemover <
 		return data->handle;
 	}
 
-	template <typename Condition>
+	template <typename Callback, typename Condition>
 	typename DispatcherType::Handle prependListener(
 			const typename DispatcherType::Event & event,
-			const typename DispatcherType::Callback & listener,
+			const Callback & listener,
 			const Condition & condition
 		)
 	{
-		using Wrapper = ItemByCondition<Condition>;
+		using Wrapper = ItemByCondition<Callback, Condition>;
 		auto data = std::make_shared<typename Wrapper::Data>(typename Wrapper::Data {
 			condition, dispatcher, event, listener, typename DispatcherType::Handle()
 		});
@@ -89,15 +89,15 @@ class ConditionalRemover <
 		return data->handle;
 	}
 
-	template <typename Condition>
+	template <typename Callback, typename Condition>
 	typename DispatcherType::Handle insertListener(
 			const typename DispatcherType::Event & event,
-			const typename DispatcherType::Callback & listener,
+			const Callback & listener,
 			const typename DispatcherType::Handle & before,
 			const Condition & condition
 		)
 	{
-		using Wrapper = ItemByCondition<Condition>;
+		using Wrapper = ItemByCondition<Callback, Condition>;
 		auto data = std::make_shared<typename Wrapper::Data>(typename Wrapper::Data {
 			condition, dispatcher, event, listener, typename DispatcherType::Handle()
 		});
@@ -116,14 +116,14 @@ class ConditionalRemover <
 	>
 {
 private:
-	template <typename Condition>
+	template <typename Callback, typename Condition>
 	struct ItemByCondition
 	{
 		struct Data
 		{
 			Condition shouldRemove;
 			CallbackListType & callbackList;
-			typename CallbackListType::Callback listener;
+			Callback listener;
 			typename CallbackListType::Handle handle;
 		};
 
@@ -144,13 +144,13 @@ class ConditionalRemover <
 	{
 	}
 	
-	template <typename Condition>
+	template <typename Callback, typename Condition>
 	typename CallbackListType::Handle append(
-			const typename CallbackListType::Callback & listener,
+			const Callback & listener,
 			const Condition & condition
 		)
 	{
-		using Wrapper = ItemByCondition<Condition>;
+		using Wrapper = ItemByCondition<Callback, Condition>;
 		auto data = std::make_shared<typename Wrapper::Data>(typename Wrapper::Data {
 			condition, callbackList, listener, typename CallbackListType::Handle()
 		});
@@ -158,13 +158,13 @@ class ConditionalRemover <
 		return data->handle;
 	}
 
-	template <typename Condition>
+	template <typename Callback, typename Condition>
 	typename CallbackListType::Handle prepend(
-			const typename CallbackListType::Callback & listener,
+			const Callback & listener,
 			const Condition & condition
 		)
 	{
-		using Wrapper = ItemByCondition<Condition>;
+		using Wrapper = ItemByCondition<Callback, Condition>;
 		auto data = std::make_shared<typename Wrapper::Data>(typename Wrapper::Data {
 			condition, callbackList, listener, typename CallbackListType::Handle()
 		});
@@ -172,14 +172,14 @@ class ConditionalRemover <
 		return data->handle;
 	}
 
-	template <typename Condition>
+	template <typename Callback, typename Condition>
 	typename CallbackListType::Handle insert(
-			const typename CallbackListType::Callback & listener,
+			const Callback & listener,
 			const typename CallbackListType::Handle & before,
 			const Condition & condition
 		)
 	{
-		using Wrapper = ItemByCondition<Condition>;
+		using Wrapper = ItemByCondition<Callback, Condition>;
 		auto data = std::make_shared<typename Wrapper::Data>(typename Wrapper::Data {
 			condition, callbackList, listener, typename CallbackListType::Handle()
 		});
diff --git a/include/eventpp/utilities/counterremover.h b/include/eventpp/utilities/counterremover.h
index aab5d05..dc2100f 100644
--- a/include/eventpp/utilities/counterremover.h
+++ b/include/eventpp/utilities/counterremover.h
@@ -30,6 +30,7 @@ class CounterRemover <
 	>
 {
 private:
+	template <typename Callback>
 	struct Wrapper
 	{
 		struct Data
@@ -37,7 +38,7 @@ class CounterRemover <
 			int triggerCount;
 			DispatcherType & dispatcher;
 			typename DispatcherType::Event event;
-			typename DispatcherType::Callback listener;
+			typename Callback listener;
 			typename DispatcherType::Handle handle;
 		};
 
@@ -58,43 +59,46 @@ class CounterRemover <
 	{
 	}
 	
+	template <typename Callback>
 	typename DispatcherType::Handle appendListener(
 			const typename DispatcherType::Event & event,
-			const typename DispatcherType::Callback & listener,
+			const Callback & listener,
 			const int triggerCount = 1
 		)
 	{
-		auto data = std::make_shared<typename Wrapper::Data>(typename Wrapper::Data {
+		auto data = std::make_shared<typename Wrapper<Callback>::Data>(typename Wrapper<Callback>::Data {
 			triggerCount, dispatcher, event, listener, typename DispatcherType::Handle()
 		});
-		data->handle = dispatcher.appendListener(event, Wrapper{data});
+		data->handle = dispatcher.appendListener(event, Wrapper<Callback>{data});
 		return data->handle;
 	}
 
+	template <typename Callback>
 	typename DispatcherType::Handle prependListener(
 			const typename DispatcherType::Event & event,
-			const typename DispatcherType::Callback & listener,
+			const Callback & listener,
 			const int triggerCount = 1
 		)
 	{
-		auto data = std::make_shared<typename Wrapper::Data>(typename Wrapper::Data {
+		auto data = std::make_shared<typename Wrapper<Callback>::Data>(typename Wrapper<Callback>::Data {
 			triggerCount, dispatcher, event, listener, typename DispatcherType::Handle()
 		});
-		data->handle = dispatcher.prependListener(event, Wrapper{data});
+		data->handle = dispatcher.prependListener(event, Wrapper<Callback>{data});
 		return data->handle;
 	}
 
+	template <typename Callback>
 	typename DispatcherType::Handle insertListener(
 			const typename DispatcherType::Event & event,
-			const typename DispatcherType::Callback & listener,
+			const Callback & listener,
 			const typename DispatcherType::Handle & before,
 			const int triggerCount = 1
 		)
 	{
-		auto data = std::make_shared<typename Wrapper::Data>(typename Wrapper::Data {
+		auto data = std::make_shared<typename Wrapper<Callback>::Data>(typename Wrapper<Callback>::Data {
 			triggerCount, dispatcher, event, listener, typename DispatcherType::Handle()
 		});
-		data->handle = dispatcher.insertListener(event, Wrapper{data}, before);
+		data->handle = dispatcher.insertListener(event, Wrapper<Callback>{data}, before);
 		return data->handle;
 	}
 
@@ -109,13 +113,14 @@ class CounterRemover <
 	>
 {
 private:
+	template <typename Callback>
 	struct Wrapper
 	{
 		struct Data
 		{
 			int triggerCount;
 			CallbackListType & callbackList;
-			typename CallbackListType::Callback listener;
+			typename Callback listener;
 			typename CallbackListType::Handle handle;
 		};
 
@@ -136,40 +141,43 @@ class CounterRemover <
 	{
 	}
 	
+	template <typename Callback>
 	typename CallbackListType::Handle append(
-			const typename CallbackListType::Callback & listener,
+			const Callback & listener,
 			const int triggerCount = 1
 		)
 	{
-		auto data = std::make_shared<typename Wrapper::Data>(typename Wrapper::Data {
+		auto data = std::make_shared<typename Wrapper<Callback>::Data>(typename Wrapper<Callback>::Data {
 			triggerCount, callbackList, listener, typename CallbackListType::Handle()
 		});
-		data->handle = callbackList.append(Wrapper{data});
+		data->handle = callbackList.append(Wrapper<Callback>{data});
 		return data->handle;
 	}
 
+	template <typename Callback>
 	typename CallbackListType::Handle prepend(
-			const typename CallbackListType::Callback & listener,
+			const Callback & listener,
 			const int triggerCount = 1
 		)
 	{
-		auto data = std::make_shared<typename Wrapper::Data>(typename Wrapper::Data {
+		auto data = std::make_shared<typename Wrapper<Callback>::Data>(typename Wrapper<Callback>::Data {
 			triggerCount, callbackList, listener, typename CallbackListType::Handle()
 		});
-		data->handle = callbackList.prepend(Wrapper{data});
+		data->handle = callbackList.prepend(Wrapper<Callback>{data});
 		return data->handle;
 	}
 
+	template <typename Callback>
 	typename CallbackListType::Handle insert(
-			const typename CallbackListType::Callback & listener,
+			const Callback & listener,
 			const typename CallbackListType::Handle & before,
 			const int triggerCount = 1
 		)
 	{
-		auto data = std::make_shared<typename Wrapper::Data>(typename Wrapper::Data {
+		auto data = std::make_shared<typename Wrapper<Callback>::Data>(typename Wrapper<Callback>::Data {
 			triggerCount, callbackList, listener, typename CallbackListType::Handle()
 		});
-		data->handle = callbackList.insert(Wrapper{data}, before);
+		data->handle = callbackList.insert(Wrapper<Callback>{data}, before);
 		return data->handle;
 	}
 
diff --git a/include/eventpp/utilities/scopedremover.h b/include/eventpp/utilities/scopedremover.h
index f85a6fa..300ec0e 100644
--- a/include/eventpp/utilities/scopedremover.h
+++ b/include/eventpp/utilities/scopedremover.h
@@ -76,9 +76,10 @@ class ScopedRemover <
 		}
 	}
 	
+	template <typename Callback>
 	typename DispatcherType::Handle appendListener(
 			const typename DispatcherType::Event & event,
-			const typename DispatcherType::Callback & listener
+			const Callback & listener
 		)
 	{
 		Item item {
@@ -94,9 +95,10 @@ class ScopedRemover <
 		return item.handle;
 	}
 
+	template <typename Callback>
 	typename DispatcherType::Handle prependListener(
 			const typename DispatcherType::Event & event,
-			const typename DispatcherType::Callback & listener
+			const Callback & listener
 		)
 	{
 		Item item {
@@ -112,9 +114,10 @@ class ScopedRemover <
 		return item.handle;
 	}
 
+	template <typename Callback>
 	typename DispatcherType::Handle insertListener(
 			const typename DispatcherType::Event & event,
-			const typename DispatcherType::Callback & listener,
+			const Callback & listener,
 			const typename DispatcherType::Handle & before
 		)
 	{
@@ -183,8 +186,9 @@ class ScopedRemover <
 		}
 	}
 	
+	template <typename Callback>
 	typename CallbackListType::Handle append(
-			const typename CallbackListType::Callback & callback
+			const Callback & callback
 		)
 	{
 		Item item {
@@ -194,8 +198,9 @@ class ScopedRemover <
 		return item.handle;
 	}
 
+	template <typename Callback>
 	typename CallbackListType::Handle prepend(
-			const typename CallbackListType::Callback & callback
+			const Callback & callback
 		)
 	{
 		Item item {
@@ -205,8 +210,9 @@ class ScopedRemover <
 		return item.handle;
 	}
 
+	template <typename Callback>
 	typename CallbackListType::Handle insert(
-			const typename CallbackListType::Callback & callback,
+			const Callback & callback,
 			const typename CallbackListType::Handle & before
 		)
 	{
diff --git a/tests/unittest/test_conditionalremover.cpp b/tests/unittest/test_conditionalremover.cpp
index f9edf50..2034314 100644
--- a/tests/unittest/test_conditionalremover.cpp
+++ b/tests/unittest/test_conditionalremover.cpp
@@ -13,10 +13,10 @@
 
 #include "test.h"
 #include "eventpp/utilities/conditionalremover.h"
-#include "eventpp/eventdispatcher.h"
 #include "eventpp/eventqueue.h"
+#include "eventpp/hetereventqueue.h"
 
-TEST_CASE("ConditionalRemover, EventDispatcher")
+TEST_CASE("ConditionalRemover, EventQueue")
 {
 	eventpp::EventQueue<int, void ()> dispatcher;
 	constexpr int event = 3;
@@ -115,3 +115,53 @@ TEST_CASE("ConditionalRemover, CallbackList")
 	REQUIRE(dataList == std::vector<int> { 5, 2, 3, 4 });
 }
 
+TEST_CASE("ConditionalRemover, HeterEventQueue")
+{
+	eventpp::HeterEventQueue<int, eventpp::HeterTuple<void ()> > dispatcher;
+	constexpr int event = 3;
+
+	std::vector<int> dataList(4);
+
+	dispatcher.appendListener(event, [&dataList]() {
+		++dataList[0];
+	});
+
+	int removeCounter = 0;
+	eventpp::conditionalRemover(dispatcher).prependListener(event, [&dataList]() {
+		++dataList[1];
+	}, [&removeCounter]() -> bool {
+		return removeCounter == 1;
+	});
+	auto handle = eventpp::conditionalRemover(dispatcher).appendListener(event, [&dataList]() {
+		++dataList[2];
+	}, [&removeCounter]() -> bool {
+		return removeCounter == 2;
+	});
+	eventpp::conditionalRemover(dispatcher).insertListener(event, [&dataList]() {
+		++dataList[3];
+	}, handle, [&removeCounter]() -> bool {
+		return removeCounter == 3;
+	});
+
+	REQUIRE(dataList == std::vector<int> { 0, 0, 0, 0 });
+
+	dispatcher.dispatch(event);
+	REQUIRE(dataList == std::vector<int> { 1, 1, 1, 1 });
+
+	++removeCounter;
+	dispatcher.dispatch(event);
+	REQUIRE(dataList == std::vector<int> { 2, 2, 2, 2 });
+
+	++removeCounter;
+	dispatcher.dispatch(event);
+	REQUIRE(dataList == std::vector<int> { 3, 2, 3, 3 });
+
+	++removeCounter;
+	dispatcher.dispatch(event);
+	REQUIRE(dataList == std::vector<int> { 4, 2, 3, 4 });
+
+	++removeCounter;
+	dispatcher.dispatch(event);
+	REQUIRE(dataList == std::vector<int> { 5, 2, 3, 4 });
+}
+
diff --git a/tests/unittest/test_counterremover.cpp b/tests/unittest/test_counterremover.cpp
index 932ceda..d4b8956 100644
--- a/tests/unittest/test_counterremover.cpp
+++ b/tests/unittest/test_counterremover.cpp
@@ -14,6 +14,7 @@
 #include "test.h"
 #include "eventpp/utilities/counterremover.h"
 #include "eventpp/eventdispatcher.h"
+#include "eventpp/hetereventdispatcher.h"
 
 TEST_CASE("CounterRemover, EventDispatcher")
 {
@@ -86,3 +87,74 @@ TEST_CASE("CounterRemover, CallbackList")
 	REQUIRE(dataList == std::vector<int> { 4, 1, 2, 3 });
 }
 
+TEST_CASE("CounterRemover, HeterEventDispatcher")
+{
+	eventpp::HeterEventDispatcher<int, eventpp::HeterTuple<void ()> > dispatcher;
+	constexpr int event = 3;
+
+	std::vector<int> dataList(4);
+
+	dispatcher.appendListener(event, [&dataList]() {
+		++dataList[0];
+	});
+
+	eventpp::counterRemover(dispatcher).prependListener(event, [&dataList]() {
+		++dataList[1];
+	});
+	auto handle = eventpp::counterRemover(dispatcher).appendListener(event, [&dataList]() {
+		++dataList[2];
+	}, 2);
+	eventpp::counterRemover(dispatcher).insertListener(event, [&dataList]() {
+		++dataList[3];
+	}, handle, 3);
+
+	REQUIRE(dataList == std::vector<int> { 0, 0, 0, 0 });
+
+	dispatcher.dispatch(event);
+	REQUIRE(dataList == std::vector<int> { 1, 1, 1, 1 });
+
+	dispatcher.dispatch(event);
+	REQUIRE(dataList == std::vector<int> { 2, 1, 2, 2 });
+
+	dispatcher.dispatch(event);
+	REQUIRE(dataList == std::vector<int> { 3, 1, 2, 3 });
+
+	dispatcher.dispatch(event);
+	REQUIRE(dataList == std::vector<int> { 4, 1, 2, 3 });
+}
+
+TEST_CASE("CounterRemover, HeterCallbackList")
+{
+	eventpp::HeterCallbackList<eventpp::HeterTuple<void ()> > callbackList;
+
+	std::vector<int> dataList(4);
+
+	callbackList.append([&dataList]() {
+		++dataList[0];
+	});
+
+	eventpp::counterRemover(callbackList).prepend([&dataList]() {
+		++dataList[1];
+	});
+	auto handle = eventpp::counterRemover(callbackList).append([&dataList]() {
+		++dataList[2];
+	}, 2);
+	eventpp::counterRemover(callbackList).insert([&dataList]() {
+		++dataList[3];
+	}, handle, 3);
+
+	REQUIRE(dataList == std::vector<int> { 0, 0, 0, 0 });
+
+	callbackList();
+	REQUIRE(dataList == std::vector<int> { 1, 1, 1, 1 });
+
+	callbackList();
+	REQUIRE(dataList == std::vector<int> { 2, 1, 2, 2 });
+
+	callbackList();
+	REQUIRE(dataList == std::vector<int> { 3, 1, 2, 3 });
+
+	callbackList();
+	REQUIRE(dataList == std::vector<int> { 4, 1, 2, 3 });
+}
+
diff --git a/tests/unittest/test_scopedremover.cpp b/tests/unittest/test_scopedremover.cpp
index 3e9083b..68ef9d4 100644
--- a/tests/unittest/test_scopedremover.cpp
+++ b/tests/unittest/test_scopedremover.cpp
@@ -2,11 +2,13 @@
 
 #include "eventpp/utilities/scopedremover.h"
 #include "eventpp/eventdispatcher.h"
+#include "eventpp/hetereventdispatcher.h"
 
 TEST_CASE("ScopedRemover, EventDispatcher")
 {
-	eventpp::EventDispatcher<int, void ()> dispatcher;
-	using Remover = eventpp::ScopedRemover<eventpp::EventDispatcher<int, void ()> >;
+	using ED = eventpp::EventDispatcher<int, void ()>;
+	ED dispatcher;
+	using Remover = eventpp::ScopedRemover<ED>;
 	constexpr int event = 3;
 	
 	std::vector<int> dataList(4);
@@ -51,8 +53,9 @@ TEST_CASE("ScopedRemover, EventDispatcher")
 
 TEST_CASE("ScopedRemover, CallbackList")
 {
-	eventpp::CallbackList<void ()> callbackList;
-	using Remover = eventpp::ScopedRemover<eventpp::CallbackList<void ()> >;
+	using CL = eventpp::CallbackList<void ()>;
+	CL callbackList;
+	using Remover = eventpp::ScopedRemover<CL>;
 	
 	std::vector<int> dataList(4);
 	
@@ -94,3 +97,96 @@ TEST_CASE("ScopedRemover, CallbackList")
 	REQUIRE(dataList == std::vector<int> { 4, 3, 2, 1 });
 }
 
+TEST_CASE("ScopedRemover, HeterEventDispatcher")
+{
+	using ED = eventpp::HeterEventDispatcher<int, eventpp::HeterTuple<void ()> >;
+	ED dispatcher;
+	using Remover = eventpp::ScopedRemover<ED>;
+	constexpr int event = 3;
+
+	std::vector<int> dataList(4);
+
+	dispatcher.appendListener(event, [&dataList]() {
+		++dataList[0];
+	});
+
+	{
+		Remover r1(dispatcher);
+		r1.prependListener(event, [&dataList]() {
+			++dataList[1];
+		});
+		{
+			Remover r2(dispatcher);
+			auto handle = r2.appendListener(event, [&dataList]() {
+				++dataList[2];
+			});
+			{
+				Remover r3(dispatcher);
+				r3.insertListener(event, [&dataList]() {
+					++dataList[3];
+				}, handle);
+
+				REQUIRE(dataList == std::vector<int> { 0, 0, 0, 0 });
+
+				dispatcher.dispatch(event);
+				REQUIRE(dataList == std::vector<int> { 1, 1, 1, 1 });
+			}
+
+			dispatcher.dispatch(event);
+			REQUIRE(dataList == std::vector<int> { 2, 2, 2, 1 });
+		}
+
+		dispatcher.dispatch(event);
+		REQUIRE(dataList == std::vector<int> { 3, 3, 2, 1 });
+	}
+
+	dispatcher.dispatch(event);
+	REQUIRE(dataList == std::vector<int> { 4, 3, 2, 1 });
+}
+
+TEST_CASE("ScopedRemover, HeterCallbackList")
+{
+	using CL = eventpp::HeterCallbackList<eventpp::HeterTuple<void ()> >;
+	CL callbackList;
+	using Remover = eventpp::ScopedRemover<CL>;
+
+	std::vector<int> dataList(4);
+
+	callbackList.append([&dataList]() {
+		++dataList[0];
+	});
+
+	{
+		Remover r1(callbackList);
+		r1.prepend([&dataList]() {
+			++dataList[1];
+		});
+		{
+			Remover r2(callbackList);
+			auto handle = r2.append([&dataList]() {
+				++dataList[2];
+			});
+			{
+				Remover r3(callbackList);
+				r3.insert([&dataList]() {
+					++dataList[3];
+				}, handle);
+
+				REQUIRE(dataList == std::vector<int> { 0, 0, 0, 0 });
+
+				callbackList();
+				REQUIRE(dataList == std::vector<int> { 1, 1, 1, 1 });
+			}
+
+			callbackList();
+			REQUIRE(dataList == std::vector<int> { 2, 2, 2, 1 });
+		}
+
+		callbackList();
+		REQUIRE(dataList == std::vector<int> { 3, 3, 2, 1 });
+	}
+
+	callbackList();
+	REQUIRE(dataList == std::vector<int> { 4, 3, 2, 1 });
+}
+

From 85af5fa817264ca9157a53a034a9cd3847699571 Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Fri, 31 May 2019 19:53:37 +0800
Subject: [PATCH 37/38] Fixed compile error on MinGW

---
 doc/conditionalremover.md                  | 2 +-
 doc/counterremover.md                      | 2 +-
 doc/scopedremover.md                       | 2 +-
 include/eventpp/utilities/counterremover.h | 4 ++--
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/doc/conditionalremover.md b/doc/conditionalremover.md
index 7d315da..1115b12 100644
--- a/doc/conditionalremover.md
+++ b/doc/conditionalremover.md
@@ -34,7 +34,7 @@ template <typename DispatcherType>
 class ConditionalRemover;
 ```
 
-`DispatcherType` can be CallbackList, EventDispatcher, or EventQueue.
+`DispatcherType` can be CallbackList, EventDispatcher, EventQueue, HeterCallbackList, HeterEventDispatcher, or HeterEventQueue.
 
 <a id="a3_3"></a>
 ### Member functions
diff --git a/doc/counterremover.md b/doc/counterremover.md
index cf81139..f070fb4 100644
--- a/doc/counterremover.md
+++ b/doc/counterremover.md
@@ -34,7 +34,7 @@ template <typename DispatcherType>
 class CounterRemover;
 ```
 
-`DispatcherType` can be CallbackList, EventDispatcher, or EventQueue.
+`DispatcherType` can be CallbackList, EventDispatcher, EventQueue, HeterCallbackList, HeterEventDispatcher, or HeterEventQueue.
 
 <a id="a3_3"></a>
 ### Member functions
diff --git a/doc/scopedremover.md b/doc/scopedremover.md
index 105670f..8987989 100644
--- a/doc/scopedremover.md
+++ b/doc/scopedremover.md
@@ -33,7 +33,7 @@ template <typename DispatcherType>
 class ScopedRemover;
 ```
 
-`DispatcherType` can be CallbackList, EventDispatcher, or EventQueue.
+`DispatcherType` can be CallbackList, EventDispatcher, EventQueue, HeterCallbackList, HeterEventDispatcher, or HeterEventQueue.
 
 <a id="a3_3"></a>
 ### Member functions
diff --git a/include/eventpp/utilities/counterremover.h b/include/eventpp/utilities/counterremover.h
index dc2100f..25d67a3 100644
--- a/include/eventpp/utilities/counterremover.h
+++ b/include/eventpp/utilities/counterremover.h
@@ -38,7 +38,7 @@ class CounterRemover <
 			int triggerCount;
 			DispatcherType & dispatcher;
 			typename DispatcherType::Event event;
-			typename Callback listener;
+			Callback listener;
 			typename DispatcherType::Handle handle;
 		};
 
@@ -120,7 +120,7 @@ class CounterRemover <
 		{
 			int triggerCount;
 			CallbackListType & callbackList;
-			typename Callback listener;
+			Callback listener;
 			typename CallbackListType::Handle handle;
 		};
 

From c072e39036d2dc7c308eabbb1e8435cef7598f0a Mon Sep 17 00:00:00 2001
From: wqking <wqking@outlook.com>
Date: Fri, 13 Dec 2019 21:17:00 +0800
Subject: [PATCH 38/38] Added VC2019 build. Added change log.

---
 readme.md            | 9 +++++++++
 tests/build/makefile | 6 ++++++
 2 files changed, 15 insertions(+)

diff --git a/readme.md b/readme.md
index 926d226..2d418da 100644
--- a/readme.md
+++ b/readme.md
@@ -126,6 +126,7 @@ The library itself is header only and doesn't need building.
 The unit tests require CMake to build, and there is a makefile to ease the building.  
 Note the unit tests require C++14 (generic lambda), the library itself only requires C++11.  
 Go to folder `tests/build`, then run `make` with different target.
+- `make vc19` #generate solution files for Microsoft Visual Studio 2019, then open eventpptest.sln in folder project_vc19
 - `make vc17` #generate solution files for Microsoft Visual Studio 2017, then open eventpptest.sln in folder project_vc17
 - `make vc15` #generate solution files for Microsoft Visual Studio 2015, then open eventpptest.sln in folder project_vc15
 - `make mingw` #build using MinGW
@@ -136,3 +137,11 @@ Go to folder `tests/build`, then run `make` with different target.
 I (wqking) am a big fan of observer pattern (publish/subscribe pattern), and I used this pattern extensively in my code. I either used GCallbackList in my [cpgf library](https://github.com/cpgf/cpgf) which is too simple and unsafe (not support multi-threading or nested events), or repeated coding event dispatching mechanism such as I did in my [Gincu game engine](https://github.com/wqking/gincu) (the latest version has be rewritten to use eventpp). Both or these methods are neither fun nor robust.  
 Thanking to C++11, now it's quite easy to write a reusable event library with beautiful syntax (it's a nightmare to simulate the variadic template in C++03), so here is `eventpp`.
 
+## Change log
+
+**Version 0.1.1**  
+Added HeterCallbackList, HeterEventDispatcher, and HeterEventQueue.
+
+**Version 0.1.0**  
+First version.  
+Added CallbackList, EventDispatcher, EventQueue, CounterRemover, ConditionalRemover, ScopedRemover, and utilities.
diff --git a/tests/build/makefile b/tests/build/makefile
index 135aa0a..59b9052 100644
--- a/tests/build/makefile
+++ b/tests/build/makefile
@@ -29,6 +29,7 @@ none: needcmake
 	$(ECHO) "  mingw_debug  Generate MinGW makefile and then use mingw32-make to build (debug version)."
 	$(ECHO) "  msys         Generate MSys makefile and then use make to build (release version)."
 	$(ECHO) "  nmake        Generate Microsoft VC makefile and then use nmake to build."
+	$(ECHO) "  vc19         Generate project files for Microsoft VC 2019. No auto build. You need to open the project in VC IDE then build."
 	$(ECHO) "  vc17         Generate project files for Microsoft VC 2017. No auto build. You need to open the project in VC IDE then build."
 	$(ECHO) "  vc15         Generate project files for Microsoft VC 2015. No auto build. You need to open the project in VC IDE then build."
 	$(ECHO) "  auto         Auto detect the compiler and make environment and then use make to build. NOT recommend."
@@ -79,6 +80,11 @@ linux_debug: needcmake
 	$(CH_DIR) $(CACHE_DIR)_linux_debug $(CMAKE) -DCMAKE_BUILD_TYPE=Debug -G"Unix Makefiles"
 	$(EXEC_BUILD)_linux_debug make $(TARGET)
 
+vc19: needcmake
+	$(MK_DIR) $(PROJECT_PREFIX)_vc19
+	$(CH_DIR) $(PROJECT_PREFIX)_vc19 $(CMAKE) -G "Visual Studio 16 2019" -A x64
+	$(ECHO) Please open the solution $(PROJECT).sln in $(PROJECT_PREFIX)_vc19 in VC IDE.
+
 vc17: needcmake
 	$(MK_DIR) $(PROJECT_PREFIX)_vc17
 	$(CH_DIR) $(PROJECT_PREFIX)_vc17 $(CMAKE) -G"Visual Studio 15 2017 Win64"