From 57610fa6ef31b39020231906f8c5d40eaa8294ae Mon Sep 17 00:00:00 2001
From: "Icecream95 (gitlab.com/icecream95)" <the.real.icecream95@gmail.com>
Date: Mon, 21 Oct 2019 17:39:28 +1300
Subject: [PATCH 01/51] Explicitly define winding as being signed

---
 Recast/Source/RecastContour.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Recast/Source/RecastContour.cpp b/Recast/Source/RecastContour.cpp
index 277ab0150..6574c11b6 100644
--- a/Recast/Source/RecastContour.cpp
+++ b/Recast/Source/RecastContour.cpp
@@ -1009,7 +1009,7 @@ bool rcBuildContours(rcContext* ctx, rcCompactHeightfield& chf,
 	if (cset.nconts > 0)
 	{
 		// Calculate winding of all polygons.
-		rcScopedDelete<char> winding((char*)rcAlloc(sizeof(char)*cset.nconts, RC_ALLOC_TEMP));
+		rcScopedDelete<signed char> winding((signed char*)rcAlloc(sizeof(signed char)*cset.nconts, RC_ALLOC_TEMP));
 		if (!winding)
 		{
 			ctx->log(RC_LOG_ERROR, "rcBuildContours: Out of memory 'hole' (%d).", cset.nconts);

From df27e4eb1a4ade9912f8b7d75c25769a3193dbd0 Mon Sep 17 00:00:00 2001
From: Jakob Botsch Nielsen <Jakob.botsch.nielsen@gmail.com>
Date: Mon, 11 May 2020 17:54:25 +0200
Subject: [PATCH 02/51] Fix build

-Wno-error does not ignore unknown warnings on old GCC versions causing
problems when using it for new warnings. On the other hand, -Wno-X will
ignore unknown warnings, so we can use this instead.

Fix #403
Fix #413
---
 RecastDemo/premake5.lua | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/RecastDemo/premake5.lua b/RecastDemo/premake5.lua
index 8c218ddb5..3f8b75b58 100644
--- a/RecastDemo/premake5.lua
+++ b/RecastDemo/premake5.lua
@@ -76,7 +76,7 @@ project "Detour"
 	-- linux library cflags and libs
 	configuration { "linux", "gmake" }
 		buildoptions { 
-			"-Wno-error=class-memaccess"
+			"-Wno-class-memaccess"
 		}
 
 
@@ -156,7 +156,7 @@ project "RecastDemo"
 			"`pkg-config --cflags gl`",
 			"`pkg-config --cflags glu`",
 			"-Wno-ignored-qualifiers",
-			"-Wno-error=class-memaccess"
+			"-Wno-class-memaccess"
 
 		}
 		linkoptions { 

From eecb7f45ecb92d79328cf54719266d8739bdbfb4 Mon Sep 17 00:00:00 2001
From: Dig-Doug <Dig-Doug@users.noreply.github.com>
Date: Wed, 25 Sep 2019 06:20:46 -0700
Subject: [PATCH 03/51] Updates the README instructions for linux

The binary has to be run from the bin directory, otherwise the DroidSans font can't be found and shows the error "Could not init GUI renderer.":

https://github.com/recastnavigation/recastnavigation/blob/master/RecastDemo/Source/main.cpp#L129
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index afa036896..d9e191fee 100644
--- a/README.md
+++ b/README.md
@@ -48,7 +48,7 @@ RecastDemo uses [premake5](http://premake.github.io/) to build platform specific
 - Install SDL2 and its dependencies according to your distro's guidelines.
 - run `premake5 gmake` from the `RecastDemo` folder.
 - `cd Build/gmake` then `make`
-- Run `RecastDemo\Bin\RecastDemo`
+- `cd RecastDemo/Bin` and then run `./RecastDemo`
 
 #### OSX
 

From 9337e124182697de93acb656ef25766486738807 Mon Sep 17 00:00:00 2001
From: Alexey Sokolov <alexey+github@asokolov.org>
Date: Thu, 24 Sep 2020 09:08:03 +0100
Subject: [PATCH 04/51] Several fixes for make install (#437)

* Don't install test

* Install to the correct directory (e.g. lib64)

* Install includes to /usr/include/recastnavigation
---
 CMakeLists.txt                 | 2 ++
 DebugUtils/CMakeLists.txt      | 7 ++++---
 Detour/CMakeLists.txt          | 7 ++++---
 DetourCrowd/CMakeLists.txt     | 7 ++++---
 DetourTileCache/CMakeLists.txt | 7 ++++---
 Recast/CMakeLists.txt          | 7 ++++---
 Tests/CMakeLists.txt           | 2 --
 7 files changed, 22 insertions(+), 17 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index d23859dfc..54a38d808 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -11,6 +11,8 @@ option(RECASTNAVIGATION_TESTS "Build tests" ON)
 option(RECASTNAVIGATION_EXAMPLES "Build examples" ON)
 option(RECASTNAVIGATION_STATIC "Build static libraries" ON)
 
+include(GNUInstallDirs)
+
 add_subdirectory(DebugUtils)
 add_subdirectory(Detour)
 add_subdirectory(DetourCrowd)
diff --git a/DebugUtils/CMakeLists.txt b/DebugUtils/CMakeLists.txt
index 8b6a3fcf6..a1d9decd4 100644
--- a/DebugUtils/CMakeLists.txt
+++ b/DebugUtils/CMakeLists.txt
@@ -26,10 +26,11 @@ set_target_properties(DebugUtils PROPERTIES
         )
 
 install(TARGETS DebugUtils
-        ARCHIVE DESTINATION lib
-        LIBRARY DESTINATION lib
+        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
         COMPONENT library
         )
 
 file(GLOB INCLUDES Include/*.h)
-install(FILES ${INCLUDES} DESTINATION include)
+install(FILES ${INCLUDES} DESTINATION
+    ${CMAKE_INSTALL_INCLUDEDIR}/recastnavigation)
diff --git a/Detour/CMakeLists.txt b/Detour/CMakeLists.txt
index de88111d5..fc21f4419 100644
--- a/Detour/CMakeLists.txt
+++ b/Detour/CMakeLists.txt
@@ -20,10 +20,11 @@ set_target_properties(Detour PROPERTIES
         )
 
 install(TARGETS Detour
-        ARCHIVE DESTINATION lib
-        LIBRARY DESTINATION lib
+        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
         COMPONENT library
         )
 
 file(GLOB INCLUDES Include/*.h)
-install(FILES ${INCLUDES} DESTINATION include)
+install(FILES ${INCLUDES} DESTINATION
+    ${CMAKE_INSTALL_INCLUDEDIR}/recastnavigation)
diff --git a/DetourCrowd/CMakeLists.txt b/DetourCrowd/CMakeLists.txt
index 73cdf7ce8..18f6f7ef2 100644
--- a/DetourCrowd/CMakeLists.txt
+++ b/DetourCrowd/CMakeLists.txt
@@ -24,10 +24,11 @@ set_target_properties(DetourCrowd PROPERTIES
         )
 
 install(TARGETS DetourCrowd
-        ARCHIVE DESTINATION lib
-        LIBRARY DESTINATION lib
+        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
         COMPONENT library
         )
 
 file(GLOB INCLUDES Include/*.h)
-install(FILES ${INCLUDES} DESTINATION include)
+install(FILES ${INCLUDES} DESTINATION
+    ${CMAKE_INSTALL_INCLUDEDIR}/recastnavigation)
diff --git a/DetourTileCache/CMakeLists.txt b/DetourTileCache/CMakeLists.txt
index 121b8edcc..9a0aa1710 100644
--- a/DetourTileCache/CMakeLists.txt
+++ b/DetourTileCache/CMakeLists.txt
@@ -25,10 +25,11 @@ set_target_properties(DetourTileCache PROPERTIES
 
 
 install(TARGETS DetourTileCache
-        ARCHIVE DESTINATION lib
-        LIBRARY DESTINATION lib
+        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
         COMPONENT library
         )
 
 file(GLOB INCLUDES Include/*.h)
-install(FILES ${INCLUDES} DESTINATION include)
+install(FILES ${INCLUDES} DESTINATION
+    ${CMAKE_INSTALL_INCLUDEDIR}/recastnavigation)
diff --git a/Recast/CMakeLists.txt b/Recast/CMakeLists.txt
index 5e843762e..f8402e37f 100644
--- a/Recast/CMakeLists.txt
+++ b/Recast/CMakeLists.txt
@@ -20,10 +20,11 @@ set_target_properties(Recast PROPERTIES
         )
 
 install(TARGETS Recast
-        ARCHIVE DESTINATION lib
-        LIBRARY DESTINATION lib
+        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
         COMPONENT library
         )
 
 file(GLOB INCLUDES Include/*.h)
-install(FILES ${INCLUDES} DESTINATION include)
+install(FILES ${INCLUDES} DESTINATION
+    ${CMAKE_INSTALL_INCLUDEDIR}/recastnavigation)
diff --git a/Tests/CMakeLists.txt b/Tests/CMakeLists.txt
index 7c1746964..a98ccbf13 100644
--- a/Tests/CMakeLists.txt
+++ b/Tests/CMakeLists.txt
@@ -8,5 +8,3 @@ add_executable(Tests ${TESTS_SOURCES})
 add_dependencies(Tests Recast Detour)
 target_link_libraries(Tests Recast Detour)
 add_test(Tests Tests)
-
-install(TARGETS Tests RUNTIME DESTINATION bin)

From e679507845df6d2d008829b5bbee008f4b3f60af Mon Sep 17 00:00:00 2001
From: Jan Haller <bromeon@gmail.com>
Date: Fri, 30 Oct 2020 10:41:54 +0100
Subject: [PATCH 05/51] Improve debug builds for MSVC (#443)

* Add -d suffix for debug libraries

* Export PDB files for each Debug library
---
 DebugUtils/CMakeLists.txt      | 4 ++++
 Detour/CMakeLists.txt          | 4 ++++
 DetourCrowd/CMakeLists.txt     | 4 ++++
 DetourTileCache/CMakeLists.txt | 4 ++++
 Recast/CMakeLists.txt          | 4 ++++
 5 files changed, 20 insertions(+)

diff --git a/DebugUtils/CMakeLists.txt b/DebugUtils/CMakeLists.txt
index a1d9decd4..30fe6261e 100644
--- a/DebugUtils/CMakeLists.txt
+++ b/DebugUtils/CMakeLists.txt
@@ -7,6 +7,7 @@ else()
 endif()
 
 add_library(RecastNavigation::DebugUtils ALIAS DebugUtils)
+set_target_properties(DebugUtils PROPERTIES DEBUG_POSTFIX -d)
 
 set(DebugUtils_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/Include")
 
@@ -23,6 +24,8 @@ target_link_libraries(DebugUtils
 set_target_properties(DebugUtils PROPERTIES
         SOVERSION ${SOVERSION}
         VERSION ${VERSION}
+        COMPILE_PDB_OUTPUT_DIRECTORY .
+        COMPILE_PDB_NAME "DebugUtils-d"
         )
 
 install(TARGETS DebugUtils
@@ -34,3 +37,4 @@ install(TARGETS DebugUtils
 file(GLOB INCLUDES Include/*.h)
 install(FILES ${INCLUDES} DESTINATION
     ${CMAKE_INSTALL_INCLUDEDIR}/recastnavigation)
+install(FILES "$<TARGET_FILE_DIR:DebugUtils>/DebugUtils-d.pdb" CONFIGURATIONS "Debug" DESTINATION "lib") 
diff --git a/Detour/CMakeLists.txt b/Detour/CMakeLists.txt
index fc21f4419..74f9fc063 100644
--- a/Detour/CMakeLists.txt
+++ b/Detour/CMakeLists.txt
@@ -7,6 +7,7 @@ else()
 endif()
 
 add_library(RecastNavigation::Detour ALIAS Detour)
+set_target_properties(Detour PROPERTIES DEBUG_POSTFIX -d)
 
 set(Detour_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/Include")
 
@@ -17,6 +18,8 @@ target_include_directories(Detour PUBLIC
 set_target_properties(Detour PROPERTIES
         SOVERSION ${SOVERSION}
         VERSION ${VERSION}
+        COMPILE_PDB_OUTPUT_DIRECTORY .
+        COMPILE_PDB_NAME "Detour-d"
         )
 
 install(TARGETS Detour
@@ -28,3 +31,4 @@ install(TARGETS Detour
 file(GLOB INCLUDES Include/*.h)
 install(FILES ${INCLUDES} DESTINATION
     ${CMAKE_INSTALL_INCLUDEDIR}/recastnavigation)
+install(FILES "$<TARGET_FILE_DIR:Detour>/Detour-d.pdb" CONFIGURATIONS "Debug" DESTINATION "lib") 
diff --git a/DetourCrowd/CMakeLists.txt b/DetourCrowd/CMakeLists.txt
index 18f6f7ef2..4ea8d8a47 100644
--- a/DetourCrowd/CMakeLists.txt
+++ b/DetourCrowd/CMakeLists.txt
@@ -7,6 +7,7 @@ else ()
 endif ()
 
 add_library(RecastNavigation::DetourCrowd ALIAS DetourCrowd)
+set_target_properties(DetourCrowd PROPERTIES DEBUG_POSTFIX -d)
 
 set(DetourCrowd_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/Include")
 
@@ -21,6 +22,8 @@ target_link_libraries(DetourCrowd
 set_target_properties(DetourCrowd PROPERTIES
         SOVERSION ${SOVERSION}
         VERSION ${VERSION}
+        COMPILE_PDB_OUTPUT_DIRECTORY .
+        COMPILE_PDB_NAME "DetourCrowd-d"
         )
 
 install(TARGETS DetourCrowd
@@ -32,3 +35,4 @@ install(TARGETS DetourCrowd
 file(GLOB INCLUDES Include/*.h)
 install(FILES ${INCLUDES} DESTINATION
     ${CMAKE_INSTALL_INCLUDEDIR}/recastnavigation)
+install(FILES "$<TARGET_FILE_DIR:DetourCrowd>/DetourCrowd-d.pdb" CONFIGURATIONS "Debug" DESTINATION "lib") 
diff --git a/DetourTileCache/CMakeLists.txt b/DetourTileCache/CMakeLists.txt
index 9a0aa1710..7a8936b17 100644
--- a/DetourTileCache/CMakeLists.txt
+++ b/DetourTileCache/CMakeLists.txt
@@ -7,6 +7,7 @@ else ()
 endif ()
 
 add_library(RecastNavigation::DetourTileCache ALIAS DetourTileCache)
+set_target_properties(DetourTileCache PROPERTIES DEBUG_POSTFIX -d)
 
 set(DetourTileCache_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/Include")
 
@@ -21,6 +22,8 @@ target_link_libraries(DetourTileCache
 set_target_properties(DetourTileCache PROPERTIES
         SOVERSION ${SOVERSION}
         VERSION ${VERSION}
+        COMPILE_PDB_OUTPUT_DIRECTORY .
+        COMPILE_PDB_NAME "DetourTileCache-d"
         )
 
 
@@ -33,3 +36,4 @@ install(TARGETS DetourTileCache
 file(GLOB INCLUDES Include/*.h)
 install(FILES ${INCLUDES} DESTINATION
     ${CMAKE_INSTALL_INCLUDEDIR}/recastnavigation)
+install(FILES "$<TARGET_FILE_DIR:DetourTileCache>/DetourTileCache-d.pdb" CONFIGURATIONS "Debug" DESTINATION "lib") 
diff --git a/Recast/CMakeLists.txt b/Recast/CMakeLists.txt
index f8402e37f..60a20364e 100644
--- a/Recast/CMakeLists.txt
+++ b/Recast/CMakeLists.txt
@@ -7,6 +7,7 @@ else ()
 endif ()
 
 add_library(RecastNavigation::Recast ALIAS Recast)
+set_target_properties(Recast PROPERTIES DEBUG_POSTFIX -d)
 
 set(Recast_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/Include")
 
@@ -17,6 +18,8 @@ target_include_directories(Recast PUBLIC
 set_target_properties(Recast PROPERTIES
         SOVERSION ${SOVERSION}
         VERSION ${VERSION}
+        COMPILE_PDB_OUTPUT_DIRECTORY .
+        COMPILE_PDB_NAME "Recast-d"
         )
 
 install(TARGETS Recast
@@ -28,3 +31,4 @@ install(TARGETS Recast
 file(GLOB INCLUDES Include/*.h)
 install(FILES ${INCLUDES} DESTINATION
     ${CMAKE_INSTALL_INCLUDEDIR}/recastnavigation)
+install(FILES "$<TARGET_FILE_DIR:Recast>/Recast-d.pdb" CONFIGURATIONS "Debug" DESTINATION "lib") 

From 8db2f62d7a67a2bacf8a2e966e4710a023fcdf77 Mon Sep 17 00:00:00 2001
From: Jakob Botsch Nielsen <Jakob.botsch.nielsen@gmail.com>
Date: Fri, 30 Oct 2020 10:40:09 +0100
Subject: [PATCH 06/51] Fix compiler error due to memset on type with
 non-trivial constructors

Fix #446
---
 RecastDemo/Include/TestCase.h  | 4 ++++
 RecastDemo/Source/TestCase.cpp | 6 ++----
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/RecastDemo/Include/TestCase.h b/RecastDemo/Include/TestCase.h
index f61cc8565..49dcb2348 100644
--- a/RecastDemo/Include/TestCase.h
+++ b/RecastDemo/Include/TestCase.h
@@ -34,6 +34,10 @@ class TestCase
 	{
 		Test() :
 			type(),
+			spos(),
+			epos(),
+			nspos(),
+			nepos(),
 			radius(0),
 			includeFlags(0),
 			excludeFlags(0),
diff --git a/RecastDemo/Source/TestCase.cpp b/RecastDemo/Source/TestCase.cpp
index cf1214a73..5ce42623f 100644
--- a/RecastDemo/Source/TestCase.cpp
+++ b/RecastDemo/Source/TestCase.cpp
@@ -154,8 +154,7 @@ bool TestCase::load(const std::string& filePath)
 		else if (row[0] == 'p' && row[1] == 'f')
 		{
 			// Pathfind test.
-			Test* test = new Test;
-			memset(test, 0, sizeof(Test));
+			Test* test = new Test();
 			test->type = TEST_PATHFIND;
 			test->expand = false;
 			test->next = m_tests;
@@ -168,8 +167,7 @@ bool TestCase::load(const std::string& filePath)
 		else if (row[0] == 'r' && row[1] == 'c')
 		{
 			// Pathfind test.
-			Test* test = new Test;
-			memset(test, 0, sizeof(Test));
+			Test* test = new Test();
 			test->type = TEST_RAYCAST;
 			test->expand = false;
 			test->next = m_tests;

From 65b314a44e92d5e07d943e7523455ad4d391dfaa Mon Sep 17 00:00:00 2001
From: Yoann Potinet <yoann.potinet@gmail.com>
Date: Fri, 7 Aug 2020 13:06:10 -0400
Subject: [PATCH 07/51] Fix shared library build

---
 CMakeLists.txt                 | 5 ++++-
 DebugUtils/CMakeLists.txt      | 8 ++------
 Detour/CMakeLists.txt          | 8 ++------
 DetourCrowd/CMakeLists.txt     | 8 ++------
 DetourTileCache/CMakeLists.txt | 8 ++------
 Recast/CMakeLists.txt          | 8 ++------
 6 files changed, 14 insertions(+), 31 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 54a38d808..b8af6d54f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -9,7 +9,10 @@ SET(VERSION 1.0.0)
 option(RECASTNAVIGATION_DEMO "Build demo" ON)
 option(RECASTNAVIGATION_TESTS "Build tests" ON)
 option(RECASTNAVIGATION_EXAMPLES "Build examples" ON)
-option(RECASTNAVIGATION_STATIC "Build static libraries" ON)
+
+if(MSVC AND BUILD_SHARED_LIBS)
+    set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
+endif()
 
 include(GNUInstallDirs)
 
diff --git a/DebugUtils/CMakeLists.txt b/DebugUtils/CMakeLists.txt
index 30fe6261e..21d8f8f9d 100644
--- a/DebugUtils/CMakeLists.txt
+++ b/DebugUtils/CMakeLists.txt
@@ -1,10 +1,5 @@
 file(GLOB SOURCES Source/*.cpp)
-
-if (RECASTNAVIGATION_STATIC)
-    add_library(DebugUtils STATIC ${SOURCES})
-else()
-    add_library(DebugUtils SHARED ${SOURCES})
-endif()
+add_library(DebugUtils ${SOURCES})
 
 add_library(RecastNavigation::DebugUtils ALIAS DebugUtils)
 set_target_properties(DebugUtils PROPERTIES DEBUG_POSTFIX -d)
@@ -29,6 +24,7 @@ set_target_properties(DebugUtils PROPERTIES
         )
 
 install(TARGETS DebugUtils
+        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
         COMPONENT library
diff --git a/Detour/CMakeLists.txt b/Detour/CMakeLists.txt
index 74f9fc063..5cb47ec0e 100644
--- a/Detour/CMakeLists.txt
+++ b/Detour/CMakeLists.txt
@@ -1,10 +1,5 @@
 file(GLOB SOURCES Source/*.cpp)
-
-if(RECASTNAVIGATION_STATIC)
-    add_library(Detour STATIC ${SOURCES})
-else()
-    add_library(Detour SHARED ${SOURCES})
-endif()
+add_library(Detour ${SOURCES})
 
 add_library(RecastNavigation::Detour ALIAS Detour)
 set_target_properties(Detour PROPERTIES DEBUG_POSTFIX -d)
@@ -23,6 +18,7 @@ set_target_properties(Detour PROPERTIES
         )
 
 install(TARGETS Detour
+        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
         COMPONENT library
diff --git a/DetourCrowd/CMakeLists.txt b/DetourCrowd/CMakeLists.txt
index 4ea8d8a47..d0e186be0 100644
--- a/DetourCrowd/CMakeLists.txt
+++ b/DetourCrowd/CMakeLists.txt
@@ -1,10 +1,5 @@
 file(GLOB SOURCES Source/*.cpp)
-
-if (RECASTNAVIGATION_STATIC)
-    add_library(DetourCrowd STATIC ${SOURCES})
-else ()
-    add_library(DetourCrowd SHARED ${SOURCES})
-endif ()
+add_library(DetourCrowd ${SOURCES})
 
 add_library(RecastNavigation::DetourCrowd ALIAS DetourCrowd)
 set_target_properties(DetourCrowd PROPERTIES DEBUG_POSTFIX -d)
@@ -27,6 +22,7 @@ set_target_properties(DetourCrowd PROPERTIES
         )
 
 install(TARGETS DetourCrowd
+        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
         COMPONENT library
diff --git a/DetourTileCache/CMakeLists.txt b/DetourTileCache/CMakeLists.txt
index 7a8936b17..3703ebb92 100644
--- a/DetourTileCache/CMakeLists.txt
+++ b/DetourTileCache/CMakeLists.txt
@@ -1,10 +1,5 @@
 file(GLOB SOURCES Source/*.cpp)
-
-if (RECASTNAVIGATION_STATIC)
-    add_library(DetourTileCache STATIC ${SOURCES})
-else ()
-    add_library(DetourTileCache SHARED ${SOURCES})
-endif ()
+add_library(DetourTileCache ${SOURCES})
 
 add_library(RecastNavigation::DetourTileCache ALIAS DetourTileCache)
 set_target_properties(DetourTileCache PROPERTIES DEBUG_POSTFIX -d)
@@ -28,6 +23,7 @@ set_target_properties(DetourTileCache PROPERTIES
 
 
 install(TARGETS DetourTileCache
+        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
         COMPONENT library
diff --git a/Recast/CMakeLists.txt b/Recast/CMakeLists.txt
index 60a20364e..360654464 100644
--- a/Recast/CMakeLists.txt
+++ b/Recast/CMakeLists.txt
@@ -1,10 +1,5 @@
 file(GLOB SOURCES Source/*.cpp)
-
-if (RECASTNAVIGATION_STATIC)
-    add_library(Recast STATIC ${SOURCES})
-else ()
-    add_library(Recast SHARED ${SOURCES})
-endif ()
+add_library(Recast ${SOURCES})
 
 add_library(RecastNavigation::Recast ALIAS Recast)
 set_target_properties(Recast PROPERTIES DEBUG_POSTFIX -d)
@@ -23,6 +18,7 @@ set_target_properties(Recast PROPERTIES
         )
 
 install(TARGETS Recast
+        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
         COMPONENT library

From 24230e8e8dde374507174cefa877b218b03447e5 Mon Sep 17 00:00:00 2001
From: Kyeongho Park <khpark@ncsoft.com>
Date: Tue, 17 Nov 2020 19:46:52 +0900
Subject: [PATCH 08/51] Bugfix/chunkytrimesh subdivide maxnodes (#451)

* minor redundant: dir

* bugfix: ChunkyTriMesh nodes array: out of bounds
---
 RecastDemo/Source/ChunkyTriMesh.cpp | 2 +-
 RecastDemo/Source/InputGeom.cpp     | 3 ---
 2 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/RecastDemo/Source/ChunkyTriMesh.cpp b/RecastDemo/Source/ChunkyTriMesh.cpp
index 2991d4ff8..242bf285a 100644
--- a/RecastDemo/Source/ChunkyTriMesh.cpp
+++ b/RecastDemo/Source/ChunkyTriMesh.cpp
@@ -83,7 +83,7 @@ static void subdivide(BoundsItem* items, int nitems, int imin, int imax, int tri
 	int inum = imax - imin;
 	int icur = curNode;
 	
-	if (curNode > maxNodes)
+	if (curNode >= maxNodes)
 		return;
 
 	rcChunkyTriMeshNode& node = nodes[curNode++];
diff --git a/RecastDemo/Source/InputGeom.cpp b/RecastDemo/Source/InputGeom.cpp
index a5f9a0d15..fc6af8204 100644
--- a/RecastDemo/Source/InputGeom.cpp
+++ b/RecastDemo/Source/InputGeom.cpp
@@ -424,9 +424,6 @@ static bool isectSegAABB(const float* sp, const float* sq,
 
 bool InputGeom::raycastMesh(float* src, float* dst, float& tmin)
 {
-	float dir[3];
-	rcVsub(dir, dst, src);
-
 	// Prune hit ray.
 	float btmin, btmax;
 	if (!isectSegAABB(src, dst, m_meshBMin, m_meshBMax, btmin, btmax))

From 6624e7aef5e15df11cb2f5673574df8e4c96af6a Mon Sep 17 00:00:00 2001
From: ZhihuiLiu <1085438567@qq.com>
Date: Fri, 13 Nov 2020 12:08:02 +0800
Subject: [PATCH 09/51] fix an index error

---
 DetourCrowd/Source/DetourCrowd.cpp | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/DetourCrowd/Source/DetourCrowd.cpp b/DetourCrowd/Source/DetourCrowd.cpp
index 1e76e40ce..3f0311f7f 100644
--- a/DetourCrowd/Source/DetourCrowd.cpp
+++ b/DetourCrowd/Source/DetourCrowd.cpp
@@ -1409,12 +1409,14 @@ void dtCrowd::update(const float dt, dtCrowdAgentDebugInfo* debug)
 	}
 	
 	// Update agents using off-mesh connection.
-	for (int i = 0; i < m_maxAgents; ++i)
+	for (int i = 0; i < nagents; ++i)
 	{
-		dtCrowdAgentAnimation* anim = &m_agentAnims[i];
+		dtCrowdAgent* ag = agents[i];
+		const int idx = (int)(ag - m_agents);
+		dtCrowdAgentAnimation* anim = &m_agentAnims[idx];
 		if (!anim->active)
 			continue;
-		dtCrowdAgent* ag = agents[i];
+		
 
 		anim->t += dt;
 		if (anim->t > anim->tmax)

From 9dc88fcab98b2213e88f7bbe5a3354ffc70c59bc Mon Sep 17 00:00:00 2001
From: Jan Haller <bromeon@gmail.com>
Date: Thu, 19 Nov 2020 10:13:30 +0100
Subject: [PATCH 10/51] Validate constraint: #polygons per tile (#449)

* Validate constraint: #polygons per tile

When adding a tile to a NavMesh, ensure that the number of polygons in that tile fit in the poly ID address space.

* Improve dtNavMeshParams field documentation
---
 Detour/Include/DetourNavMesh.h  | 4 ++--
 Detour/Source/DetourNavMesh.cpp | 7 +++++++
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/Detour/Include/DetourNavMesh.h b/Detour/Include/DetourNavMesh.h
index 98293c49d..9ac1dc8d6 100644
--- a/Detour/Include/DetourNavMesh.h
+++ b/Detour/Include/DetourNavMesh.h
@@ -329,8 +329,8 @@ struct dtNavMeshParams
 	float orig[3];					///< The world space origin of the navigation mesh's tile space. [(x, y, z)]
 	float tileWidth;				///< The width of each tile. (Along the x-axis.)
 	float tileHeight;				///< The height of each tile. (Along the z-axis.)
-	int maxTiles;					///< The maximum number of tiles the navigation mesh can contain.
-	int maxPolys;					///< The maximum number of polygons each tile can contain.
+	int maxTiles;					///< The maximum number of tiles the navigation mesh can contain. This and maxPolys are used to calculate how many bits are needed to identify tiles and polygons uniquely.
+	int maxPolys;					///< The maximum number of polygons each tile can contain. This and maxTiles are used to calculate how many bits are needed to identify tiles and polygons uniquely.
 };
 
 /// A navigation mesh based on tiles of convex polygons.
diff --git a/Detour/Source/DetourNavMesh.cpp b/Detour/Source/DetourNavMesh.cpp
index a655d1d89..b119cd541 100644
--- a/Detour/Source/DetourNavMesh.cpp
+++ b/Detour/Source/DetourNavMesh.cpp
@@ -914,6 +914,13 @@ dtStatus dtNavMesh::addTile(unsigned char* data, int dataSize, int flags,
 		return DT_FAILURE | DT_WRONG_MAGIC;
 	if (header->version != DT_NAVMESH_VERSION)
 		return DT_FAILURE | DT_WRONG_VERSION;
+
+#ifndef DT_POLYREF64
+	// Do not allow adding more polygons than specified in the NavMesh's maxPolys constraint.
+	// Otherwise, the poly ID cannot be represented with the given number of bits.
+	if (m_polyBits < dtIlog2(dtNextPow2((unsigned int)header->polyCount)))
+		return DT_FAILURE | DT_INVALID_PARAM;
+#endif
 		
 	// Make sure the location is free.
 	if (getTileAt(header->x, header->y, header->layer))

From ec05c9e17c31bb5528ca0daf06974ed5fb9fd18c Mon Sep 17 00:00:00 2001
From: Jakob Botsch Nielsen <Jakob.botsch.nielsen@gmail.com>
Date: Thu, 19 Nov 2020 14:23:59 +0100
Subject: [PATCH 11/51] Update build instructions for Windows

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index d9e191fee..3e1d3ada9 100644
--- a/README.md
+++ b/README.md
@@ -62,7 +62,7 @@ RecastDemo uses [premake5](http://premake.github.io/) to build platform specific
 #### Windows
 
 - Grab the latest SDL2 development library release from [here](https://www.libsdl.org/download-2.0.php) and unzip it `RecastDemo\Contrib`.  Rename the SDL folder such that the path `RecastDemo\Contrib\SDL\lib\x86` is valid.
-- Run `"premake5" vs2015` from the `RecastDemo` folder
+- Run `"premake5" vs2019` from the `RecastDemo` folder
 - Open the solution, build, and run.
 
 ### Running Unit tests

From c32297c2f9532a55a11c00f22ec763d771d3dae5 Mon Sep 17 00:00:00 2001
From: Rubaka <rubakabit@gmail.com>
Date: Thu, 19 Nov 2020 18:27:26 +0300
Subject: [PATCH 12/51] Fixed run RecastDemo on MVS

---
 RecastDemo/CMakeLists.txt | 30 ++++++++++++++++++++++++------
 1 file changed, 24 insertions(+), 6 deletions(-)

diff --git a/RecastDemo/CMakeLists.txt b/RecastDemo/CMakeLists.txt
index a6a1a7333..b379b27bd 100644
--- a/RecastDemo/CMakeLists.txt
+++ b/RecastDemo/CMakeLists.txt
@@ -18,6 +18,7 @@ include_directories(../DetourCrowd/Include)
 include_directories(../DetourTileCache/Include)
 include_directories(../Recast/Include)
 include_directories(Include)
+include_directories(Contrib/SDL/include)
 
 if (WIN32)
     add_executable(RecastDemo WIN32 ${SOURCES})
@@ -27,14 +28,31 @@ else()
     add_executable(RecastDemo ${SOURCES})
 endif()
 
-file(COPY Bin/Meshes DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
-file(COPY Bin/TestCases DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
-file(COPY Bin/DroidSans.ttf DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
-
-if (WIN32)
-    file(COPY "${SDL2_RUNTIME_LIBRARY}" DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
+if( WIN32 )
+  if ( "${CMAKE_MAKE_PROGRAM}" MATCHES "MSBuild" )
+    add_custom_command(TARGET RecastDemo
+      POST_BUILD
+      COMMAND ${CMAKE_COMMAND} -E copy "${SDL2_RUNTIME_LIBRARY}" ${CMAKE_BINARY_DIR}/RecastDemo/$(ConfigurationName)/
+      COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/Bin/Meshes ${CMAKE_BINARY_DIR}/RecastDemo/$(ConfigurationName)/Meshes
+      COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/Bin/TestCases ${CMAKE_BINARY_DIR}/RecastDemo/$(ConfigurationName)/TestCases
+      COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/Bin/DroidSans.ttf ${CMAKE_BINARY_DIR}/RecastDemo/$(ConfigurationName)/
+    )
+  elseif ( MINGW )
+    add_custom_command(TARGET RecastDemo
+      POST_BUILD
+      COMMAND ${CMAKE_COMMAND} -E copy "${SDL2_RUNTIME_LIBRARY}" ${CMAKE_BINARY_DIR}/RecastDemo/
+      COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/Bin/Meshes ${CMAKE_BINARY_DIR}/RecastDemo/Meshes
+      COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/Bin/TestCases ${CMAKE_BINARY_DIR}/RecastDemo/TestCases
+      COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/Bin/DroidSans.ttf ${CMAKE_BINARY_DIR}/RecastDemo/
+    )
+  endif()
+else()
+    file(COPY Bin/Meshes DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
+    file(COPY Bin/TestCases DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
+    file(COPY Bin/DroidSans.ttf DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
 endif()
 
+
 add_dependencies(RecastDemo DebugUtils Detour DetourCrowd DetourTileCache Recast)
 target_link_libraries(RecastDemo ${OPENGL_LIBRARIES} SDL2::SDL2main DebugUtils Detour DetourCrowd DetourTileCache Recast)
 

From cf4f3e15a85775db643381f32623cfde40720db9 Mon Sep 17 00:00:00 2001
From: Jan Haller <bromeon@gmail.com>
Date: Sat, 23 Jan 2021 13:25:41 +0100
Subject: [PATCH 13/51] Poly query API: expose distance and isOverPoly (#448)

* Add dtNavMeshQuery.findNearestPoly() overload with parameters: distance, isOverPoly

* dtNavMeshQuery::findNearestPoly(): improve documentation, avoid code duplication

* Make code C++98-compatible

* Remove distance parameter from dtNavMeshQuery::queryPolygons()
---
 Detour/Include/DetourNavMeshQuery.h  | 22 +++++++++++++++++++---
 Detour/Source/DetourNavMeshQuery.cpp | 18 +++++++++++++++++-
 2 files changed, 36 insertions(+), 4 deletions(-)

diff --git a/Detour/Include/DetourNavMeshQuery.h b/Detour/Include/DetourNavMeshQuery.h
index 0b40371be..08b70a8f5 100644
--- a/Detour/Include/DetourNavMeshQuery.h
+++ b/Detour/Include/DetourNavMeshQuery.h
@@ -313,15 +313,31 @@ class dtNavMeshQuery
 	///@{
 
 	/// Finds the polygon nearest to the specified center point.
+	/// [opt] means the specified parameter can be a null pointer, in that case the output parameter will not be set.
+	///
 	///  @param[in]		center		The center of the search box. [(x, y, z)]
-	///  @param[in]		halfExtents		The search distance along each axis. [(x, y, z)]
+	///  @param[in]		halfExtents	The search distance along each axis. [(x, y, z)]
 	///  @param[in]		filter		The polygon filter to apply to the query.
-	///  @param[out]	nearestRef	The reference id of the nearest polygon.
-	///  @param[out]	nearestPt	The nearest point on the polygon. [opt] [(x, y, z)]
+	///  @param[out]	nearestRef	The reference id of the nearest polygon. Will be set to 0 if no polygon is found.
+	///  @param[out]	nearestPt	The nearest point on the polygon. Unchanged if no polygon is found. [opt] [(x, y, z)]
 	/// @returns The status flags for the query.
 	dtStatus findNearestPoly(const float* center, const float* halfExtents,
 							 const dtQueryFilter* filter,
 							 dtPolyRef* nearestRef, float* nearestPt) const;
+
+	/// Finds the polygon nearest to the specified center point.
+	/// [opt] means the specified parameter can be a null pointer, in that case the output parameter will not be set.
+	/// 
+	///  @param[in]		center		The center of the search box. [(x, y, z)]
+	///  @param[in]		halfExtents	The search distance along each axis. [(x, y, z)]
+	///  @param[in]		filter		The polygon filter to apply to the query.
+	///  @param[out]	nearestRef	The reference id of the nearest polygon. Will be set to 0 if no polygon is found.
+	///  @param[out]	nearestPt	The nearest point on the polygon. Unchanged if no polygon is found. [opt] [(x, y, z)]
+	///  @param[out]	isOverPoly 	Set to true if the point's X/Z coordinate lies inside the polygon, false otherwise. Unchanged if no polygon is found. [opt]
+	/// @returns The status flags for the query.
+	dtStatus findNearestPoly(const float* center, const float* halfExtents,
+							 const dtQueryFilter* filter,
+							 dtPolyRef* nearestRef, float* nearestPt, bool* isOverPoly) const;
 	
 	/// Finds polygons that overlap the search box.
 	///  @param[in]		center		The center of the search box. [(x, y, z)]
diff --git a/Detour/Source/DetourNavMeshQuery.cpp b/Detour/Source/DetourNavMeshQuery.cpp
index 839ee1e81..8ea09c823 100644
--- a/Detour/Source/DetourNavMeshQuery.cpp
+++ b/Detour/Source/DetourNavMeshQuery.cpp
@@ -630,15 +630,17 @@ class dtFindNearestPolyQuery : public dtPolyQuery
 	float m_nearestDistanceSqr;
 	dtPolyRef m_nearestRef;
 	float m_nearestPoint[3];
+	bool m_overPoly;
 
 public:
 	dtFindNearestPolyQuery(const dtNavMeshQuery* query, const float* center)
-		: m_query(query), m_center(center), m_nearestDistanceSqr(FLT_MAX), m_nearestRef(0), m_nearestPoint()
+		: m_query(query), m_center(center), m_nearestDistanceSqr(FLT_MAX), m_nearestRef(0), m_nearestPoint(), m_overPoly(false)
 	{
 	}
 
 	dtPolyRef nearestRef() const { return m_nearestRef; }
 	const float* nearestPoint() const { return m_nearestPoint; }
+	bool isOverPoly() const { return m_overPoly; }
 
 	void process(const dtMeshTile* tile, dtPoly** polys, dtPolyRef* refs, int count)
 	{
@@ -672,6 +674,7 @@ class dtFindNearestPolyQuery : public dtPolyQuery
 
 				m_nearestDistanceSqr = d;
 				m_nearestRef = ref;
+				m_overPoly = posOverPoly;
 			}
 		}
 	}
@@ -686,6 +689,15 @@ class dtFindNearestPolyQuery : public dtPolyQuery
 dtStatus dtNavMeshQuery::findNearestPoly(const float* center, const float* halfExtents,
 										 const dtQueryFilter* filter,
 										 dtPolyRef* nearestRef, float* nearestPt) const
+{
+	return findNearestPoly(center, halfExtents, filter, nearestRef, nearestPt, NULL);
+}
+
+// If center and nearestPt point to an equal position, isOverPoly will be true;
+// however there's also a special case of climb height inside the polygon (see dtFindNearestPolyQuery)
+dtStatus dtNavMeshQuery::findNearestPoly(const float* center, const float* halfExtents,
+										 const dtQueryFilter* filter,
+										 dtPolyRef* nearestRef, float* nearestPt, bool* isOverPoly) const
 {
 	dtAssert(m_nav);
 
@@ -704,7 +716,11 @@ dtStatus dtNavMeshQuery::findNearestPoly(const float* center, const float* halfE
 	// Only override nearestPt if we actually found a poly so the nearest point
 	// is valid.
 	if (nearestPt && *nearestRef)
+	{
 		dtVcopy(nearestPt, query.nearestPoint());
+		if (isOverPoly)
+			*isOverPoly = query.isOverPoly();
+	}
 	
 	return DT_SUCCESS;
 }

From e75adf86f91eb3082220085e42dda62679f9a3ea Mon Sep 17 00:00:00 2001
From: Gleb Mazovetskiy <glex.spb@gmail.com>
Date: Mon, 15 Feb 2021 19:27:21 +0800
Subject: [PATCH 14/51] Avoid reallocs of temp vectors (#467)

* Use clear() instead of resize(0) for temp vectors

Nicer style

* rcVectorBase::resize: Avoid realloc on grow

When capacity is sufficient, do not realloc the whole buffer

* rcVector: Grow exponentially on resize
---
 Recast/Include/RecastAlloc.h       | 47 +++++++++++++++++++++---------
 Recast/Source/RecastContour.cpp    |  4 +--
 Recast/Source/RecastMeshDetail.cpp | 16 +++++-----
 Recast/Source/RecastRegion.cpp     | 10 +++----
 4 files changed, 49 insertions(+), 28 deletions(-)

diff --git a/Recast/Include/RecastAlloc.h b/Recast/Include/RecastAlloc.h
index e436af9a0..20e8dd1bc 100644
--- a/Recast/Include/RecastAlloc.h
+++ b/Recast/Include/RecastAlloc.h
@@ -106,6 +106,8 @@ class rcVectorBase {
 	// Creates an array of the given size, copies all of this vector's data into it, and returns it.
 	T* allocate_and_copy(rcSizeType size);
 	void resize_impl(rcSizeType size, const T* value);
+	// Requires: min_capacity > m_cap.
+	rcSizeType get_new_capacity(rcSizeType min_capacity);
  public:
 	typedef rcSizeType size_type;
 	typedef T value_type;
@@ -196,8 +198,7 @@ void rcVectorBase<T, H>::push_back(const T& value) {
 		return;
 	}
 
-	rcAssert(RC_SIZE_MAX / 2 >= m_size);
-	rcSizeType new_cap = m_size ? 2*m_size : 1;
+	const rcSizeType new_cap = get_new_capacity(m_cap + 1);
 	T* data = allocate_and_copy(new_cap);
 	// construct between allocate and destroy+free in case value is
 	// in this vector.
@@ -208,25 +209,44 @@ void rcVectorBase<T, H>::push_back(const T& value) {
 	rcFree(m_data);
 	m_data = data;
 }
+
+template <typename T, rcAllocHint H>
+rcSizeType rcVectorBase<T, H>::get_new_capacity(rcSizeType min_capacity) {
+	rcAssert(min_capacity <= RC_SIZE_MAX);
+	if (rcUnlikely(m_cap >= RC_SIZE_MAX / 2))
+		return RC_SIZE_MAX;
+	return 2 * m_cap > min_capacity ? 2 * m_cap : min_capacity;
+}
+
 template <typename T, rcAllocHint H>
 void rcVectorBase<T, H>::resize_impl(rcSizeType size, const T* value) {
 	if (size < m_size) {
 		destroy_range(size, m_size);
 		m_size = size;
 	} else if (size > m_size) {
-		T* new_data = allocate_and_copy(size);
-		// We defer deconstructing/freeing old data until after constructing
-		// new elements in case "value" is there.
-		if (value) {
-			construct_range(new_data + m_size, new_data + size, *value);
+		if (size <= m_cap) {
+			if (value) {
+				construct_range(m_data + m_size, m_data + size, *value);
+			} else {
+				construct_range(m_data + m_size, m_data + size);
+			}
+			m_size = size;
 		} else {
-			construct_range(new_data + m_size, new_data + size);
+			const rcSizeType new_cap = get_new_capacity(size);
+			T* new_data = allocate_and_copy(new_cap);
+			// We defer deconstructing/freeing old data until after constructing
+			// new elements in case "value" is there.
+			if (value) {
+				construct_range(new_data + m_size, new_data + size, *value);
+			} else {
+				construct_range(new_data + m_size, new_data + size);
+			}
+			destroy_range(0, m_size);
+			rcFree(m_data);
+			m_data = new_data;
+			m_cap = new_cap;
+			m_size = size;
 		}
-		destroy_range(0, m_size);
-		rcFree(m_data);
-		m_data = new_data;
-		m_cap = size;
-		m_size = size;
 	}
 }
 template <typename T, rcAllocHint H>
@@ -303,6 +323,7 @@ class rcIntArray
 	rcIntArray(int n) : m_impl(n, 0) {}
 	void push(int item) { m_impl.push_back(item); }
 	void resize(int size) { m_impl.resize(size); }
+	void clear() { m_impl.clear(); }
 	int pop()
 	{
 		int v = m_impl.back();
diff --git a/Recast/Source/RecastContour.cpp b/Recast/Source/RecastContour.cpp
index 6574c11b6..1293d4fbd 100644
--- a/Recast/Source/RecastContour.cpp
+++ b/Recast/Source/RecastContour.cpp
@@ -921,8 +921,8 @@ bool rcBuildContours(rcContext* ctx, rcCompactHeightfield& chf,
 					continue;
 				const unsigned char area = chf.areas[i];
 				
-				verts.resize(0);
-				simplified.resize(0);
+				verts.clear();
+				simplified.clear();
 				
 				ctx->startTimer(RC_TIMER_BUILD_CONTOURS_TRACE);
 				walkContour(x, y, i, chf, flags, verts);
diff --git a/Recast/Source/RecastMeshDetail.cpp b/Recast/Source/RecastMeshDetail.cpp
index 9a423cab8..1999200c1 100644
--- a/Recast/Source/RecastMeshDetail.cpp
+++ b/Recast/Source/RecastMeshDetail.cpp
@@ -653,8 +653,8 @@ static bool buildPolyDetail(rcContext* ctx, const float* in, const int nin,
 	for (int i = 0; i < nin; ++i)
 		rcVcopy(&verts[i*3], &in[i*3]);
 	
-	edges.resize(0);
-	tris.resize(0);
+	edges.clear();
+	tris.clear();
 	
 	const float cs = chf.cs;
 	const float ics = 1.0f/cs;
@@ -803,7 +803,7 @@ static bool buildPolyDetail(rcContext* ctx, const float* in, const int nin,
 		int x1 = (int)ceilf(bmax[0]/sampleDist);
 		int z0 = (int)floorf(bmin[2]/sampleDist);
 		int z1 = (int)ceilf(bmax[2]/sampleDist);
-		samples.resize(0);
+		samples.clear();
 		for (int z = z0; z < z1; ++z)
 		{
 			for (int x = x0; x < x1; ++x)
@@ -864,8 +864,8 @@ static bool buildPolyDetail(rcContext* ctx, const float* in, const int nin,
 			
 			// Create new triangulation.
 			// TODO: Incremental add instead of full rebuild.
-			edges.resize(0);
-			tris.resize(0);
+			edges.clear();
+			tris.clear();
 			delaunayHull(ctx, nverts, verts, nhull, hull, tris, edges);
 		}
 	}
@@ -935,7 +935,7 @@ static void seedArrayWithPolyCenter(rcContext* ctx, const rcCompactHeightfield&
 	pcy /= npoly;
 	
 	// Use seeds array as a stack for DFS
-	array.resize(0);
+	array.clear();
 	array.push(startCellX);
 	array.push(startCellY);
 	array.push(startSpanIndex);
@@ -1001,7 +1001,7 @@ static void seedArrayWithPolyCenter(rcContext* ctx, const rcCompactHeightfield&
 		rcSwap(dirs[directDir], dirs[3]);
 	}
 
-	array.resize(0);
+	array.clear();
 	// getHeightData seeds are given in coordinates with borders
 	array.push(cx+bs);
 	array.push(cy+bs);
@@ -1030,7 +1030,7 @@ static void getHeightData(rcContext* ctx, const rcCompactHeightfield& chf,
 	// Note: Reads to the compact heightfield are offset by border size (bs)
 	// since border size offset is already removed from the polymesh vertices.
 	
-	queue.resize(0);
+	queue.clear();
 	// Set all heights to RC_UNSET_HEIGHT.
 	memset(hp.data, 0xff, sizeof(unsigned short)*hp.width*hp.height);
 
diff --git a/Recast/Source/RecastRegion.cpp b/Recast/Source/RecastRegion.cpp
index e1fc0ee78..48318688b 100644
--- a/Recast/Source/RecastRegion.cpp
+++ b/Recast/Source/RecastRegion.cpp
@@ -650,7 +650,7 @@ static bool mergeRegions(rcRegion& rega, rcRegion& regb)
 		return false;
 	
 	// Merge neighbours.
-	rega.connections.resize(0);
+	rega.connections.clear();
 	for (int i = 0, ni = acon.size(); i < ni-1; ++i)
 		rega.connections.push(acon[(insa+1+i) % ni]);
 		
@@ -876,8 +876,8 @@ static bool mergeAndFilterRegions(rcContext* ctx, int minRegionArea, int mergeRe
 		// Also keep track of the regions connects to a tile border.
 		bool connectsToBorder = false;
 		int spanCount = 0;
-		stack.resize(0);
-		trace.resize(0);
+		stack.clear();
+		trace.clear();
 
 		reg.visited = true;
 		stack.push(i);
@@ -1068,7 +1068,7 @@ static bool mergeAndFilterLayerRegions(rcContext* ctx, int minRegionArea,
 		{
 			const rcCompactCell& c = chf.cells[x+y*w];
 
-			lregs.resize(0);
+			lregs.clear();
 			
 			for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i)
 			{
@@ -1139,7 +1139,7 @@ static bool mergeAndFilterLayerRegions(rcContext* ctx, int minRegionArea,
 		// Start search.
 		root.id = layerId;
 
-		stack.resize(0);
+		stack.clear();
 		stack.push(i);
 		
 		while (stack.size() > 0)

From 1f25f9cc29ae56fa23531af01abef375a186aa2d Mon Sep 17 00:00:00 2001
From: elsid <elsid.mail@gmail.com>
Date: Wed, 3 Mar 2021 17:33:44 +0100
Subject: [PATCH 15/51] Install .pdb files only with MSVC

---
 DebugUtils/CMakeLists.txt      | 4 +++-
 Detour/CMakeLists.txt          | 4 +++-
 DetourCrowd/CMakeLists.txt     | 4 +++-
 DetourTileCache/CMakeLists.txt | 4 +++-
 Recast/CMakeLists.txt          | 4 +++-
 5 files changed, 15 insertions(+), 5 deletions(-)

diff --git a/DebugUtils/CMakeLists.txt b/DebugUtils/CMakeLists.txt
index 21d8f8f9d..14b36a9a5 100644
--- a/DebugUtils/CMakeLists.txt
+++ b/DebugUtils/CMakeLists.txt
@@ -33,4 +33,6 @@ install(TARGETS DebugUtils
 file(GLOB INCLUDES Include/*.h)
 install(FILES ${INCLUDES} DESTINATION
     ${CMAKE_INSTALL_INCLUDEDIR}/recastnavigation)
-install(FILES "$<TARGET_FILE_DIR:DebugUtils>/DebugUtils-d.pdb" CONFIGURATIONS "Debug" DESTINATION "lib") 
+if(MSVC)
+    install(FILES "$<TARGET_FILE_DIR:DebugUtils>/DebugUtils-d.pdb" CONFIGURATIONS "Debug" DESTINATION "lib")
+endif()
diff --git a/Detour/CMakeLists.txt b/Detour/CMakeLists.txt
index 5cb47ec0e..da1a195c5 100644
--- a/Detour/CMakeLists.txt
+++ b/Detour/CMakeLists.txt
@@ -27,4 +27,6 @@ install(TARGETS Detour
 file(GLOB INCLUDES Include/*.h)
 install(FILES ${INCLUDES} DESTINATION
     ${CMAKE_INSTALL_INCLUDEDIR}/recastnavigation)
-install(FILES "$<TARGET_FILE_DIR:Detour>/Detour-d.pdb" CONFIGURATIONS "Debug" DESTINATION "lib") 
+if(MSVC)
+    install(FILES "$<TARGET_FILE_DIR:Detour>/Detour-d.pdb" CONFIGURATIONS "Debug" DESTINATION "lib")
+endif()
diff --git a/DetourCrowd/CMakeLists.txt b/DetourCrowd/CMakeLists.txt
index d0e186be0..60b8e1a73 100644
--- a/DetourCrowd/CMakeLists.txt
+++ b/DetourCrowd/CMakeLists.txt
@@ -31,4 +31,6 @@ install(TARGETS DetourCrowd
 file(GLOB INCLUDES Include/*.h)
 install(FILES ${INCLUDES} DESTINATION
     ${CMAKE_INSTALL_INCLUDEDIR}/recastnavigation)
-install(FILES "$<TARGET_FILE_DIR:DetourCrowd>/DetourCrowd-d.pdb" CONFIGURATIONS "Debug" DESTINATION "lib") 
+if(MSVC)
+    install(FILES "$<TARGET_FILE_DIR:DetourCrowd>/DetourCrowd-d.pdb" CONFIGURATIONS "Debug" DESTINATION "lib")
+endif()
diff --git a/DetourTileCache/CMakeLists.txt b/DetourTileCache/CMakeLists.txt
index 3703ebb92..cf2d437a2 100644
--- a/DetourTileCache/CMakeLists.txt
+++ b/DetourTileCache/CMakeLists.txt
@@ -32,4 +32,6 @@ install(TARGETS DetourTileCache
 file(GLOB INCLUDES Include/*.h)
 install(FILES ${INCLUDES} DESTINATION
     ${CMAKE_INSTALL_INCLUDEDIR}/recastnavigation)
-install(FILES "$<TARGET_FILE_DIR:DetourTileCache>/DetourTileCache-d.pdb" CONFIGURATIONS "Debug" DESTINATION "lib") 
+if(MSVC)
+    install(FILES "$<TARGET_FILE_DIR:DetourTileCache>/DetourTileCache-d.pdb" CONFIGURATIONS "Debug" DESTINATION "lib")
+endif()
diff --git a/Recast/CMakeLists.txt b/Recast/CMakeLists.txt
index 360654464..f25cab898 100644
--- a/Recast/CMakeLists.txt
+++ b/Recast/CMakeLists.txt
@@ -27,4 +27,6 @@ install(TARGETS Recast
 file(GLOB INCLUDES Include/*.h)
 install(FILES ${INCLUDES} DESTINATION
     ${CMAKE_INSTALL_INCLUDEDIR}/recastnavigation)
-install(FILES "$<TARGET_FILE_DIR:Recast>/Recast-d.pdb" CONFIGURATIONS "Debug" DESTINATION "lib") 
+if(MSVC)
+    install(FILES "$<TARGET_FILE_DIR:Recast>/Recast-d.pdb" CONFIGURATIONS "Debug" DESTINATION "lib")
+endif()

From 63a4ee4c1e696a5a2a0577f3351104b570bfdd48 Mon Sep 17 00:00:00 2001
From: Bret Curtis <psi29a@gmail.com>
Date: Fri, 5 Mar 2021 17:24:04 +0100
Subject: [PATCH 16/51] Add version and pkgconfig (#474)

* Add version and pkgconfig

* simply versioning

Co-authored-by: Bret Curtis <bret.curtis@pegus.digital>
---
 CMakeLists.txt                 | 23 ++++++++++++++++++++++-
 DebugUtils/CMakeLists.txt      |  2 +-
 Detour/CMakeLists.txt          |  2 +-
 DetourCrowd/CMakeLists.txt     |  2 +-
 DetourTileCache/CMakeLists.txt |  2 +-
 Recast/CMakeLists.txt          |  2 +-
 recastnavigation.pc.in         | 10 ++++++++++
 version.h.in                   |  3 +++
 8 files changed, 40 insertions(+), 6 deletions(-)
 create mode 100644 recastnavigation.pc.in
 create mode 100644 version.h.in

diff --git a/CMakeLists.txt b/CMakeLists.txt
index b8af6d54f..c3121c6ec 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -4,7 +4,8 @@ project(RecastNavigation)
 
 # lib versions
 SET(SOVERSION 1)
-SET(VERSION 1.0.0)
+set(LIB_VERSION 1.5.1)
+string(REPLACE "." "," LIB_VERSION_NUM "${LIB_VERSION}.0")
 
 option(RECASTNAVIGATION_DEMO "Build demo" ON)
 option(RECASTNAVIGATION_TESTS "Build tests" ON)
@@ -16,6 +17,26 @@ endif()
 
 include(GNUInstallDirs)
 
+configure_file(
+    "${RecastNavigation_SOURCE_DIR}/version.h.in"
+    "${RecastNavigation_BINARY_DIR}/version.h")
+install(FILES "${RecastNavigation_BINARY_DIR}/version.h" DESTINATION
+        ${CMAKE_INSTALL_INCLUDEDIR}/recastnavigation)
+
+# Needed for recastnavigation.pc.in
+set(prefix ${CMAKE_INSTALL_PREFIX})
+set(exec_prefix "\${prefix}")
+set(libdir "\${exec_prefix}/${CMAKE_INSTALL_LIBDIR}")
+set(bindir "\${exec_prefix}/${CMAKE_INSTALL_BINDIR}")
+set(includedir "\${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")
+set(PACKAGE_VERSION "${LIB_VERSION}")
+configure_file(
+        "${RecastNavigation_SOURCE_DIR}/recastnavigation.pc.in"
+        "${RecastNavigation_BINARY_DIR}/recastnavigation.pc"
+        @ONLY)
+install(FILES "${RecastNavigation_BINARY_DIR}/recastnavigation.pc"
+        DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
+
 add_subdirectory(DebugUtils)
 add_subdirectory(Detour)
 add_subdirectory(DetourCrowd)
diff --git a/DebugUtils/CMakeLists.txt b/DebugUtils/CMakeLists.txt
index 14b36a9a5..f6325c4ac 100644
--- a/DebugUtils/CMakeLists.txt
+++ b/DebugUtils/CMakeLists.txt
@@ -18,7 +18,7 @@ target_link_libraries(DebugUtils
 
 set_target_properties(DebugUtils PROPERTIES
         SOVERSION ${SOVERSION}
-        VERSION ${VERSION}
+        VERSION ${LIB_VERSION}
         COMPILE_PDB_OUTPUT_DIRECTORY .
         COMPILE_PDB_NAME "DebugUtils-d"
         )
diff --git a/Detour/CMakeLists.txt b/Detour/CMakeLists.txt
index da1a195c5..a3ca80858 100644
--- a/Detour/CMakeLists.txt
+++ b/Detour/CMakeLists.txt
@@ -12,7 +12,7 @@ target_include_directories(Detour PUBLIC
 
 set_target_properties(Detour PROPERTIES
         SOVERSION ${SOVERSION}
-        VERSION ${VERSION}
+        VERSION ${LIB_VERSION}
         COMPILE_PDB_OUTPUT_DIRECTORY .
         COMPILE_PDB_NAME "Detour-d"
         )
diff --git a/DetourCrowd/CMakeLists.txt b/DetourCrowd/CMakeLists.txt
index 60b8e1a73..1a5d2243d 100644
--- a/DetourCrowd/CMakeLists.txt
+++ b/DetourCrowd/CMakeLists.txt
@@ -16,7 +16,7 @@ target_link_libraries(DetourCrowd
 
 set_target_properties(DetourCrowd PROPERTIES
         SOVERSION ${SOVERSION}
-        VERSION ${VERSION}
+        VERSION ${LIB_VERSION}
         COMPILE_PDB_OUTPUT_DIRECTORY .
         COMPILE_PDB_NAME "DetourCrowd-d"
         )
diff --git a/DetourTileCache/CMakeLists.txt b/DetourTileCache/CMakeLists.txt
index cf2d437a2..7b835560c 100644
--- a/DetourTileCache/CMakeLists.txt
+++ b/DetourTileCache/CMakeLists.txt
@@ -16,7 +16,7 @@ target_link_libraries(DetourTileCache
 
 set_target_properties(DetourTileCache PROPERTIES
         SOVERSION ${SOVERSION}
-        VERSION ${VERSION}
+        VERSION ${LIB_VERSION}
         COMPILE_PDB_OUTPUT_DIRECTORY .
         COMPILE_PDB_NAME "DetourTileCache-d"
         )
diff --git a/Recast/CMakeLists.txt b/Recast/CMakeLists.txt
index f25cab898..de88b8115 100644
--- a/Recast/CMakeLists.txt
+++ b/Recast/CMakeLists.txt
@@ -12,7 +12,7 @@ target_include_directories(Recast PUBLIC
 
 set_target_properties(Recast PROPERTIES
         SOVERSION ${SOVERSION}
-        VERSION ${VERSION}
+        VERSION ${LIB_VERSION}
         COMPILE_PDB_OUTPUT_DIRECTORY .
         COMPILE_PDB_NAME "Recast-d"
         )
diff --git a/recastnavigation.pc.in b/recastnavigation.pc.in
new file mode 100644
index 000000000..7f806fd44
--- /dev/null
+++ b/recastnavigation.pc.in
@@ -0,0 +1,10 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: RecastNavigation
+Description: RecastNavigation is a cross-platform navigation mesh construction toolset for games
+Version: @PACKAGE_VERSION@
+Libs: -L${libdir} -lRecast -lDetour -lDebugUtils -lDetourCrowd -lDetourTileCache
+Cflags: -I${includedir} -I${includedir}/recastnavigation @PKG_CONFIG_CFLAGS@
\ No newline at end of file
diff --git a/version.h.in b/version.h.in
new file mode 100644
index 000000000..5e6e16c18
--- /dev/null
+++ b/version.h.in
@@ -0,0 +1,3 @@
+/* Define to the library version */
+#define RECASTNAV_VERSION "${LIB_VERSION}"
+#define RECASTNAV_VERSION_NUM ${LIB_VERSION_NUM}

From c5cbd53024c8a9d8d097a4371215e3342d2fdc87 Mon Sep 17 00:00:00 2001
From: Bret Curtis <psi29a@gmail.com>
Date: Fri, 5 Mar 2021 17:24:41 +0100
Subject: [PATCH 17/51] Fix MacOS builds on Travis (#475)

* use defaults where possible, simplify .travis.yml and fix macos builds while we are at it

* de-duplicate code

* specifically ask for xcode12.2
---
 .travis.yml | 40 ++++++++++------------------------------
 1 file changed, 10 insertions(+), 30 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 0e63abad1..6cd8bbc2b 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,4 +1,6 @@
 language: cpp
+os: linux
+dist: bionic
 branches:
   only:
   - master
@@ -9,55 +11,33 @@ sudo: false
 
 addons:
   apt:
-    sources:
-      - ubuntu-toolchain-r-test
-      - llvm-toolchain-xenial-7
-    packages: [ cmake, clang-7, clang-tools-7, gcc-8, g++-8, libsdl2-dev ]
+    packages: [ build-essential, cmake, clang, clang-tools, libsdl2-dev ]
 
 matrix:
   include:
-  - name: Recastnavigation (all) on MacOS xcode9.4
+  - name: Recastnavigation on MacOS using XCode
     os: osx
-    osx_image: xcode9.4
+    osx_image: xcode12.2
     before_install:
       - brew update
       - brew install sdl2
     if: branch != coverity_scan
-  - name: Recastnavigation on Ubuntu Xenial GCC-5
-    os: linux
-    dist: xenial
-    sudo: required
+  - name: Recastnavigation on Ubuntu GCC
     if: branch != coverity_scan
-  - name: Recastnavigation on Ubuntu Xenial GCC-8
-    os: linux
-    dist: xenial
-    sudo: required
-    env:
-      - MATRIX_EVAL="CC=gcc-8 && CXX=g++-8"
-    if: branch != coverity_scan
-  - name: Recastnavigation on Ubuntu Xenial GCC-5 using Premake5
-    os: linux
-    dist: xenial
-    sudo: required
+  - name: Recastnavigation on Ubuntu GCC using Premake5
     if: branch != coverity_scan
     before_install:
       - wget https://github.com/premake/premake-core/releases/download/v5.0.0-alpha12/premake-5.0.0-alpha12-linux.tar.gz -O premake.tar.gz
       - tar -xf premake.tar.gz
     env:
       - PREMAKE=1
-  - name: Recastnavigation on Ubuntu Xenial Clang-7 with Static Analysis
-    os: linux
-    dist: xenial
-    sudo: required
+  - name: Recastnavigation on Ubuntu Clang with Static Analysis
     env:
-      - MATRIX_EVAL="CC=clang-7 && CXX=clang++-7"
-      - ANALYZE="scan-build-7 --force-analyze-debug-code --use-cc clang-7 --use-c++ clang++-7"
+      - MATRIX_EVAL="CC=clang && CXX=clang++"
+      - ANALYZE="scan-build --force-analyze-debug-code --use-cc clang --use-c++ clang++"
     if: branch != coverity_scan
     compiler: clang
   - name: Recastnavigation Coverity Scan
-    os: linux
-    dist: xenial
-    sudo: required
     if: branch = coverity_scan
 
 before_script:

From 5a870d427e47abd4a8e4ce58a95582ec049434d5 Mon Sep 17 00:00:00 2001
From: Prin_E <ddderer@gmail.com>
Date: Thu, 17 Mar 2022 01:53:48 +0900
Subject: [PATCH 18/51] Fixed RecastDemo crash in macOS 10.11+

* Set hints to always use OpenGL render driver (instead of Metal driver)
* Compile error fix in Xcode 13
---
 Recast/Include/RecastAlloc.h | 2 +-
 RecastDemo/Source/main.cpp   | 3 +++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/Recast/Include/RecastAlloc.h b/Recast/Include/RecastAlloc.h
index 20e8dd1bc..071278d65 100644
--- a/Recast/Include/RecastAlloc.h
+++ b/Recast/Include/RecastAlloc.h
@@ -22,7 +22,7 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#include <RecastAssert.h>
+#include "RecastAssert.h"
 
 /// Provides hint values to the memory allocator on how long the
 /// memory is expected to be used.
diff --git a/RecastDemo/Source/main.cpp b/RecastDemo/Source/main.cpp
index e9f584df4..270c2af3b 100644
--- a/RecastDemo/Source/main.cpp
+++ b/RecastDemo/Source/main.cpp
@@ -78,6 +78,9 @@ int main(int /*argc*/, char** /*argv*/)
 		return -1;
 	}
 
+    // Use OpenGL render driver.
+    SDL_SetHint(SDL_HINT_RENDER_DRIVER, "opengl");
+
 	// Enable depth buffer.
 	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
 	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);

From c02d6fa81eb8e332b932186ebd5641f249f46fe8 Mon Sep 17 00:00:00 2001
From: Brian Swenson <unknown>
Date: Wed, 1 Jun 2022 17:29:09 -0400
Subject: [PATCH 19/51] -Wunused-but-set-variable flagged variables removed

---
 DetourTileCache/Source/DetourTileCacheBuilder.cpp | 2 --
 Recast/Source/RecastMesh.cpp                      | 2 --
 2 files changed, 4 deletions(-)

diff --git a/DetourTileCache/Source/DetourTileCacheBuilder.cpp b/DetourTileCache/Source/DetourTileCacheBuilder.cpp
index 21a59f1a6..05e34acd1 100644
--- a/DetourTileCache/Source/DetourTileCacheBuilder.cpp
+++ b/DetourTileCache/Source/DetourTileCacheBuilder.cpp
@@ -1399,7 +1399,6 @@ static void pushBack(unsigned short v, unsigned short* arr, int& an)
 static bool canRemoveVertex(dtTileCachePolyMesh& mesh, const unsigned short rem)
 {
 	// Count number of polygons to remove.
-	int numRemovedVerts = 0;
 	int numTouchedVerts = 0;
 	int numRemainingEdges = 0;
 	for (int i = 0; i < mesh.npolys; ++i)
@@ -1419,7 +1418,6 @@ static bool canRemoveVertex(dtTileCachePolyMesh& mesh, const unsigned short rem)
 		}
 		if (numRemoved)
 		{
-			numRemovedVerts += numRemoved;
 			numRemainingEdges += numVerts-(numRemoved+1);
 		}
 	}
diff --git a/Recast/Source/RecastMesh.cpp b/Recast/Source/RecastMesh.cpp
index e99eaebb7..ea09ee1de 100644
--- a/Recast/Source/RecastMesh.cpp
+++ b/Recast/Source/RecastMesh.cpp
@@ -566,7 +566,6 @@ static bool canRemoveVertex(rcContext* ctx, rcPolyMesh& mesh, const unsigned sho
 	const int nvp = mesh.nvp;
 	
 	// Count number of polygons to remove.
-	int numRemovedVerts = 0;
 	int numTouchedVerts = 0;
 	int numRemainingEdges = 0;
 	for (int i = 0; i < mesh.npolys; ++i)
@@ -586,7 +585,6 @@ static bool canRemoveVertex(rcContext* ctx, rcPolyMesh& mesh, const unsigned sho
 		}
 		if (numRemoved)
 		{
-			numRemovedVerts += numRemoved;
 			numRemainingEdges += numVerts-(numRemoved+1);
 		}
 	}

From c187b7e88bfc922bca2175e3751881bdf378ff0d Mon Sep 17 00:00:00 2001
From: Graham Pentheny <grahamboree@users.noreply.github.com>
Date: Fri, 3 Jun 2022 02:56:44 -0400
Subject: [PATCH 20/51] Removed broken IssueStats badges from README.md

---
 README.md | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/README.md b/README.md
index 3e1d3ada9..2ea200af9 100644
--- a/README.md
+++ b/README.md
@@ -5,9 +5,6 @@ Recast & Detour
 [![Travis (Linux) Build Status](https://travis-ci.org/recastnavigation/recastnavigation.svg?branch=master)](https://travis-ci.org/recastnavigation/recastnavigation)
 [![Appveyor (Windows) Build  Status](https://ci.appveyor.com/api/projects/status/20w84u25b3f8h179/branch/master?svg=true)](https://ci.appveyor.com/project/recastnavigation/recastnavigation/branch/master)
 
-[![Issue Stats](http://www.issuestats.com/github/recastnavigation/recastnavigation/badge/pr?style=flat)](http://www.issuestats.com/github/recastnavigation/recastnavigation)
-[![Issue Stats](http://www.issuestats.com/github/recastnavigation/recastnavigation/badge/issue?style=flat)](http://www.issuestats.com/github/recastnavigation/recastnavigation)
-
 ![screenshot of a navmesh baked with the sample program](/RecastDemo/screenshot.png?raw=true)
 
 ## Recast

From 2164a272e5487534c1f63f6ace8cb30ca9683280 Mon Sep 17 00:00:00 2001
From: Graham Pentheny <graham.pentheny@gmail.com>
Date: Thu, 6 Oct 2022 22:48:29 -0400
Subject: [PATCH 21/51] Updated array size in docstring for dtMeshTile::verts

Thanks to @pineappleKID for pointing this out!
https://github.com/recastnavigation/recastnavigation/issues/535
---
 Detour/Include/DetourNavMesh.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Detour/Include/DetourNavMesh.h b/Detour/Include/DetourNavMesh.h
index 9ac1dc8d6..cb5414f53 100644
--- a/Detour/Include/DetourNavMesh.h
+++ b/Detour/Include/DetourNavMesh.h
@@ -285,7 +285,7 @@ struct dtMeshTile
 	unsigned int linksFreeList;			///< Index to the next free link.
 	dtMeshHeader* header;				///< The tile header.
 	dtPoly* polys;						///< The tile polygons. [Size: dtMeshHeader::polyCount]
-	float* verts;						///< The tile vertices. [Size: dtMeshHeader::vertCount]
+	float* verts;						///< The tile vertices. [(x, y, z) * dtMeshHeader::vertCount]
 	dtLink* links;						///< The tile links. [Size: dtMeshHeader::maxLinkCount]
 	dtPolyDetail* detailMeshes;			///< The tile's detail sub-meshes. [Size: dtMeshHeader::detailMeshCount]
 	

From 3a1924e3b03a19dbddd1a0af64dea27bf09c339a Mon Sep 17 00:00:00 2001
From: ZA139 <40553487+ZA139@users.noreply.github.com>
Date: Sun, 9 Oct 2022 21:11:34 +0800
Subject: [PATCH 22/51] Correction the comment of dtVperp2D

The return value should be the perp dot product rather than the dot product.
---
 Detour/Include/DetourCommon.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Detour/Include/DetourCommon.h b/Detour/Include/DetourCommon.h
index 113e8c336..d578ebe59 100644
--- a/Detour/Include/DetourCommon.h
+++ b/Detour/Include/DetourCommon.h
@@ -319,7 +319,7 @@ inline float dtVdot2D(const float* u, const float* v)
 /// Derives the xz-plane 2D perp product of the two vectors. (uz*vx - ux*vz)
 ///  @param[in]		u		The LHV vector [(x, y, z)]
 ///  @param[in]		v		The RHV vector [(x, y, z)]
-/// @return The dot product on the xz-plane.
+/// @return The prep dot product on the xz-plane.
 ///
 /// The vectors are projected onto the xz-plane, so the y-values are ignored.
 inline float dtVperp2D(const float* u, const float* v)

From 314e94b692fe6c5df1de703527c8774a473526b7 Mon Sep 17 00:00:00 2001
From: ZA139 <40553487+ZA139@users.noreply.github.com>
Date: Mon, 10 Oct 2022 09:29:52 +0800
Subject: [PATCH 23/51] Fix the typo though of dtVperp2D function comment

fix typo though
---
 Detour/Include/DetourCommon.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Detour/Include/DetourCommon.h b/Detour/Include/DetourCommon.h
index d578ebe59..9d247fe55 100644
--- a/Detour/Include/DetourCommon.h
+++ b/Detour/Include/DetourCommon.h
@@ -319,7 +319,7 @@ inline float dtVdot2D(const float* u, const float* v)
 /// Derives the xz-plane 2D perp product of the two vectors. (uz*vx - ux*vz)
 ///  @param[in]		u		The LHV vector [(x, y, z)]
 ///  @param[in]		v		The RHV vector [(x, y, z)]
-/// @return The prep dot product on the xz-plane.
+/// @return The perp dot product on the xz-plane.
 ///
 /// The vectors are projected onto the xz-plane, so the y-values are ignored.
 inline float dtVperp2D(const float* u, const float* v)

From 30edaf442c87e870e71a0e4509a96281418b1af8 Mon Sep 17 00:00:00 2001
From: Andrei Kortunov <andrei.kortunov@yandex.ru>
Date: Tue, 11 Oct 2022 09:31:06 +0400
Subject: [PATCH 24/51] Fix -Wextra-semi GCC warnings by removing redundant
 semicolons

---
 Recast/Include/RecastAlloc.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Recast/Include/RecastAlloc.h b/Recast/Include/RecastAlloc.h
index 071278d65..8b166d736 100644
--- a/Recast/Include/RecastAlloc.h
+++ b/Recast/Include/RecastAlloc.h
@@ -112,7 +112,7 @@ class rcVectorBase {
 	typedef rcSizeType size_type;
 	typedef T value_type;
 
-	rcVectorBase() : m_size(0), m_cap(0), m_data(0) {};
+	rcVectorBase() : m_size(0), m_cap(0), m_data(0) {}
 	rcVectorBase(const rcVectorBase<T, H>& other) : m_size(0), m_cap(0), m_data(0) { assign(other.begin(), other.end()); }
 	explicit rcVectorBase(rcSizeType count) : m_size(0), m_cap(0), m_data(0) { resize(count); }
 	rcVectorBase(rcSizeType count, const T& value) : m_size(0), m_cap(0), m_data(0) { resize(count, value); }
@@ -142,8 +142,8 @@ class rcVectorBase {
 
 	const T& front() const { rcAssert(m_size); return m_data[0]; }
 	T& front() { rcAssert(m_size); return m_data[0]; }
-	const T& back() const { rcAssert(m_size); return m_data[m_size - 1]; };
-	T& back() { rcAssert(m_size); return m_data[m_size - 1]; };
+	const T& back() const { rcAssert(m_size); return m_data[m_size - 1]; }
+	T& back() { rcAssert(m_size); return m_data[m_size - 1]; }
 	const T* data() const { return m_data; }
 	T* data() { return m_data; }
 

From a425d03b0e41021193059df70e0a64363b71286b Mon Sep 17 00:00:00 2001
From: grdowns <grdowns@microsoft.com>
Date: Tue, 10 Sep 2019 12:11:28 -0700
Subject: [PATCH 25/51] Add vcpkg installation instructions

---
 README.md | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/README.md b/README.md
index 2ea200af9..6f8fae903 100644
--- a/README.md
+++ b/README.md
@@ -31,6 +31,12 @@ Recast is accompanied with Detour, path-finding and spatial reasoning toolkit. Y
 
 Detour offers simple static navigation mesh which is suitable for many simple cases, as well as tiled navigation mesh which allows you to plug in and out pieces of the mesh. The tiled mesh allows you to create systems where you stream new navigation data in and out as the player progresses the level, or you may regenerate tiles as the world changes. 
 
+## Installation through vcpkg
+
+If you are using the [vcpkg](https://github.com/Microsoft/vcpkg/) dependency manager you can download and install Recast with a single command:
+```
+vcpkg install recast
+```
 
 ## Recast Demo
 

From 9df3e2e0a6e37651f876fd1960ce91687ed2d48f Mon Sep 17 00:00:00 2001
From: Anton Matveev <Learko@users.noreply.github.com>
Date: Fri, 17 Apr 2020 12:57:31 +0500
Subject: [PATCH 26/51] Fix rounding error due to precision loss after
 optimization.

---
 Detour/Source/DetourNavMesh.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Detour/Source/DetourNavMesh.cpp b/Detour/Source/DetourNavMesh.cpp
index b119cd541..2240526eb 100644
--- a/Detour/Source/DetourNavMesh.cpp
+++ b/Detour/Source/DetourNavMesh.cpp
@@ -433,8 +433,8 @@ void dtNavMesh::connectExtLinks(dtMeshTile* tile, dtMeshTile* target, int side)
 						float tmax = (neia[k*2+1]-va[2]) / (vb[2]-va[2]);
 						if (tmin > tmax)
 							dtSwap(tmin,tmax);
-						link->bmin = (unsigned char)(dtClamp(tmin, 0.0f, 1.0f)*255.0f);
-						link->bmax = (unsigned char)(dtClamp(tmax, 0.0f, 1.0f)*255.0f);
+						link->bmin = (unsigned char)roundf(dtClamp(tmin, 0.0f, 1.0f)*255.0f);
+						link->bmax = (unsigned char)roundf(dtClamp(tmax, 0.0f, 1.0f)*255.0f);
 					}
 					else if (dir == 2 || dir == 6)
 					{
@@ -442,8 +442,8 @@ void dtNavMesh::connectExtLinks(dtMeshTile* tile, dtMeshTile* target, int side)
 						float tmax = (neia[k*2+1]-va[0]) / (vb[0]-va[0]);
 						if (tmin > tmax)
 							dtSwap(tmin,tmax);
-						link->bmin = (unsigned char)(dtClamp(tmin, 0.0f, 1.0f)*255.0f);
-						link->bmax = (unsigned char)(dtClamp(tmax, 0.0f, 1.0f)*255.0f);
+						link->bmin = (unsigned char)roundf(dtClamp(tmin, 0.0f, 1.0f)*255.0f);
+						link->bmax = (unsigned char)roundf(dtClamp(tmax, 0.0f, 1.0f)*255.0f);
 					}
 				}
 			}

From 0af470fe748466d66c56a134785340bd2906ed97 Mon Sep 17 00:00:00 2001
From: EfveZombie <34877029+EfveZombie@users.noreply.github.com>
Date: Thu, 13 Oct 2022 17:27:06 +0800
Subject: [PATCH 27/51] fix: use closestPointOnPoly instead of getPolyHeight in
 dtNavMeshQuery::findRandomPoint (#560)

---
 Detour/Source/DetourNavMeshQuery.cpp | 14 +++-----------
 1 file changed, 3 insertions(+), 11 deletions(-)

diff --git a/Detour/Source/DetourNavMeshQuery.cpp b/Detour/Source/DetourNavMeshQuery.cpp
index 8ea09c823..b48618f0a 100644
--- a/Detour/Source/DetourNavMeshQuery.cpp
+++ b/Detour/Source/DetourNavMeshQuery.cpp
@@ -301,11 +301,7 @@ dtStatus dtNavMeshQuery::findRandomPoint(const dtQueryFilter* filter, float (*fr
 	float pt[3];
 	dtRandomPointInConvexPoly(verts, poly->vertCount, areas, s, t, pt);
 	
-	float h = 0.0f;
-	dtStatus status = getPolyHeight(polyRef, pt, &h);
-	if (dtStatusFailed(status))
-		return status;
-	pt[1] = h;
+	closestPointOnPoly(polyRef, pt, pt, NULL);
 	
 	dtVcopy(randomPt, pt);
 	*randomRef = polyRef;
@@ -488,16 +484,12 @@ dtStatus dtNavMeshQuery::findRandomPointAroundCircle(dtPolyRef startRef, const f
 	float pt[3];
 	dtRandomPointInConvexPoly(verts, randomPoly->vertCount, areas, s, t, pt);
 	
-	float h = 0.0f;
-	dtStatus stat = getPolyHeight(randomPolyRef, pt, &h);
-	if (dtStatusFailed(status))
-		return stat;
-	pt[1] = h;
+	closestPointOnPoly(randomPolyRef, pt, pt, NULL);
 	
 	dtVcopy(randomPt, pt);
 	*randomRef = randomPolyRef;
 	
-	return DT_SUCCESS;
+	return status;
 }
 
 

From 4e233f22b432e77dd9a3e2e5b990750d88d4c465 Mon Sep 17 00:00:00 2001
From: Graham Pentheny <graham.pentheny@gmail.com>
Date: Wed, 12 Oct 2022 00:55:38 -0400
Subject: [PATCH 28/51] Added configuration protips from Mikko's blog to a FAQ

---
 Docs/Conceptual/FAQ.md | 49 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 Docs/Conceptual/FAQ.md

diff --git a/Docs/Conceptual/FAQ.md b/Docs/Conceptual/FAQ.md
new file mode 100644
index 000000000..232aef6ec
--- /dev/null
+++ b/Docs/Conceptual/FAQ.md
@@ -0,0 +1,49 @@
+# Configuring Recast with rcConfig
+The following describes best practices for configuring Recast.  They're broken down by the fields in `rcConfig` and are ordered by the sequence in which you should consider them.
+
+## Determine Agent Size
+First you should decide the size of your agent's logical cylinder. If your game world uses meters as units, a reasonable starting point for a human-sized agent might be a radius of `0.4` and a height of `2.0`.
+
+## cs
+The voxelization cell size `cs` defines the voxel size along both axes of the ground plane: x and z in Recast. This value is usually derived from the character radius `r`. A recommended starting value for `cs` is either `r/2` or `r/3`. Smaller values of `cs` will increase rasterization resolution and navmesh detail, but total generation time will increase exponentially.  In outdoor environments, `r/2` is often good enough.  For indoor scenes with tight spaces you might want the extra precision, so a value of `r/3` or smaller may give better results.
+
+The initial instinct is to reduce this value to something very close to zero to maximize the detail of the generated navmesh. This quickly becomes a case of diminishing returns, however. Beyond a certain point there's usually not much perceptable difference in the generated navmesh, but huge increases in generation time.  This hinders your ability to quickly iterate on level designs and provides little benefit.  The general recommendation here is to use as large a value for `cs` as you can get away with.
+
+## ch
+The voxelization cell height `ch` is defined separately in order to allow greater precision in height tests. A good starting point for `ch` is half the `cs` value. Smaller `ch` values ensure that the navmesh properly connects areas that are only separated by a small curb or ditch.  If small holes are generated in your navmesh around where there are discontinuities in height (for example, stairs or curbs), you may want to decrease the cell height value to increase the vertical rasterization precision of Recast.
+
+## walkableHeight
+This value defines the height `h` of the agent in voxels. This value should be calculated as `ceil(h / ch)`.  Note this is based on `ch` not `cs` since it's a height value.
+
+## walkableClimb
+The `walkableClimb` value defines the maximum height of ledges and steps that the agent can walk up. Given a designer-defined `maxClimb` distance in world units, this value should be calculated as `ceil(maxClimb / ch)`.  Again, note that this is using `ch` not `cs` because it's a height-based value.
+
+## walkableRadius
+The parameter `walkableRadius` defines the agent radius in voxels.  Most often, this value should be calculated as `ceil(r/cs)`. Note this is based on `cs` since the agent radius is always parallel to the ground plane.
+
+If the `walkableRadius` value is greater than zero, the edges of the navmesh will be pushed away from all obstacles by this amount.
+
+A non-zero `walkableRadius` allows for much simpler runtime navmesh collision checks. The game only needs to check that the center point of the agent is contained within a navmesh polygon.  Without this erosion, runtime navigation checks need to collide the geometric projection onto the navmesh of agent's logical cylinder with the boundary edges of the navmesh polygons.
+
+Navmesh erosion is performed on the voxelized world representation, so some precision can be lost there. This step allows simpler checks at runtime. 
+
+If you want to have tight-fitting navmesh, or want to reuse the same navmesh for multiple agents with differing radii, you can use a `walkableRadius` value of zero.
+
+## walkableSlopeAngle
+The parameter `walkableSlopeAngle` is to filter out areas of the world where the ground slope would be too steep for an agent to traverse. This value is defined as a maximum angle in degrees that the surface normal of a polgyon can differ from the world's up vector.  This value must be within the range `[0, 90]`.
+
+## maxEdgeLen
+In certain cases, long outer edges may decrease the quality of the resulting triangulation, creating very long thin triangles. This can sometimes be remedied by limiting the maximum edge length, causing the problematic long edges to be broken up into smaller segments. 
+
+The parameter `maxEdgeLen` defines the maximum edge length and is defined in terms of voxels. A good value for `maxEdgeLen` is something like `walkableRadius * 8`. A good way to adjust this value is to first set it really high and see if your data creates long edges. If it does, decrease `maxEdgeLen` until you find the largest value which improves the resulting tesselation.
+
+## maxSimplificationError
+When the rasterized areas are converted back to a vectorized representation, the `maxSimplificationError` describes how loosely the simplification is done.  The simplification process uses the [Ramer–Douglas-Peucker algorithm](https://en.wikipedia.org/wiki/Ramer–Douglas–Peucker_algorithm), and this value describes the max deviation in voxels. 
+
+Good values for `maxSimplificationError` are in the range `[1.1, 1.5]`.  A value of `1.3` is a good starting point and usually yields good results. If the value is less than `1.1`, some sawtoothing starts to appear at the generated edges.  If the value is more than `1.5`, the mesh simplification starts to cut some corners it shouldn't.
+
+## minRegionSize
+Watershed partitioning is really prone to noise in the input distance field. In order to get nicer areas, the areas are merged and small disconnected areas are removed after the water shed partitioning. The parameter `minRegionSize` describes the minimum isolated region size that is still kept. A region is removed if the number of voxels in the region is less than the square of `minRegionSize`.
+
+## mergeRegionSize
+The triangulation process works best with small, localized voxel regions. The parameter `mergeRegionSize` controls the maximum voxel area of a region that is allowed to be merged with another region.  If you see small patches missing here and there, you could lower the minRegionSize.

From c14a5a58977ae8aea7bc02d0e498bfdf4d13201b Mon Sep 17 00:00:00 2001
From: Graham Pentheny <graham.pentheny@gmail.com>
Date: Tue, 25 Oct 2022 19:47:43 -0400
Subject: [PATCH 29/51] Ignore generated dSYM debug symbols archive on mac

---
 .gitignore | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.gitignore b/.gitignore
index 98f17e4b7..1e20e6026 100644
--- a/.gitignore
+++ b/.gitignore
@@ -16,6 +16,9 @@ RecastDemo/Bin/Tests
 # Build directory
 RecastDemo/Build
 
+# XCode debug symbols archive
+RecastDemo/Bin/*.dSYM
+
 # Ignore meshes
 RecastDemo/Bin/Meshes/*
 

From 96dc90b6ff93007a82c2325ee696bfb32b642cc0 Mon Sep 17 00:00:00 2001
From: Graham Pentheny <graham.pentheny@gmail.com>
Date: Tue, 25 Oct 2022 19:43:55 -0400
Subject: [PATCH 30/51] Fix deprecation warnings when using premake5

The premake script generates some deprecation warnings when generating with premake5:
- "configuration" has been deprecated in favor of "filter"
- "solution" was renamed to "workspace"
---
 RecastDemo/premake5.lua | 33 ++++++++++++++++-----------------
 1 file changed, 16 insertions(+), 17 deletions(-)

diff --git a/RecastDemo/premake5.lua b/RecastDemo/premake5.lua
index 3f8b75b58..f6fdca6a8 100644
--- a/RecastDemo/premake5.lua
+++ b/RecastDemo/premake5.lua
@@ -6,7 +6,7 @@
 local action = _ACTION or ""
 local todir = "Build/" .. action
 
-solution "recastnavigation"
+workspace "recastnavigation"
 	configurations { 
 		"Debug",
 		"Release"
@@ -15,27 +15,27 @@ solution "recastnavigation"
 	location (todir)
 
 	floatingpoint "Fast"
-	symbols "On"
 	exceptionhandling "Off"
 	rtti "Off"
+	symbols "On"
 	flags { "FatalCompileWarnings" }
 
 	-- debug configs
-	configuration "Debug*"
+	filter "configurations:Debug"
 		defines { "DEBUG" }
 		targetdir ( todir .. "/lib/Debug" )
  
  	-- release configs
-	configuration "Release*"
+	filter "configurations:Release"
 		defines { "NDEBUG" }
 		optimize "On"
 		targetdir ( todir .. "/lib/Release" )
 
-	configuration "not windows"
+	filter "system:not windows"
 		warnings "Extra"
 
 	-- windows specific
-	configuration "windows"
+	filter "system:windows"
 		platforms { "Win32", "Win64" }
 		defines { "WIN32", "_WINDOWS", "_CRT_SECURE_NO_WARNINGS", "_HAS_EXCEPTIONS=0" }
 		-- warnings "Extra" uses /W4 which is too aggressive for us, so use W3 instead.
@@ -58,7 +58,7 @@ project "DebugUtils"
 		"../DetourTileCache/Include",
 		"../Recast/Include"
 	}
-	files { 
+	files {
 		"../DebugUtils/Include/*.h",
 		"../DebugUtils/Source/*.cpp"
 	}
@@ -74,12 +74,11 @@ project "Detour"
 		"../Detour/Source/*.cpp" 
 	}
 	-- linux library cflags and libs
-	configuration { "linux", "gmake" }
-		buildoptions { 
+	filter {"system:linux", "action:gmake"}
+		buildoptions {
 			"-Wno-class-memaccess"
 		}
 
-
 project "DetourCrowd"
 	language "C++"
 	kind "StaticLib"
@@ -150,7 +149,7 @@ project "RecastDemo"
 	targetdir "Bin"
 
 	-- linux library cflags and libs
-	configuration { "linux", "gmake" }
+	filter {"system:linux", "action:gmake"}
 		buildoptions { 
 			"`pkg-config --cflags sdl2`",
 			"`pkg-config --cflags gl`",
@@ -166,7 +165,7 @@ project "RecastDemo"
 		}
 
 	-- windows library cflags and libs
-	configuration { "windows" }
+	filter "system:windows"
 		includedirs { "../RecastDemo/Contrib/SDL/include" }
 		libdirs { "../RecastDemo/Contrib/SDL/lib/%{cfg.architecture:gsub('x86_64', 'x64')}" }
 		debugdir "../RecastDemo/Bin/"
@@ -182,7 +181,7 @@ project "RecastDemo"
 		}
 
 	-- mac includes and libs
-	configuration { "macosx" }
+	filter "system:macosx"
 		kind "ConsoleApp" -- xcode4 failes to run the project if using WindowedApp
 		includedirs { "/Library/Frameworks/SDL2.framework/Headers" }
 		links { 
@@ -209,7 +208,7 @@ project "Tests"
 		"../Tests/Recast",
 		"../Tests",
 	}
-	files	{ 
+	files { 
 		"../Tests/*.h",
 		"../Tests/*.hpp",
 		"../Tests/*.cpp",
@@ -232,7 +231,7 @@ project "Tests"
 	targetdir "Bin"
 
 	-- linux library cflags and libs
-	configuration { "linux", "gmake" }
+	filter {"system:linux", "action:gmake"}
 		buildoptions { 
 			"`pkg-config --cflags sdl2`",
 			"`pkg-config --cflags gl`",
@@ -246,7 +245,7 @@ project "Tests"
 		}
 
 	-- windows library cflags and libs
-	configuration { "windows" }
+	filter "system:windows"
 		includedirs { "../RecastDemo/Contrib/SDL/include" }
 		libdirs { "../RecastDemo/Contrib/SDL/lib/%{cfg.architecture:gsub('x86_64', 'x64')}" }
 		debugdir "../RecastDemo/Bin/"
@@ -258,7 +257,7 @@ project "Tests"
 		}
 
 	-- mac includes and libs
-	configuration { "macosx" }
+	filter "system:macosx"
 		kind "ConsoleApp"
 		includedirs { "/Library/Frameworks/SDL2.framework/Headers" }
 		links { 

From 0d1cbd3d6755712325f3c6278542174df5dd9cb8 Mon Sep 17 00:00:00 2001
From: Graham Pentheny <graham.pentheny@gmail.com>
Date: Sun, 16 Oct 2022 11:59:25 -0400
Subject: [PATCH 31/51] Don't explicitly create a GL context since
 SDL_CreateWindowAndRenderer does it internally.

Having two GL contexts causes rendering problems on Ubuntu.  Fixes #521
---
 RecastDemo/Source/main.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/RecastDemo/Source/main.cpp b/RecastDemo/Source/main.cpp
index 270c2af3b..1a31e75fc 100644
--- a/RecastDemo/Source/main.cpp
+++ b/RecastDemo/Source/main.cpp
@@ -127,7 +127,6 @@ int main(int /*argc*/, char** /*argv*/)
 	}
 
 	SDL_SetWindowPosition(window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
-	SDL_GL_CreateContext(window);
 
 	if (!imguiRenderGLInit("DroidSans.ttf"))
 	{

From d576e71b256d8ba853c522d365ff08e2a5e45d76 Mon Sep 17 00:00:00 2001
From: Graham Pentheny <graham.pentheny@gmail.com>
Date: Sat, 29 Oct 2022 13:43:50 -0400
Subject: [PATCH 32/51] Disable class-memaccess error to fix builds on Ubuntu
 with newer versions of GCC

Based on SgtVincent's suggestion here: https://github.com/recastnavigation/recastnavigation/issues/497#issuecomment-1293318731

Fixes #497
---
 RecastDemo/premake5.lua | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/RecastDemo/premake5.lua b/RecastDemo/premake5.lua
index f6fdca6a8..c9a9f23cd 100644
--- a/RecastDemo/premake5.lua
+++ b/RecastDemo/premake5.lua
@@ -76,7 +76,7 @@ project "Detour"
 	-- linux library cflags and libs
 	filter {"system:linux", "action:gmake"}
 		buildoptions {
-			"-Wno-class-memaccess"
+			"-Wno-error=class-memaccess"
 		}
 
 project "DetourCrowd"
@@ -155,7 +155,7 @@ project "RecastDemo"
 			"`pkg-config --cflags gl`",
 			"`pkg-config --cflags glu`",
 			"-Wno-ignored-qualifiers",
-			"-Wno-class-memaccess"
+			"-Wno-error=class-memaccess"
 
 		}
 		linkoptions { 

From 7dfa9849ca4f725991916cccd16a704c4d167b98 Mon Sep 17 00:00:00 2001
From: Graham Pentheny <graham.pentheny@gmail.com>
Date: Sat, 29 Oct 2022 14:13:46 -0400
Subject: [PATCH 33/51] Updated Catch2 testing library to v3.1.1

https://github.com/catchorg/Catch2

Updated tests with new API changes as well.
---
 RecastDemo/premake5.lua                   |     4 +
 Tests/Contrib/Catch/catch_amalgamated.cpp | 10395 +++++++++++++++++
 Tests/Contrib/Catch/catch_amalgamated.hpp | 12260 ++++++++++++++++++++
 Tests/Detour/Tests_Detour.cpp             |    20 +-
 Tests/Recast/Tests_Recast.cpp             |   150 +-
 Tests/catch.hpp                           | 11689 -------------------
 Tests/main.cpp                            |     2 +-
 7 files changed, 22745 insertions(+), 11775 deletions(-)
 create mode 100644 Tests/Contrib/Catch/catch_amalgamated.cpp
 create mode 100644 Tests/Contrib/Catch/catch_amalgamated.hpp
 delete mode 100644 Tests/catch.hpp

diff --git a/RecastDemo/premake5.lua b/RecastDemo/premake5.lua
index c9a9f23cd..08a2dbbda 100644
--- a/RecastDemo/premake5.lua
+++ b/RecastDemo/premake5.lua
@@ -19,6 +19,7 @@ workspace "recastnavigation"
 	rtti "Off"
 	symbols "On"
 	flags { "FatalCompileWarnings" }
+	cppdialect "C++98"
 
 	-- debug configs
 	filter "configurations:Debug"
@@ -193,6 +194,7 @@ project "RecastDemo"
 project "Tests"
 	language "C++"
 	kind "ConsoleApp"
+	cppdialect "C++20" -- Catch requires newer C++ features
 
 	-- Catch requires RTTI and exceptions
 	exceptionhandling "On"
@@ -207,6 +209,7 @@ project "Tests"
 		"../Recast/Source",
 		"../Tests/Recast",
 		"../Tests",
+		"../Tests/Contrib/Catch"
 	}
 	files { 
 		"../Tests/*.h",
@@ -216,6 +219,7 @@ project "Tests"
 		"../Tests/Recast/*.cpp",
 		"../Tests/Detour/*.h",
 		"../Tests/Detour/*.cpp",
+		"../Tests/Contrib/Catch/*.cpp"
 	}
 
 	-- project dependencies
diff --git a/Tests/Contrib/Catch/catch_amalgamated.cpp b/Tests/Contrib/Catch/catch_amalgamated.cpp
new file mode 100644
index 000000000..1f5527a43
--- /dev/null
+++ b/Tests/Contrib/Catch/catch_amalgamated.cpp
@@ -0,0 +1,10395 @@
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+//  Catch v3.1.1
+//  Generated: 2022-10-17 18:47:22.400176
+//  ----------------------------------------------------------
+//  This file is an amalgamation of multiple different files.
+//  You probably shouldn't edit it directly.
+//  ----------------------------------------------------------
+
+#include "catch_amalgamated.hpp"
+
+
+#ifndef CATCH_WINDOWS_H_PROXY_HPP_INCLUDED
+#define CATCH_WINDOWS_H_PROXY_HPP_INCLUDED
+
+
+#if defined(CATCH_PLATFORM_WINDOWS)
+
+// We might end up with the define made globally through the compiler,
+// and we don't want to trigger warnings for this
+#if !defined(NOMINMAX)
+#  define NOMINMAX
+#endif
+#if !defined(WIN32_LEAN_AND_MEAN)
+#  define WIN32_LEAN_AND_MEAN
+#endif
+
+#include <windows.h>
+
+#endif // defined(CATCH_PLATFORM_WINDOWS)
+
+#endif // CATCH_WINDOWS_H_PROXY_HPP_INCLUDED
+
+
+
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            ChronometerConcept::~ChronometerConcept() = default;
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+
+
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            BenchmarkFunction::callable::~callable() = default;
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+
+
+#include <exception>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            struct optimized_away_error : std::exception {
+                const char* what() const noexcept override;
+            };
+
+            const char* optimized_away_error::what() const noexcept {
+                return "could not measure benchmark, maybe it was optimized away";
+            }
+
+            void throw_optimized_away_error() {
+                Catch::throw_exception(optimized_away_error{});
+            }
+
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+
+// Adapted from donated nonius code.
+
+
+
+#include <cassert>
+#include <cstddef>
+#include <iterator>
+#include <random>
+
+
+#if defined(CATCH_CONFIG_USE_ASYNC)
+#include <future>
+#endif
+
+namespace {
+
+using Catch::Benchmark::Detail::sample;
+
+     template <typename URng, typename Estimator>
+     sample resample(URng& rng, unsigned int resamples, std::vector<double>::iterator first, std::vector<double>::iterator last, Estimator& estimator) {
+         auto n = static_cast<size_t>(last - first);
+         std::uniform_int_distribution<decltype(n)> dist(0, n - 1);
+
+         sample out;
+         out.reserve(resamples);
+         std::generate_n(std::back_inserter(out), resamples, [n, first, &estimator, &dist, &rng] {
+             std::vector<double> resampled;
+             resampled.reserve(n);
+             std::generate_n(std::back_inserter(resampled), n, [first, &dist, &rng] { return first[static_cast<std::ptrdiff_t>(dist(rng))]; });
+             return estimator(resampled.begin(), resampled.end());
+         });
+         std::sort(out.begin(), out.end());
+         return out;
+     }
+
+
+    double erf_inv(double x) {
+        // Code accompanying the article "Approximating the erfinv function" in GPU Computing Gems, Volume 2
+        double w, p;
+
+        w = -log((1.0 - x) * (1.0 + x));
+
+        if (w < 6.250000) {
+            w = w - 3.125000;
+            p = -3.6444120640178196996e-21;
+            p = -1.685059138182016589e-19 + p * w;
+            p = 1.2858480715256400167e-18 + p * w;
+            p = 1.115787767802518096e-17 + p * w;
+            p = -1.333171662854620906e-16 + p * w;
+            p = 2.0972767875968561637e-17 + p * w;
+            p = 6.6376381343583238325e-15 + p * w;
+            p = -4.0545662729752068639e-14 + p * w;
+            p = -8.1519341976054721522e-14 + p * w;
+            p = 2.6335093153082322977e-12 + p * w;
+            p = -1.2975133253453532498e-11 + p * w;
+            p = -5.4154120542946279317e-11 + p * w;
+            p = 1.051212273321532285e-09 + p * w;
+            p = -4.1126339803469836976e-09 + p * w;
+            p = -2.9070369957882005086e-08 + p * w;
+            p = 4.2347877827932403518e-07 + p * w;
+            p = -1.3654692000834678645e-06 + p * w;
+            p = -1.3882523362786468719e-05 + p * w;
+            p = 0.0001867342080340571352 + p * w;
+            p = -0.00074070253416626697512 + p * w;
+            p = -0.0060336708714301490533 + p * w;
+            p = 0.24015818242558961693 + p * w;
+            p = 1.6536545626831027356 + p * w;
+        } else if (w < 16.000000) {
+            w = sqrt(w) - 3.250000;
+            p = 2.2137376921775787049e-09;
+            p = 9.0756561938885390979e-08 + p * w;
+            p = -2.7517406297064545428e-07 + p * w;
+            p = 1.8239629214389227755e-08 + p * w;
+            p = 1.5027403968909827627e-06 + p * w;
+            p = -4.013867526981545969e-06 + p * w;
+            p = 2.9234449089955446044e-06 + p * w;
+            p = 1.2475304481671778723e-05 + p * w;
+            p = -4.7318229009055733981e-05 + p * w;
+            p = 6.8284851459573175448e-05 + p * w;
+            p = 2.4031110387097893999e-05 + p * w;
+            p = -0.0003550375203628474796 + p * w;
+            p = 0.00095328937973738049703 + p * w;
+            p = -0.0016882755560235047313 + p * w;
+            p = 0.0024914420961078508066 + p * w;
+            p = -0.0037512085075692412107 + p * w;
+            p = 0.005370914553590063617 + p * w;
+            p = 1.0052589676941592334 + p * w;
+            p = 3.0838856104922207635 + p * w;
+        } else {
+            w = sqrt(w) - 5.000000;
+            p = -2.7109920616438573243e-11;
+            p = -2.5556418169965252055e-10 + p * w;
+            p = 1.5076572693500548083e-09 + p * w;
+            p = -3.7894654401267369937e-09 + p * w;
+            p = 7.6157012080783393804e-09 + p * w;
+            p = -1.4960026627149240478e-08 + p * w;
+            p = 2.9147953450901080826e-08 + p * w;
+            p = -6.7711997758452339498e-08 + p * w;
+            p = 2.2900482228026654717e-07 + p * w;
+            p = -9.9298272942317002539e-07 + p * w;
+            p = 4.5260625972231537039e-06 + p * w;
+            p = -1.9681778105531670567e-05 + p * w;
+            p = 7.5995277030017761139e-05 + p * w;
+            p = -0.00021503011930044477347 + p * w;
+            p = -0.00013871931833623122026 + p * w;
+            p = 1.0103004648645343977 + p * w;
+            p = 4.8499064014085844221 + p * w;
+        }
+        return p * x;
+    }
+
+    double standard_deviation(std::vector<double>::iterator first, std::vector<double>::iterator last) {
+        auto m = Catch::Benchmark::Detail::mean(first, last);
+        double variance = std::accumulate( first,
+                                           last,
+                                           0.,
+                                           [m]( double a, double b ) {
+                                               double diff = b - m;
+                                               return a + diff * diff;
+                                           } ) /
+                          ( last - first );
+        return std::sqrt( variance );
+    }
+
+}
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+
+#if defined( __GNUC__ ) || defined( __clang__ )
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+            bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
+#if defined( __GNUC__ ) || defined( __clang__ )
+#    pragma GCC diagnostic pop
+#endif
+
+            double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last) {
+                auto count = last - first;
+                double idx = (count - 1) * k / static_cast<double>(q);
+                int j = static_cast<int>(idx);
+                double g = idx - j;
+                std::nth_element(first, first + j, last);
+                auto xj = first[j];
+                if ( directCompare( g, 0 ) ) {
+                    return xj;
+                }
+
+                auto xj1 = *std::min_element(first + (j + 1), last);
+                return xj + g * (xj1 - xj);
+            }
+
+
+            double erfc_inv(double x) {
+                return erf_inv(1.0 - x);
+            }
+
+            double normal_quantile(double p) {
+                static const double ROOT_TWO = std::sqrt(2.0);
+
+                double result = 0.0;
+                assert(p >= 0 && p <= 1);
+                if (p < 0 || p > 1) {
+                    return result;
+                }
+
+                result = -erfc_inv(2.0 * p);
+                // result *= normal distribution standard deviation (1.0) * sqrt(2)
+                result *= /*sd * */ ROOT_TWO;
+                // result += normal disttribution mean (0)
+                return result;
+            }
+
+
+            double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n) {
+                double sb = stddev.point;
+                double mn = mean.point / n;
+                double mg_min = mn / 2.;
+                double sg = (std::min)(mg_min / 4., sb / std::sqrt(n));
+                double sg2 = sg * sg;
+                double sb2 = sb * sb;
+
+                auto c_max = [n, mn, sb2, sg2](double x) -> double {
+                    double k = mn - x;
+                    double d = k * k;
+                    double nd = n * d;
+                    double k0 = -n * nd;
+                    double k1 = sb2 - n * sg2 + nd;
+                    double det = k1 * k1 - 4 * sg2 * k0;
+                    return static_cast<int>(-2. * k0 / (k1 + std::sqrt(det)));
+                };
+
+                auto var_out = [n, sb2, sg2](double c) {
+                    double nc = n - c;
+                    return (nc / n) * (sb2 - nc * sg2);
+                };
+
+                return (std::min)(var_out(1), var_out((std::min)(c_max(0.), c_max(mg_min)))) / sb2;
+            }
+
+
+            bootstrap_analysis analyse_samples(double confidence_level, unsigned int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last) {
+                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
+                CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+                static std::random_device entropy;
+                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+                auto n = static_cast<int>(last - first); // seriously, one can't use integral types without hell in C++
+
+                auto mean = &Detail::mean<std::vector<double>::iterator>;
+                auto stddev = &standard_deviation;
+
+#if defined(CATCH_CONFIG_USE_ASYNC)
+                auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
+                    auto seed = entropy();
+                    return std::async(std::launch::async, [=] {
+                        std::mt19937 rng(seed);
+                        auto resampled = resample(rng, n_resamples, first, last, f);
+                        return bootstrap(confidence_level, first, last, resampled, f);
+                    });
+                };
+
+                auto mean_future = Estimate(mean);
+                auto stddev_future = Estimate(stddev);
+
+                auto mean_estimate = mean_future.get();
+                auto stddev_estimate = stddev_future.get();
+#else
+                auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
+                    auto seed = entropy();
+                    std::mt19937 rng(seed);
+                    auto resampled = resample(rng, n_resamples, first, last, f);
+                    return bootstrap(confidence_level, first, last, resampled, f);
+                };
+
+                auto mean_estimate = Estimate(mean);
+                auto stddev_estimate = Estimate(stddev);
+#endif // CATCH_USE_ASYNC
+
+                double outlier_variance = Detail::outlier_variance(mean_estimate, stddev_estimate, n);
+
+                return { mean_estimate, stddev_estimate, outlier_variance };
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+
+
+#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 {
+
+    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(std::isinf(m_value)? 0 : m_value)));
+    }
+
+    void Approx::setMargin(double newMargin) {
+        CATCH_ENFORCE(newMargin >= 0,
+            "Invalid Approx::margin: " << newMargin << '.'
+            << " Approx::Margin has to be non-negative.");
+        m_margin = newMargin;
+    }
+
+    void Approx::setEpsilon(double newEpsilon) {
+        CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0,
+            "Invalid Approx::epsilon: " << newEpsilon << '.'
+            << " Approx::epsilon has to be in [0, 1]");
+        m_epsilon = newEpsilon;
+    }
+
+namespace literals {
+    Approx operator "" _a(long double val) {
+        return Approx(val);
+    }
+    Approx operator "" _a(unsigned long long val) {
+        return Approx(val);
+    }
+} // end namespace literals
+
+std::string StringMaker<Catch::Approx>::convert(Catch::Approx const& value) {
+    return value.toString();
+}
+
+} // end namespace Catch
+
+
+
+namespace Catch {
+
+    AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const & _lazyExpression):
+        lazyExpression(_lazyExpression),
+        resultType(_resultType) {}
+
+    std::string AssertionResultData::reconstructExpression() const {
+
+        if( reconstructedExpression.empty() ) {
+            if( lazyExpression ) {
+                ReusableStringStream rss;
+                rss << lazyExpression;
+                reconstructedExpression = rss.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.empty();
+    }
+
+    bool AssertionResult::hasMessage() const {
+        return !m_resultData.message.empty();
+    }
+
+    std::string AssertionResult::getExpression() const {
+        // Possibly overallocating by 3 characters should be basically free
+        std::string expr; expr.reserve(m_info.capturedExpression.size() + 3);
+        if (isFalseTest(m_info.resultDisposition)) {
+            expr += "!(";
+        }
+        expr += m_info.capturedExpression;
+        if (isFalseTest(m_info.resultDisposition)) {
+            expr += ')';
+        }
+        return expr;
+    }
+
+    std::string AssertionResult::getExpressionInMacro() const {
+        std::string expr;
+        if( m_info.macroName.empty() )
+            expr = static_cast<std::string>(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;
+    }
+
+    StringRef AssertionResult::getMessage() const {
+        return m_resultData.message;
+    }
+    SourceLineInfo AssertionResult::getSourceInfo() const {
+        return m_info.lineInfo;
+    }
+
+    StringRef AssertionResult::getTestMacroName() const {
+        return m_info.macroName;
+    }
+
+} // end namespace Catch
+
+
+
+namespace {
+    bool provideBazelReporterOutput() {
+#if defined(CATCH_CONFIG_BAZEL_SUPPORT)
+        return true;
+#elif defined(CATCH_PLATFORM_WINDOWS_UWP)
+        // UWP does not support environment variables
+        return false;
+#else
+
+#    if defined( _MSC_VER )
+        // On Windows getenv throws a warning as there is no input validation,
+        // since the switch is hardcoded, this should not be an issue.
+#        pragma warning( push )
+#        pragma warning( disable : 4996 )
+#    endif
+
+        return std::getenv( "BAZEL_TEST" ) != nullptr;
+
+#    if defined( _MSC_VER )
+#        pragma warning( pop )
+#    endif
+#endif
+    }
+}
+
+namespace Catch {
+
+    bool operator==( ProcessedReporterSpec const& lhs,
+                     ProcessedReporterSpec const& rhs ) {
+        return lhs.name == rhs.name &&
+               lhs.outputFilename == rhs.outputFilename &&
+               lhs.colourMode == rhs.colourMode &&
+               lhs.customOptions == rhs.customOptions;
+    }
+
+    Config::Config( ConfigData const& data ):
+        m_data( data ) {
+        // We need to trim filter specs to avoid trouble with superfluous
+        // whitespace (esp. important for bdd macros, as those are manually
+        // aligned with whitespace).
+
+        for (auto& elem : m_data.testsOrTags) {
+            elem = trim(elem);
+        }
+        for (auto& elem : m_data.sectionsToRun) {
+            elem = trim(elem);
+        }
+
+
+        TestSpecParser parser(ITagAliasRegistry::get());
+        if (!m_data.testsOrTags.empty()) {
+            m_hasTestFilters = true;
+            for (auto const& testOrTags : m_data.testsOrTags) {
+                parser.parse(testOrTags);
+            }
+        }
+        m_testSpec = parser.testSpec();
+
+
+        // Insert the default reporter if user hasn't asked for a specfic one
+        if ( m_data.reporterSpecifications.empty() ) {
+            m_data.reporterSpecifications.push_back( {
+#if defined( CATCH_CONFIG_DEFAULT_REPORTER )
+                CATCH_CONFIG_DEFAULT_REPORTER,
+#else
+                "console",
+#endif
+                {}, {}, {}
+            } );
+        }
+
+#if !defined(CATCH_PLATFORM_WINDOWS_UWP)
+    if(provideBazelReporterOutput()){
+            // Register a JUnit reporter for Bazel. Bazel sets an environment
+            // variable with the path to XML output. If this file is written to
+            // during test, Bazel will not generate a default XML output.
+            // This allows the XML output file to contain higher level of detail
+            // than what is possible otherwise.
+#    if defined( _MSC_VER )
+            // On Windows getenv throws a warning as there is no input validation,
+            // since the key is hardcoded, this should not be an issue.
+#           pragma warning( push )
+#           pragma warning( disable : 4996 )
+#    endif
+            const auto bazelOutputFilePtr = std::getenv( "XML_OUTPUT_FILE" );
+#    if defined( _MSC_VER )
+#        pragma warning( pop )
+#    endif
+            if ( bazelOutputFilePtr != nullptr ) {
+                m_data.reporterSpecifications.push_back(
+                    { "junit", std::string( bazelOutputFilePtr ), {}, {} } );
+            }
+    }
+#endif
+
+        // We now fixup the reporter specs to handle default output spec,
+        // default colour spec, etc
+        bool defaultOutputUsed = false;
+        for ( auto const& reporterSpec : m_data.reporterSpecifications ) {
+            // We do the default-output check separately, while always
+            // using the default output below to make the code simpler
+            // and avoid superfluous copies.
+            if ( reporterSpec.outputFile().none() ) {
+                CATCH_ENFORCE( !defaultOutputUsed,
+                               "Internal error: cannot use default output for "
+                               "multiple reporters" );
+                defaultOutputUsed = true;
+            }
+
+            m_processedReporterSpecs.push_back( ProcessedReporterSpec{
+                reporterSpec.name(),
+                reporterSpec.outputFile() ? *reporterSpec.outputFile()
+                                          : data.defaultOutputFilename,
+                reporterSpec.colourMode().valueOr( data.defaultColourMode ),
+                reporterSpec.customOptions() } );
+        }
+    }
+
+    Config::~Config() = default;
+
+
+    bool Config::listTests() const          { return m_data.listTests; }
+    bool Config::listTags() const           { return m_data.listTags; }
+    bool Config::listReporters() const      { return m_data.listReporters; }
+    bool Config::listListeners() const      { return m_data.listListeners; }
+
+    std::vector<std::string> const& Config::getTestsOrTags() const { return m_data.testsOrTags; }
+    std::vector<std::string> const& Config::getSectionsToRun() const { return m_data.sectionsToRun; }
+
+    std::vector<ReporterSpec> const& Config::getReporterSpecs() const {
+        return m_data.reporterSpecifications;
+    }
+
+    std::vector<ProcessedReporterSpec> const&
+    Config::getProcessedReporterSpecs() const {
+        return m_processedReporterSpecs;
+    }
+
+    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; }
+    StringRef 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::warnAboutUnmatchedTestSpecs() const {
+        return !!( m_data.warnings & WarnAbout::UnmatchedTestSpec );
+    }
+    bool Config::zeroTestsCountAsSuccess() const       { return m_data.allowZeroTests; }
+    ShowDurations Config::showDurations() const        { return m_data.showDurations; }
+    double Config::minDuration() const                 { return m_data.minDuration; }
+    TestRunOrder Config::runOrder() const              { return m_data.runOrder; }
+    uint32_t Config::rngSeed() const                   { return m_data.rngSeed; }
+    unsigned int Config::shardCount() const            { return m_data.shardCount; }
+    unsigned int Config::shardIndex() const            { return m_data.shardIndex; }
+    ColourMode Config::defaultColourMode() const       { return m_data.defaultColourMode; }
+    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; }
+
+    bool Config::skipBenchmarks() const                           { return m_data.skipBenchmarks; }
+    bool Config::benchmarkNoAnalysis() const                      { return m_data.benchmarkNoAnalysis; }
+    unsigned int Config::benchmarkSamples() const                 { return m_data.benchmarkSamples; }
+    double Config::benchmarkConfidenceInterval() const            { return m_data.benchmarkConfidenceInterval; }
+    unsigned int Config::benchmarkResamples() const               { return m_data.benchmarkResamples; }
+    std::chrono::milliseconds Config::benchmarkWarmupTime() const { return std::chrono::milliseconds(m_data.benchmarkWarmupTime); }
+
+} // end namespace Catch
+
+
+
+
+
+namespace Catch {
+    std::uint32_t getSeed() {
+        return getCurrentContext().getConfig()->rngSeed();
+    }
+}
+
+
+
+#include <cassert>
+#include <stack>
+
+namespace Catch {
+
+    ////////////////////////////////////////////////////////////////////////////
+
+
+    ScopedMessage::ScopedMessage( MessageBuilder const& builder ):
+        m_info( builder.m_info ) {
+        m_info.message = builder.m_stream.str();
+        getResultCapture().pushScopedMessage( m_info );
+    }
+
+    ScopedMessage::ScopedMessage( ScopedMessage&& old ) noexcept:
+        m_info( CATCH_MOVE( old.m_info ) ) {
+        old.m_moved = true;
+    }
+
+    ScopedMessage::~ScopedMessage() {
+        if ( !uncaught_exceptions() && !m_moved ){
+            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(static_cast<unsigned char>(names[start]))) {
+                ++start;
+            }
+            while (names[end] == ',' || isspace(static_cast<unsigned char>(names[end]))) {
+                --end;
+            }
+            return names.substr(start, end - start + 1);
+        };
+        auto skipq = [&] (size_t start, char quote) {
+            for (auto i = start + 1; i < names.size() ; ++i) {
+                if (names[i] == quote)
+                    return i;
+                if (names[i] == '\\')
+                    ++i;
+            }
+            CATCH_INTERNAL_ERROR("CAPTURE parsing encountered unmatched quote");
+        };
+
+        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 '"':
+            case '\'':
+                pos = skipq(pos, c);
+                break;
+            case ',':
+                if (start != pos && openings.empty()) {
+                    m_messages.emplace_back(macroName, lineInfo, resultType);
+                    m_messages.back().message = static_cast<std::string>(trimmed(start, pos));
+                    m_messages.back().message += " := ";
+                    start = pos;
+                }
+            }
+        }
+        assert(openings.empty() && "Mismatched openings");
+        m_messages.emplace_back(macroName, lineInfo, resultType);
+        m_messages.back().message = static_cast<std::string>(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
+
+
+
+
+namespace Catch {
+
+    namespace {
+
+        class RegistryHub : public IRegistryHub,
+                            public IMutableRegistryHub,
+                            private Detail::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 factory ) override {
+                m_reporterRegistry.registerReporter( name, CATCH_MOVE(factory) );
+            }
+            void registerListener( Detail::unique_ptr<EventListenerFactory> factory ) override {
+                m_reporterRegistry.registerListener( CATCH_MOVE(factory) );
+            }
+            void registerTest( Detail::unique_ptr<TestCaseInfo>&& testInfo, Detail::unique_ptr<ITestInvoker>&& invoker ) override {
+                m_testCaseRegistry.registerTest( CATCH_MOVE(testInfo), CATCH_MOVE(invoker) );
+            }
+            void registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator ) override {
+                m_exceptionTranslatorRegistry.registerTranslator( CATCH_MOVE(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 {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+                m_exceptionRegistry.add(std::current_exception());
+#else
+                CATCH_INTERNAL_ERROR("Attempted to register active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
+#endif
+            }
+            IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() override {
+                return m_enumValuesRegistry;
+            }
+
+        private:
+            TestRegistry m_testCaseRegistry;
+            ReporterRegistry m_reporterRegistry;
+            ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
+            TagAliasRegistry m_tagAliasRegistry;
+            StartupExceptionRegistry m_exceptionRegistry;
+            Detail::EnumValuesRegistry m_enumValuesRegistry;
+        };
+    }
+
+    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
+
+
+
+#include <algorithm>
+#include <cassert>
+#include <iomanip>
+#include <set>
+
+namespace Catch {
+
+    namespace {
+        const int MaxExitCode = 255;
+
+        IEventListenerPtr createReporter(std::string const& reporterName, ReporterConfig&& config) {
+            auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, CATCH_MOVE(config));
+            CATCH_ENFORCE(reporter, "No reporter registered with name: '" << reporterName << '\'');
+
+            return reporter;
+        }
+
+        IEventListenerPtr prepareReporters(Config const* config) {
+            if (Catch::getRegistryHub().getReporterRegistry().getListeners().empty()
+                    && config->getProcessedReporterSpecs().size() == 1) {
+                auto const& spec = config->getProcessedReporterSpecs()[0];
+                return createReporter(
+                    spec.name,
+                    ReporterConfig( config,
+                                    makeStream( spec.outputFilename ),
+                                    spec.colourMode,
+                                    spec.customOptions ) );
+            }
+
+            auto multi = Detail::make_unique<MultiReporter>(config);
+
+            auto const& listeners = Catch::getRegistryHub().getReporterRegistry().getListeners();
+            for (auto const& listener : listeners) {
+                multi->addListener(listener->create(config));
+            }
+
+            for ( auto const& reporterSpec : config->getProcessedReporterSpecs() ) {
+                multi->addReporter( createReporter(
+                    reporterSpec.name,
+                    ReporterConfig( config,
+                                    makeStream( reporterSpec.outputFilename ),
+                                    reporterSpec.colourMode,
+                                    reporterSpec.customOptions ) ) );
+            }
+
+            return multi;
+        }
+
+        class TestGroup {
+        public:
+            explicit TestGroup(IEventListenerPtr&& reporter, Config const* config):
+                m_reporter(reporter.get()),
+                m_config{config},
+                m_context{config, CATCH_MOVE(reporter)} {
+
+                assert( m_config->testSpec().getInvalidSpecs().empty() &&
+                        "Invalid test specs should be handled before running tests" );
+
+                auto const& allTestCases = getAllTestCasesSorted(*m_config);
+                auto const& testSpec = m_config->testSpec();
+                if ( !testSpec.hasFilters() ) {
+                    for ( auto const& test : allTestCases ) {
+                        if ( !test.getTestCaseInfo().isHidden() ) {
+                            m_tests.emplace( &test );
+                        }
+                    }
+                } else {
+                    m_matches =
+                        testSpec.matchesByFilter( allTestCases, *m_config );
+                    for ( auto const& match : m_matches ) {
+                        m_tests.insert( match.tests.begin(),
+                                        match.tests.end() );
+                    }
+                }
+
+                m_tests = createShard(m_tests, m_config->shardCount(), m_config->shardIndex());
+            }
+
+            Totals execute() {
+                Totals totals;
+                for (auto const& testCase : m_tests) {
+                    if (!m_context.aborting())
+                        totals += m_context.runTest(*testCase);
+                    else
+                        m_reporter->skipTest(testCase->getTestCaseInfo());
+                }
+
+                for (auto const& match : m_matches) {
+                    if (match.tests.empty()) {
+                        m_unmatchedTestSpecs = true;
+                        m_reporter->noMatchingTestCases( match.name );
+                    }
+                }
+
+                return totals;
+            }
+
+            bool hadUnmatchedTestSpecs() const {
+                return m_unmatchedTestSpecs;
+            }
+
+
+        private:
+            IEventListener* m_reporter;
+            Config const* m_config;
+            RunContext m_context;
+            std::set<TestCaseHandle const*> m_tests;
+            TestSpec::Matches m_matches;
+            bool m_unmatchedTestSpecs = false;
+        };
+
+        void applyFilenamesAsTags() {
+            for (auto const& testInfo : getRegistryHub().getTestCaseRegistry().getAllInfos()) {
+                testInfo->addFilenameTag();
+            }
+        }
+
+    } // 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() ) {
+            config();
+            getCurrentMutableContext().setConfig(m_config.get());
+
+            m_startupExceptions = true;
+            auto errStream = makeStream( "%stderr" );
+            auto colourImpl = makeColourImpl(
+                ColourMode::PlatformDefault, errStream.get() );
+            auto guard = colourImpl->guardColour( Colour::Red );
+            errStream->stream() << "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 ) {
+                    errStream->stream() << TextFlow::Column( ex.what() ).indent(2) << '\n';
+                }
+            }
+        }
+#endif
+
+        alreadyInstantiated = true;
+        m_cli = makeCommandLineParser( m_configData );
+    }
+    Session::~Session() {
+        Catch::cleanUp();
+    }
+
+    void Session::showHelp() const {
+        Catch::cout()
+                << "\nCatch2 v" << libraryVersion() << '\n'
+                << m_cli << '\n'
+                << "For more detailed usage please see the project docs\n\n" << std::flush;
+    }
+    void Session::libIdentify() {
+        Catch::cout()
+                << std::left << std::setw(16) << "description: " << "A Catch2 test executable\n"
+                << std::left << std::setw(16) << "category: " << "testframework\n"
+                << std::left << std::setw(16) << "framework: " << "Catch2\n"
+                << std::left << std::setw(16) << "version: " << libraryVersion() << '\n' << std::flush;
+    }
+
+    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 ) {
+            config();
+            getCurrentMutableContext().setConfig(m_config.get());
+            auto errStream = makeStream( "%stderr" );
+            auto colour = makeColourImpl( ColourMode::PlatformDefault, errStream.get() );
+
+            errStream->stream()
+                << colour->guardColour( Colour::Red )
+                << "\nError(s) in input:\n"
+                << TextFlow::Column( result.errorMessage() ).indent( 2 )
+                << "\n\n";
+            errStream->stream() << "Run with -? for usage\n\n" << std::flush;
+            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, nullptr, 0, nullptr, nullptr );
+
+            utf8Argv[ i ] = new char[ bufSize ];
+
+            WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, nullptr, nullptr );
+        }
+
+        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\n" << std::flush;
+            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 << '\n' << std::flush;
+            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 = Detail::make_unique<Config>( m_configData );
+        return *m_config;
+    }
+
+    int Session::runInternal() {
+        if( m_startupExceptions )
+            return 1;
+
+        if (m_configData.showHelp || m_configData.libIdentify) {
+            return 0;
+        }
+
+        if ( m_configData.shardIndex >= m_configData.shardCount ) {
+            Catch::cerr() << "The shard count (" << m_configData.shardCount
+                          << ") must be greater than the shard index ("
+                          << m_configData.shardIndex << ")\n"
+                          << std::flush;
+            return 1;
+        }
+
+        CATCH_TRY {
+            config(); // Force config to be constructed
+
+            seedRng( *m_config );
+
+            if (m_configData.filenamesAsTags) {
+                applyFilenamesAsTags();
+            }
+
+            // Set up global config instance before we start calling into other functions
+            getCurrentMutableContext().setConfig(m_config.get());
+
+            // Create reporter(s) so we can route listings through them
+            auto reporter = prepareReporters(m_config.get());
+
+            auto const& invalidSpecs = m_config->testSpec().getInvalidSpecs();
+            if ( !invalidSpecs.empty() ) {
+                for ( auto const& spec : invalidSpecs ) {
+                    reporter->reportInvalidTestSpec( spec );
+                }
+                return 1;
+            }
+
+
+            // Handle list request
+            if (list(*reporter, *m_config)) {
+                return 0;
+            }
+
+            TestGroup tests { CATCH_MOVE(reporter), m_config.get() };
+            auto const totals = tests.execute();
+
+            if ( tests.hadUnmatchedTestSpecs()
+                && m_config->warnAboutUnmatchedTestSpecs() ) {
+                return 3;
+            }
+
+            if ( totals.testCases.total() == 0
+                && !m_config->zeroTestsCountAsSuccess() ) {
+                return 2;
+            }
+
+            // 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, static_cast<int>(totals.assertions.failed));
+        }
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+        catch( std::exception& ex ) {
+            Catch::cerr() << ex.what() << '\n' << std::flush;
+            return MaxExitCode;
+        }
+#endif
+    }
+
+} // end namespace Catch
+
+
+
+
+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();
+        }
+    }
+
+}
+
+
+
+#include <cassert>
+#include <cctype>
+#include <algorithm>
+
+namespace Catch {
+
+    namespace {
+        using TCP_underlying_type = uint8_t;
+        static_assert(sizeof(TestCaseProperties) == sizeof(TCP_underlying_type),
+                      "The size of the TestCaseProperties is different from the assumed size");
+
+        TestCaseProperties operator|(TestCaseProperties lhs, TestCaseProperties rhs) {
+            return static_cast<TestCaseProperties>(
+                static_cast<TCP_underlying_type>(lhs) | static_cast<TCP_underlying_type>(rhs)
+            );
+        }
+
+        TestCaseProperties& operator|=(TestCaseProperties& lhs, TestCaseProperties rhs) {
+            lhs = static_cast<TestCaseProperties>(
+                static_cast<TCP_underlying_type>(lhs) | static_cast<TCP_underlying_type>(rhs)
+            );
+            return lhs;
+        }
+
+        TestCaseProperties operator&(TestCaseProperties lhs, TestCaseProperties rhs) {
+            return static_cast<TestCaseProperties>(
+                static_cast<TCP_underlying_type>(lhs) & static_cast<TCP_underlying_type>(rhs)
+            );
+        }
+
+        bool applies(TestCaseProperties tcp) {
+            static_assert(static_cast<TCP_underlying_type>(TestCaseProperties::None) == 0,
+                          "TestCaseProperties::None must be equal to 0");
+            return tcp != TestCaseProperties::None;
+        }
+
+        TestCaseProperties parseSpecialTag( StringRef tag ) {
+            if( !tag.empty() && tag[0] == '.' )
+                return TestCaseProperties::IsHidden;
+            else if( tag == "!throws"_sr )
+                return TestCaseProperties::Throws;
+            else if( tag == "!shouldfail"_sr )
+                return TestCaseProperties::ShouldFail;
+            else if( tag == "!mayfail"_sr )
+                return TestCaseProperties::MayFail;
+            else if( tag == "!nonportable"_sr )
+                return TestCaseProperties::NonPortable;
+            else if( tag == "!benchmark"_sr )
+                return TestCaseProperties::Benchmark | TestCaseProperties::IsHidden;
+            else
+                return TestCaseProperties::None;
+        }
+        bool isReservedTag( StringRef tag ) {
+            return parseSpecialTag( tag ) == TestCaseProperties::None
+                && tag.size() > 0
+                && !std::isalnum( static_cast<unsigned char>(tag[0]) );
+        }
+        void enforceNotReservedTag( StringRef tag, SourceLineInfo const& _lineInfo ) {
+            CATCH_ENFORCE( !isReservedTag(tag),
+                          "Tag name: [" << tag << "] is not allowed.\n"
+                          << "Tag names starting with non alphanumeric characters are reserved\n"
+                          << _lineInfo );
+        }
+
+        std::string makeDefaultName() {
+            static size_t counter = 0;
+            return "Anonymous test case " + std::to_string(++counter);
+        }
+
+        StringRef extractFilenamePart(StringRef filename) {
+            size_t lastDot = filename.size();
+            while (lastDot > 0 && filename[lastDot - 1] != '.') {
+                --lastDot;
+            }
+            --lastDot;
+
+            size_t nameStart = lastDot;
+            while (nameStart > 0 && filename[nameStart - 1] != '/' && filename[nameStart - 1] != '\\') {
+                --nameStart;
+            }
+
+            return filename.substr(nameStart, lastDot - nameStart);
+        }
+
+        // Returns the upper bound on size of extra tags ([#file]+[.])
+        size_t sizeOfExtraTags(StringRef filepath) {
+            // [.] is 3, [#] is another 3
+            const size_t extras = 3 + 3;
+            return extractFilenamePart(filepath).size() + extras;
+        }
+    } // end unnamed namespace
+
+    bool operator<(  Tag const& lhs, Tag const& rhs ) {
+        Detail::CaseInsensitiveLess cmp;
+        return cmp( lhs.original, rhs.original );
+    }
+    bool operator==( Tag const& lhs, Tag const& rhs ) {
+        Detail::CaseInsensitiveEqualTo cmp;
+        return cmp( lhs.original, rhs.original );
+    }
+
+    Detail::unique_ptr<TestCaseInfo>
+        makeTestCaseInfo(StringRef _className,
+                         NameAndTags const& nameAndTags,
+                         SourceLineInfo const& _lineInfo ) {
+        return Detail::make_unique<TestCaseInfo>(_className, nameAndTags, _lineInfo);
+    }
+
+    TestCaseInfo::TestCaseInfo(StringRef _className,
+                               NameAndTags const& _nameAndTags,
+                               SourceLineInfo const& _lineInfo):
+        name( _nameAndTags.name.empty() ? makeDefaultName() : _nameAndTags.name ),
+        className( _className ),
+        lineInfo( _lineInfo )
+    {
+        StringRef originalTags = _nameAndTags.tags;
+        // We need to reserve enough space to store all of the tags
+        // (including optional hidden tag and filename tag)
+        auto requiredSize = originalTags.size() + sizeOfExtraTags(_lineInfo.file);
+        backingTags.reserve(requiredSize);
+
+        // We cannot copy the tags directly, as we need to normalize
+        // some tags, so that [.foo] is copied as [.][foo].
+        size_t tagStart = 0;
+        size_t tagEnd = 0;
+        bool inTag = false;
+        for (size_t idx = 0; idx < originalTags.size(); ++idx) {
+            auto c = originalTags[idx];
+            if (c == '[') {
+                assert(!inTag);
+                inTag = true;
+                tagStart = idx;
+            }
+            if (c == ']') {
+                assert(inTag);
+                inTag = false;
+                tagEnd = idx;
+                assert(tagStart < tagEnd);
+
+                // We need to check the tag for special meanings, copy
+                // it over to backing storage and actually reference the
+                // backing storage in the saved tags
+                StringRef tagStr = originalTags.substr(tagStart+1, tagEnd - tagStart - 1);
+                CATCH_ENFORCE(!tagStr.empty(), "Empty tags are not allowed");
+                enforceNotReservedTag(tagStr, lineInfo);
+                properties |= parseSpecialTag(tagStr);
+                // When copying a tag to the backing storage, we need to
+                // check if it is a merged hide tag, such as [.foo], and
+                // if it is, we need to handle it as if it was [foo].
+                if (tagStr.size() > 1 && tagStr[0] == '.') {
+                    tagStr = tagStr.substr(1, tagStr.size() - 1);
+                }
+                // We skip over dealing with the [.] tag, as we will add
+                // it later unconditionally and then sort and unique all
+                // the tags.
+                internalAppendTag(tagStr);
+            }
+            (void)inTag; // Silence "set-but-unused" warning in release mode.
+        }
+        // Add [.] if relevant
+        if (isHidden()) {
+            internalAppendTag("."_sr);
+        }
+
+        // Sort and prepare tags
+        std::sort(begin(tags), end(tags));
+        tags.erase(std::unique(begin(tags), end(tags)),
+                   end(tags));
+    }
+
+    bool TestCaseInfo::isHidden() const {
+        return applies( properties & TestCaseProperties::IsHidden );
+    }
+    bool TestCaseInfo::throws() const {
+        return applies( properties & TestCaseProperties::Throws );
+    }
+    bool TestCaseInfo::okToFail() const {
+        return applies( properties & (TestCaseProperties::ShouldFail | TestCaseProperties::MayFail ) );
+    }
+    bool TestCaseInfo::expectedToFail() const {
+        return applies( properties & (TestCaseProperties::ShouldFail) );
+    }
+
+    void TestCaseInfo::addFilenameTag() {
+        std::string combined("#");
+        combined += extractFilenamePart(lineInfo.file);
+        internalAppendTag(combined);
+    }
+
+    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.original.size();
+        }
+        ret.reserve(full_size);
+        for (const auto& tag : tags) {
+            ret.push_back('[');
+            ret += tag.original;
+            ret.push_back(']');
+        }
+
+        return ret;
+    }
+
+    void TestCaseInfo::internalAppendTag(StringRef tagStr) {
+        backingTags += '[';
+        const auto backingStart = backingTags.size();
+        backingTags += tagStr;
+        const auto backingEnd = backingTags.size();
+        backingTags += ']';
+        tags.emplace_back(StringRef(backingTags.c_str() + backingStart, backingEnd - backingStart));
+    }
+
+    bool operator<( TestCaseInfo const& lhs, TestCaseInfo const& rhs ) {
+        // We want to avoid redoing the string comparisons multiple times,
+        // so we store the result of a three-way comparison before using
+        // it in the actual comparison logic.
+        const auto cmpName = lhs.name.compare( rhs.name );
+        if ( cmpName != 0 ) {
+            return cmpName < 0;
+        }
+        const auto cmpClassName = lhs.className.compare( rhs.className );
+        if ( cmpClassName != 0 ) {
+            return cmpClassName < 0;
+        }
+        return lhs.tags < rhs.tags;
+    }
+
+    TestCaseInfo const& TestCaseHandle::getTestCaseInfo() const {
+        return *m_info;
+    }
+
+} // end namespace Catch
+
+
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+    TestSpec::Pattern::Pattern( std::string const& name )
+    : m_name( name )
+    {}
+
+    TestSpec::Pattern::~Pattern() = default;
+
+    std::string const& TestSpec::Pattern::name() const {
+        return m_name;
+    }
+
+
+    TestSpec::NamePattern::NamePattern( std::string const& name, std::string const& filterString )
+    : Pattern( filterString )
+    , m_wildcardPattern( toLower( name ), CaseSensitive::No )
+    {}
+
+    bool TestSpec::NamePattern::matches( TestCaseInfo const& testCase ) const {
+        return m_wildcardPattern.matches( testCase.name );
+    }
+
+
+    TestSpec::TagPattern::TagPattern( std::string const& tag, std::string const& filterString )
+    : Pattern( filterString )
+    , m_tag( tag )
+    {}
+
+    bool TestSpec::TagPattern::matches( TestCaseInfo const& testCase ) const {
+        return std::find( begin( testCase.tags ),
+                          end( testCase.tags ),
+                          Tag( m_tag ) ) != end( testCase.tags );
+    }
+
+    bool TestSpec::Filter::matches( TestCaseInfo const& testCase ) const {
+        bool should_use = !testCase.isHidden();
+        for (auto const& pattern : m_required) {
+            should_use = true;
+            if (!pattern->matches(testCase)) {
+                return false;
+            }
+        }
+        for (auto const& pattern : m_forbidden) {
+            if (pattern->matches(testCase)) {
+                return false;
+            }
+        }
+        return should_use;
+    }
+
+    std::string TestSpec::Filter::name() const {
+        std::string name;
+        for (auto const& p : m_required) {
+            name += p->name();
+        }
+        for (auto const& p : m_forbidden) {
+            name += p->name();
+        }
+        return name;
+    }
+
+
+    bool TestSpec::hasFilters() const {
+        return !m_filters.empty();
+    }
+
+    bool TestSpec::matches( TestCaseInfo const& testCase ) const {
+        return std::any_of( m_filters.begin(), m_filters.end(), [&]( Filter const& f ){ return f.matches( testCase ); } );
+    }
+
+    TestSpec::Matches TestSpec::matchesByFilter( std::vector<TestCaseHandle> const& testCases, IConfig const& config ) const
+    {
+        Matches matches( m_filters.size() );
+        std::transform( m_filters.begin(), m_filters.end(), matches.begin(), [&]( Filter const& filter ){
+            std::vector<TestCaseHandle const*> currentMatches;
+            for( auto const& test : testCases )
+                if( isThrowSafe( test, config ) && filter.matches( test.getTestCaseInfo() ) )
+                    currentMatches.emplace_back( &test );
+            return FilterMatch{ filter.name(), currentMatches };
+        } );
+        return matches;
+    }
+
+    const TestSpec::vectorStrings& TestSpec::getInvalidSpecs() const {
+        return m_invalidSpecs;
+    }
+
+}
+
+
+
+#include <chrono>
+
+namespace Catch {
+
+    namespace {
+        static auto getCurrentNanosecondsSinceEpoch() -> uint64_t {
+            return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
+        }
+    } // end unnamed namespace
+
+    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
+
+
+
+
+#include <cmath>
+#include <iomanip>
+
+namespace Catch {
+
+namespace Detail {
+
+    namespace {
+        const int hexThreshold = 255;
+
+        struct Endianness {
+            enum Arch { Big, Little };
+
+            static Arch which() {
+                int one = 1;
+                // If the lowest byte we read is non-zero, we can assume
+                // that little endian format is used.
+                auto value = *reinterpret_cast<char*>(&one);
+                return value ? Little : Big;
+            }
+        };
+
+        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;
+        }
+    } // end unnamed namespace
+
+    std::string convertIntoString(StringRef string, bool escape_invisibles) {
+        std::string ret;
+        // This is enough for the "don't escape invisibles" case, and a good
+        // lower bound on the "escape invisibles" case.
+        ret.reserve(string.size() + 2);
+
+        if (!escape_invisibles) {
+            ret += '"';
+            ret += string;
+            ret += '"';
+            return ret;
+        }
+
+        ret += '"';
+        for (char c : string) {
+            switch (c) {
+            case '\r':
+                ret.append("\\r");
+                break;
+            case '\n':
+                ret.append("\\n");
+                break;
+            case '\t':
+                ret.append("\\t");
+                break;
+            case '\f':
+                ret.append("\\f");
+                break;
+            default:
+                ret.push_back(c);
+                break;
+            }
+        }
+        ret += '"';
+
+        return ret;
+    }
+
+    std::string convertIntoString(StringRef string) {
+        return convertIntoString(string, getCurrentContext().getConfig()->showInvisibles());
+    }
+
+    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();
+    }
+} // end Detail namespace
+
+
+
+//// ======================================================= ////
+//
+//   Out-of-line defs for full specialization of StringMaker
+//
+//// ======================================================= ////
+
+std::string StringMaker<std::string>::convert(const std::string& str) {
+    return Detail::convertIntoString( str );
+}
+
+#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+std::string StringMaker<std::string_view>::convert(std::string_view str) {
+    return Detail::convertIntoString( StringRef( str.data(), str.size() ) );
+}
+#endif
+
+std::string StringMaker<char const*>::convert(char const* str) {
+    if (str) {
+        return Detail::convertIntoString( str );
+    } else {
+        return{ "{null string}" };
+    }
+}
+std::string StringMaker<char*>::convert(char* str) {
+    if (str) {
+        return Detail::convertIntoString( 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
+
+#if defined(CATCH_CONFIG_CPP17_BYTE)
+#include <cstddef>
+std::string StringMaker<std::byte>::convert(std::byte value) {
+    return ::Catch::Detail::stringify(std::to_integer<unsigned long long>(value));
+}
+#endif // defined(CATCH_CONFIG_CPP17_BYTE)
+
+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<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));
+}
+
+int StringMaker<float>::precision = 5;
+
+std::string StringMaker<float>::convert(float value) {
+    return Detail::fpToString(value, precision) + 'f';
+}
+
+int StringMaker<double>::precision = 10;
+
+std::string StringMaker<double>::convert(double value) {
+    return Detail::fpToString(value, precision);
+}
+
+} // end namespace Catch
+
+
+
+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::uint64_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;
+    }
+
+}
+
+
+#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( 3, 1, 1, "", 0 );
+        return version;
+    }
+
+}
+
+
+
+
+namespace Catch {
+
+    const char* GeneratorException::what() const noexcept {
+        return m_msg;
+    }
+
+} // end namespace Catch
+
+
+
+
+namespace Catch {
+
+    IGeneratorTracker::~IGeneratorTracker() = default;
+
+namespace Generators {
+
+namespace Detail {
+
+    [[noreturn]]
+    void throw_generator_exception(char const* msg) {
+        Catch::throw_exception(GeneratorException{ msg });
+    }
+} // end namespace Detail
+
+    GeneratorUntypedBase::~GeneratorUntypedBase() = default;
+
+    auto acquireGeneratorTracker(StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
+        return getResultCapture().acquireGeneratorTracker( generatorName, lineInfo );
+    }
+
+} // namespace Generators
+} // namespace Catch
+
+
+
+
+
+std::uint32_t Catch::Generators::Detail::getSeed() { return sharedRng()(); }
+
+
+
+
+namespace Catch {
+    IResultCapture::~IResultCapture() = default;
+}
+
+
+
+
+namespace Catch {
+    IConfig::~IConfig() = default;
+}
+
+
+
+
+namespace Catch {
+    IExceptionTranslator::~IExceptionTranslator() = default;
+    IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() = default;
+}
+
+
+
+#include <string>
+
+namespace Catch {
+    namespace Generators {
+
+        bool GeneratorUntypedBase::countedNext() {
+            auto ret = next();
+            if ( ret ) {
+                m_stringReprCache.clear();
+                ++m_currentElementIndex;
+            }
+            return ret;
+        }
+
+        StringRef GeneratorUntypedBase::currentElementAsString() const {
+            if ( m_stringReprCache.empty() ) {
+                m_stringReprCache = stringifyImpl();
+            }
+            return m_stringReprCache;
+        }
+
+    } // namespace Generators
+} // namespace Catch
+
+
+
+
+namespace Catch {
+    IRegistryHub::~IRegistryHub() = default;
+    IMutableRegistryHub::~IMutableRegistryHub() = default;
+}
+
+
+
+#include <algorithm>
+#include <cassert>
+#include <iomanip>
+
+namespace Catch {
+
+    ReporterConfig::ReporterConfig(
+        IConfig const* _fullConfig,
+        Detail::unique_ptr<IStream> _stream,
+        ColourMode colourMode,
+        std::map<std::string, std::string> customOptions ):
+        m_stream( CATCH_MOVE(_stream) ),
+        m_fullConfig( _fullConfig ),
+        m_colourMode( colourMode ),
+        m_customOptions( CATCH_MOVE( customOptions ) ) {}
+
+    Detail::unique_ptr<IStream> ReporterConfig::takeStream() && {
+        assert( m_stream );
+        return CATCH_MOVE( m_stream );
+    }
+    IConfig const * ReporterConfig::fullConfig() const { return m_fullConfig; }
+    ColourMode ReporterConfig::colourMode() const { return m_colourMode; }
+
+    std::map<std::string, std::string> const&
+    ReporterConfig::customOptions() const {
+        return m_customOptions;
+    }
+
+    ReporterConfig::~ReporterConfig() = default;
+
+    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 );
+        }
+    }
+
+    SectionStats::SectionStats(  SectionInfo const& _sectionInfo,
+                                 Counts const& _assertions,
+                                 double _durationInSeconds,
+                                 bool _missingAssertions )
+    :   sectionInfo( _sectionInfo ),
+        assertions( _assertions ),
+        durationInSeconds( _durationInSeconds ),
+        missingAssertions( _missingAssertions )
+    {}
+
+
+    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 )
+    {}
+
+
+    TestRunStats::TestRunStats(   TestRunInfo const& _runInfo,
+                    Totals const& _totals,
+                    bool _aborting )
+    :   runInfo( _runInfo ),
+        totals( _totals ),
+        aborting( _aborting )
+    {}
+
+    IEventListener::~IEventListener() = default;
+
+} // end namespace Catch
+
+
+
+
+namespace Catch {
+    IReporterFactory::~IReporterFactory() = default;
+    EventListenerFactory::~EventListenerFactory() = default;
+}
+
+
+
+
+namespace Catch {
+    IReporterRegistry::~IReporterRegistry() = default;
+}
+
+
+
+
+namespace Catch {
+    ITestInvoker::~ITestInvoker() = default;
+    ITestCaseRegistry::~ITestCaseRegistry() = default;
+}
+
+
+
+namespace Catch {
+
+    AssertionHandler::AssertionHandler
+        (   StringRef 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 message) {
+        m_resultCapture.handleMessage( m_assertionInfo, resultType, message, m_reaction );
+    }
+
+    auto AssertionHandler::allowThrows() const -> bool {
+        return getCurrentContext().getConfig()->allowThrows();
+    }
+
+    void AssertionHandler::complete() {
+        setCompleted();
+        if( m_reaction.shouldDebugBreak ) {
+
+            // 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)
+
+            // (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;
+    }
+
+    void AssertionHandler::handleUnexpectedInflightException() {
+        m_resultCapture.handleUnexpectedInflightException( m_assertionInfo, Catch::translateActiveException(), m_reaction );
+    }
+
+    void AssertionHandler::handleExceptionThrownAsExpected() {
+        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+    }
+    void AssertionHandler::handleExceptionNotThrownAsExpected() {
+        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+    }
+
+    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 matcherString  ) {
+        handleExceptionMatchExpr( handler, Matchers::Equals( str ), matcherString );
+    }
+
+} // namespace Catch
+
+
+
+
+#include <algorithm>
+
+namespace Catch {
+    namespace Detail {
+
+        bool CaseInsensitiveLess::operator()( StringRef lhs,
+                                              StringRef rhs ) const {
+            return std::lexicographical_compare(
+                lhs.begin(), lhs.end(),
+                rhs.begin(), rhs.end(),
+                []( char l, char r ) { return toLower( l ) < toLower( r ); } );
+        }
+
+        bool
+        CaseInsensitiveEqualTo::operator()( StringRef lhs,
+                                            StringRef rhs ) const {
+            return std::equal(
+                lhs.begin(), lhs.end(),
+                rhs.begin(), rhs.end(),
+                []( char l, char r ) { return toLower( l ) == toLower( r ); } );
+        }
+
+    } // namespace Detail
+} // namespace Catch
+
+
+
+
+#include <algorithm>
+#include <ostream>
+
+namespace {
+    bool isOptPrefix( char c ) {
+        return c == '-'
+#ifdef CATCH_PLATFORM_WINDOWS
+               || c == '/'
+#endif
+            ;
+    }
+
+    std::string normaliseOpt( std::string const& optName ) {
+#ifdef CATCH_PLATFORM_WINDOWS
+        if ( optName[0] == '/' )
+            return "-" + optName.substr( 1 );
+        else
+#endif
+            return optName;
+    }
+
+} // namespace
+
+namespace Catch {
+    namespace Clara {
+        namespace Detail {
+
+            void TokenStream::loadBuffer() {
+                m_tokenBuffer.clear();
+
+                // 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 } );
+                    }
+                }
+            }
+
+            TokenStream::TokenStream( Args const& args ):
+                TokenStream( args.m_args.begin(), args.m_args.end() ) {}
+
+            TokenStream::TokenStream( Iterator it_, Iterator itEnd_ ):
+                it( it_ ), itEnd( itEnd_ ) {
+                loadBuffer();
+            }
+
+            TokenStream& TokenStream::operator++() {
+                if ( m_tokenBuffer.size() >= 2 ) {
+                    m_tokenBuffer.erase( m_tokenBuffer.begin() );
+                } else {
+                    if ( it != itEnd )
+                        ++it;
+                    loadBuffer();
+                }
+                return *this;
+            }
+
+            ParserResult convertInto( std::string const& source,
+                                      std::string& target ) {
+                target = source;
+                return ParserResult::ok( ParseResultType::Matched );
+            }
+
+            ParserResult convertInto( std::string const& source,
+                                      bool& target ) {
+                std::string srcLC = toLower( source );
+
+                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 );
+            }
+
+            size_t ParserBase::cardinality() const { return 1; }
+
+            InternalParseResult ParserBase::parse( Args const& args ) const {
+                return parse( args.exeName(), TokenStream( args ) );
+            }
+
+            ParseState::ParseState( ParseResultType type,
+                                    TokenStream const& remainingTokens ):
+                m_type( type ), m_remainingTokens( remainingTokens ) {}
+
+            ParserResult BoundFlagRef::setFlag( bool flag ) {
+                m_ref = flag;
+                return ParserResult::ok( ParseResultType::Matched );
+            }
+
+            ResultBase::~ResultBase() = default;
+
+            bool BoundRef::isContainer() const { return false; }
+
+            bool BoundRef::isFlag() const { return false; }
+
+            bool BoundFlagRefBase::isFlag() const { return true; }
+
+} // namespace Detail
+
+        Detail::InternalParseResult Arg::parse(std::string const&,
+                                               Detail::TokenStream const& tokens) const {
+            auto validationResult = validate();
+            if (!validationResult)
+                return Detail::InternalParseResult(validationResult);
+
+            auto remainingTokens = tokens;
+            auto const& token = *remainingTokens;
+            if (token.type != Detail::TokenType::Argument)
+                return Detail::InternalParseResult::ok(Detail::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 Detail::InternalParseResult(result);
+            else
+                return Detail::InternalParseResult::ok(Detail::ParseState(
+                    ParseResultType::Matched, ++remainingTokens));
+        }
+
+        Opt::Opt(bool& ref) :
+            ParserRefImpl(std::make_shared<Detail::BoundFlagRef>(ref)) {}
+
+        std::vector<Detail::HelpColumns> Opt::getHelpColumns() const {
+            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 } };
+        }
+
+        bool Opt::isMatch(std::string const& optToken) const {
+            auto normalisedToken = normaliseOpt(optToken);
+            for (auto const& name : m_optNames) {
+                if (normaliseOpt(name) == normalisedToken)
+                    return true;
+            }
+            return false;
+        }
+
+        Detail::InternalParseResult Opt::parse(std::string const&,
+                                       Detail::TokenStream const& tokens) const {
+            auto validationResult = validate();
+            if (!validationResult)
+                return Detail::InternalParseResult(validationResult);
+
+            auto remainingTokens = tokens;
+            if (remainingTokens &&
+                remainingTokens->type == Detail::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 Detail::InternalParseResult(result);
+                        if (result.value() ==
+                            ParseResultType::ShortCircuitAll)
+                            return Detail::InternalParseResult::ok(Detail::ParseState(
+                                result.value(), remainingTokens));
+                    } else {
+                        auto valueRef =
+                            static_cast<Detail::BoundValueRefBase*>(
+                                m_ref.get());
+                        ++remainingTokens;
+                        if (!remainingTokens)
+                            return Detail::InternalParseResult::runtimeError(
+                                "Expected argument following " +
+                                token.token);
+                        auto const& argToken = *remainingTokens;
+                        if (argToken.type != Detail::TokenType::Argument)
+                            return Detail::InternalParseResult::runtimeError(
+                                "Expected argument following " +
+                                token.token);
+                        const auto result = valueRef->setValue(argToken.token);
+                        if (!result)
+                            return Detail::InternalParseResult(result);
+                        if (result.value() ==
+                            ParseResultType::ShortCircuitAll)
+                            return Detail::InternalParseResult::ok(Detail::ParseState(
+                                result.value(), remainingTokens));
+                    }
+                    return Detail::InternalParseResult::ok(Detail::ParseState(
+                        ParseResultType::Matched, ++remainingTokens));
+                }
+            }
+            return Detail::InternalParseResult::ok(
+                Detail::ParseState(ParseResultType::NoMatch, remainingTokens));
+        }
+
+        Detail::Result Opt::validate() const {
+            if (m_optNames.empty())
+                return Detail::Result::logicError("No options supplied to Opt");
+            for (auto const& name : m_optNames) {
+                if (name.empty())
+                    return Detail::Result::logicError(
+                        "Option name cannot be empty");
+#ifdef CATCH_PLATFORM_WINDOWS
+                if (name[0] != '-' && name[0] != '/')
+                    return Detail::Result::logicError(
+                        "Option name must begin with '-' or '/'");
+#else
+                if (name[0] != '-')
+                    return Detail::Result::logicError(
+                        "Option name must begin with '-'");
+#endif
+            }
+            return ParserRefImpl::validate();
+        }
+
+        ExeName::ExeName() :
+            m_name(std::make_shared<std::string>("<executable>")) {}
+
+        ExeName::ExeName(std::string& ref) : ExeName() {
+            m_ref = std::make_shared<Detail::BoundValueRef<std::string>>(ref);
+        }
+
+        Detail::InternalParseResult
+            ExeName::parse(std::string const&,
+                           Detail::TokenStream const& tokens) const {
+            return Detail::InternalParseResult::ok(
+                Detail::ParseState(ParseResultType::NoMatch, tokens));
+        }
+
+        ParserResult ExeName::set(std::string const& newName) {
+            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);
+        }
+
+
+
+
+        Parser& Parser::operator|=( Parser const& other ) {
+            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;
+        }
+
+        std::vector<Detail::HelpColumns> Parser::getHelpColumns() const {
+            std::vector<Detail::HelpColumns> cols;
+            for ( auto const& o : m_options ) {
+                auto childCols = o.getHelpColumns();
+                cols.insert( cols.end(), childCols.begin(), childCols.end() );
+            }
+            return cols;
+        }
+
+        void Parser::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:\n";
+            }
+
+            auto rows = getHelpColumns();
+            size_t consoleWidth = CATCH_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 << '\n';
+            }
+        }
+
+        Detail::Result Parser::validate() const {
+            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 Detail::Result::ok();
+        }
+
+        Detail::InternalParseResult
+        Parser::parse( std::string const& exeName,
+                       Detail::TokenStream const& tokens ) const {
+
+            struct ParserInfo {
+                ParserBase const* parser = nullptr;
+                size_t count = 0;
+            };
+            std::vector<ParserInfo> parseInfos;
+            parseInfos.reserve( m_options.size() + m_args.size() );
+            for ( auto const& opt : m_options ) {
+                parseInfos.push_back( { &opt, 0 } );
+            }
+            for ( auto const& arg : m_args ) {
+                parseInfos.push_back( { &arg, 0 } );
+            }
+
+            m_exeName.set( exeName );
+
+            auto result = Detail::InternalParseResult::ok(
+                Detail::ParseState( ParseResultType::NoMatch, tokens ) );
+            while ( result.value().remainingTokens() ) {
+                bool tokenParsed = false;
+
+                for ( auto& parseInfo : parseInfos ) {
+                    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 Detail::InternalParseResult::runtimeError(
+                        "Unrecognised token: " +
+                        result.value().remainingTokens()->token );
+            }
+            // !TBD Check missing required options
+            return result;
+        }
+
+        Args::Args(int argc, char const* const* argv) :
+            m_exeName(argv[0]), m_args(argv + 1, argv + argc) {}
+
+        Args::Args(std::initializer_list<std::string> args) :
+            m_exeName(*args.begin()),
+            m_args(args.begin() + 1, args.end()) {}
+
+
+        Help::Help( bool& showHelpFlag ):
+            Opt( [&]( bool flag ) {
+                showHelpFlag = flag;
+                return ParserResult::ok( ParseResultType::ShortCircuitAll );
+            } ) {
+            static_cast<Opt&> ( *this )(
+                "display usage information" )["-?"]["-h"]["--help"]
+                .optional();
+        }
+
+    } // namespace Clara
+} // namespace Catch
+
+
+
+
+#include <fstream>
+#include <string>
+
+namespace Catch {
+
+    Clara::Parser makeCommandLineParser( ConfigData& config ) {
+
+        using namespace Clara;
+
+        auto const setWarning = [&]( std::string const& warning ) {
+            if ( warning == "NoAssertions" ) {
+                config.warnings = static_cast<WarnAbout::What>(config.warnings | WarnAbout::NoAssertions);
+                return ParserResult::ok( ParseResultType::Matched );
+            } else if ( warning == "UnmatchedTestSpec" ) {
+                config.warnings = static_cast<WarnAbout::What>(config.warnings | WarnAbout::UnmatchedTestSpec);
+                return ParserResult::ok( ParseResultType::Matched );
+            }
+
+            return ParserResult ::runtimeError(
+                "Unrecognised warning option: '" + warning + '\'' );
+        };
+        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 );
+                        config.testsOrTags.emplace_back( "," );
+                    }
+                }
+                //Remove comma in the end
+                if(!config.testsOrTags.empty())
+                    config.testsOrTags.erase( config.testsOrTags.end()-1 );
+
+                return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const setTestOrder = [&]( std::string const& order ) {
+                if( startsWith( "declared", order ) )
+                    config.runOrder = TestRunOrder::Declared;
+                else if( startsWith( "lexical", order ) )
+                    config.runOrder = TestRunOrder::LexicographicallySorted;
+                else if( startsWith( "random", order ) )
+                    config.runOrder = TestRunOrder::Randomized;
+                else
+                    return ParserResult::runtimeError( "Unrecognised ordering: '" + order + '\'' );
+                return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const setRngSeed = [&]( std::string const& seed ) {
+                if( seed == "time" ) {
+                    config.rngSeed = generateRandomSeed(GenerateFrom::Time);
+                    return ParserResult::ok(ParseResultType::Matched);
+                } else if (seed == "random-device") {
+                    config.rngSeed = generateRandomSeed(GenerateFrom::RandomDevice);
+                    return ParserResult::ok(ParseResultType::Matched);
+                }
+
+                CATCH_TRY {
+                    std::size_t parsedTo = 0;
+                    unsigned long parsedSeed = std::stoul(seed, &parsedTo, 0);
+                    if (parsedTo != seed.size()) {
+                        return ParserResult::runtimeError("Could not parse '" + seed + "' as seed");
+                    }
+
+                    // TODO: Ideally we could parse unsigned int directly,
+                    //       but the stdlib doesn't provide helper for that
+                    //       type. After this is refactored to use fixed size
+                    //       type, we should check the parsed value is in range
+                    //       of the underlying type.
+                    config.rngSeed = static_cast<unsigned int>(parsedSeed);
+                    return ParserResult::ok(ParseResultType::Matched);
+                } CATCH_CATCH_ANON(std::exception const&) {
+                    return ParserResult::runtimeError("Could not parse '" + seed + "' as seed");
+                }
+            };
+        auto const setDefaultColourMode = [&]( std::string const& colourMode ) {
+            Optional<ColourMode> maybeMode = Catch::Detail::stringToColourMode(toLower( colourMode ));
+            if ( !maybeMode ) {
+                return ParserResult::runtimeError(
+                    "colour mode must be one of: default, ansi, win32, "
+                    "or none. '" +
+                    colourMode + "' is not recognised" );
+            }
+            auto mode = *maybeMode;
+            if ( !isColourImplAvailable( mode ) ) {
+                return ParserResult::runtimeError(
+                    "colour mode '" + colourMode +
+                    "' is not supported in this binary" );
+            }
+            config.defaultColourMode = mode;
+            return ParserResult::ok( ParseResultType::Matched );
+        };
+        auto const setWaitForKeypress = [&]( std::string const& keypress ) {
+                auto keypressLc = toLower( keypress );
+                if (keypressLc == "never")
+                    config.waitForKeypress = WaitForKeypress::Never;
+                else 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: never, 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& userReporterSpec ) {
+            if ( userReporterSpec.empty() ) {
+                return ParserResult::runtimeError( "Received empty reporter spec." );
+            }
+
+            Optional<ReporterSpec> parsed =
+                parseReporterSpec( userReporterSpec );
+            if ( !parsed ) {
+                return ParserResult::runtimeError(
+                    "Could not parse reporter spec '" + userReporterSpec +
+                    "'" );
+            }
+
+            auto const& reporterSpec = *parsed;
+
+            IReporterRegistry::FactoryMap const& factories =
+                getRegistryHub().getReporterRegistry().getFactories();
+            auto result = factories.find( reporterSpec.name() );
+
+            if ( result == factories.end() ) {
+                return ParserResult::runtimeError(
+                    "Unrecognized reporter, '" + reporterSpec.name() +
+                    "'. Check available with --list-reporters" );
+            }
+
+
+            const bool hadOutputFile = reporterSpec.outputFile().some();
+            config.reporterSpecifications.push_back( CATCH_MOVE( *parsed ) );
+            // It would be enough to check this only once at the very end, but
+            // there is  not a place where we could call this check, so do it
+            // every time it could fail. For valid inputs, this is still called
+            // at most once.
+            if (!hadOutputFile) {
+                int n_reporters_without_file = 0;
+                for (auto const& spec : config.reporterSpecifications) {
+                    if (spec.outputFile().none()) {
+                        n_reporters_without_file++;
+                    }
+                }
+                if (n_reporters_without_file > 1) {
+                    return ParserResult::runtimeError( "Only one reporter may have unspecified output file." );
+                }
+            }
+
+            return ParserResult::ok( ParseResultType::Matched );
+        };
+        auto const setShardCount = [&]( std::string const& shardCount ) {
+            CATCH_TRY{
+                std::size_t parsedTo = 0;
+                int64_t parsedCount = std::stoll(shardCount, &parsedTo, 0);
+                if (parsedTo != shardCount.size()) {
+                    return ParserResult::runtimeError("Could not parse '" + shardCount + "' as shard count");
+                }
+                if (parsedCount <= 0) {
+                    return ParserResult::runtimeError("Shard count must be a positive number");
+                }
+
+                config.shardCount = static_cast<unsigned int>(parsedCount);
+                return ParserResult::ok(ParseResultType::Matched);
+            } CATCH_CATCH_ANON(std::exception const&) {
+                return ParserResult::runtimeError("Could not parse '" + shardCount + "' as shard count");
+            }
+        };
+
+        auto const setShardIndex = [&](std::string const& shardIndex) {
+            CATCH_TRY{
+                std::size_t parsedTo = 0;
+                int64_t parsedIndex = std::stoll(shardIndex, &parsedTo, 0);
+                if (parsedTo != shardIndex.size()) {
+                    return ParserResult::runtimeError("Could not parse '" + shardIndex + "' as shard index");
+                }
+                if (parsedIndex < 0) {
+                    return ParserResult::runtimeError("Shard index must be a non-negative number");
+                }
+
+                config.shardIndex = static_cast<unsigned int>(parsedIndex);
+                return ParserResult::ok(ParseResultType::Matched);
+            } CATCH_CATCH_ANON(std::exception const&) {
+                return ParserResult::runtimeError("Could not parse '" + shardIndex + "' as shard index");
+            }
+        };
+
+
+        auto cli
+            = ExeName( config.processName )
+            | Help( config.showHelp )
+            | 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.defaultOutputFilename, "filename" )
+                ["-o"]["--out"]
+                ( "default output filename" )
+            | Opt( accept_many, setReporter, "name[::key=value]*" )
+                ["-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( accept_many, 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( config.minDuration, "seconds" )
+                ["-D"]["--min-duration"]
+                ( "show test durations for tests taking at least the given number of seconds" )
+            | 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.listTests )
+                ["--list-tests"]
+                ( "list all/matching test cases" )
+            | Opt( config.listTags )
+                ["--list-tags"]
+                ( "list all/matching tags" )
+            | Opt( config.listReporters )
+                ["--list-reporters"]
+                ( "list all available reporters" )
+            | Opt( config.listListeners )
+                ["--list-listeners"]
+                ( "list all listeners" )
+            | Opt( setTestOrder, "decl|lex|rand" )
+                ["--order"]
+                ( "test case order (defaults to decl)" )
+            | Opt( setRngSeed, "'time'|'random-device'|number" )
+                ["--rng-seed"]
+                ( "set a specific seed for random numbers" )
+            | Opt( setDefaultColourMode, "ansi|win32|none|default" )
+                ["--colour-mode"]
+                ( "what color mode should be used as default" )
+            | Opt( config.libIdentify )
+                ["--libidentify"]
+                ( "report name and version according to libidentify standard" )
+            | Opt( setWaitForKeypress, "never|start|exit|both" )
+                ["--wait-for-keypress"]
+                ( "waits for a keypress before exiting" )
+            | Opt( config.skipBenchmarks)
+                ["--skip-benchmarks"]
+                ( "disable running benchmarks")
+            | Opt( config.benchmarkSamples, "samples" )
+                ["--benchmark-samples"]
+                ( "number of samples to collect (default: 100)" )
+            | Opt( config.benchmarkResamples, "resamples" )
+                ["--benchmark-resamples"]
+                ( "number of resamples for the bootstrap (default: 100000)" )
+            | Opt( config.benchmarkConfidenceInterval, "confidence interval" )
+                ["--benchmark-confidence-interval"]
+                ( "confidence interval for the bootstrap (between 0 and 1, default: 0.95)" )
+            | Opt( config.benchmarkNoAnalysis )
+                ["--benchmark-no-analysis"]
+                ( "perform only measurements; do not perform any analysis" )
+            | Opt( config.benchmarkWarmupTime, "benchmarkWarmupTime" )
+                ["--benchmark-warmup-time"]
+                ( "amount of time in milliseconds spent on warming up each test (default: 100)" )
+            | Opt( setShardCount, "shard count" )
+                ["--shard-count"]
+                ( "split the tests to execute into this many groups" )
+            | Opt( setShardIndex, "shard index" )
+                ["--shard-index"]
+                ( "index of the group of tests to execute (see --shard-count)" ) |
+            Opt( config.allowZeroTests )
+                ["--allow-running-no-tests"]
+                ( "Treat 'No tests run' as a success" )
+            | Arg( config.testsOrTags, "test name|pattern|tags" )
+                ( "which test or tests to use" );
+
+        return cli;
+    }
+
+} // end namespace Catch
+
+
+#if defined(__clang__)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wexit-time-destructors"
+#endif
+
+
+
+#include <cassert>
+#include <ostream>
+#include <utility>
+
+namespace Catch {
+
+    ColourImpl::~ColourImpl() = default;
+
+    ColourImpl::ColourGuard ColourImpl::guardColour( Colour::Code colourCode ) {
+        return ColourGuard(colourCode, this );
+    }
+
+    void ColourImpl::ColourGuard::engageImpl( std::ostream& stream ) {
+        assert( &stream == &m_colourImpl->m_stream->stream() &&
+                "Engaging colour guard for different stream than used by the "
+                "parent colour implementation" );
+        static_cast<void>( stream );
+
+        m_engaged = true;
+        m_colourImpl->use( m_code );
+    }
+
+    ColourImpl::ColourGuard::ColourGuard( Colour::Code code,
+                                          ColourImpl const* colour ):
+        m_colourImpl( colour ), m_code( code ) {
+    }
+    ColourImpl::ColourGuard::ColourGuard( ColourGuard&& rhs ) noexcept:
+        m_colourImpl( rhs.m_colourImpl ),
+        m_code( rhs.m_code ),
+        m_engaged( rhs.m_engaged ) {
+        rhs.m_engaged = false;
+    }
+    ColourImpl::ColourGuard&
+    ColourImpl::ColourGuard::operator=( ColourGuard&& rhs ) noexcept {
+        using std::swap;
+        swap( m_colourImpl, rhs.m_colourImpl );
+        swap( m_code, rhs.m_code );
+        swap( m_engaged, rhs.m_engaged );
+
+        return *this;
+    }
+    ColourImpl::ColourGuard::~ColourGuard() {
+        if ( m_engaged ) {
+            m_colourImpl->use( Colour::None );
+        }
+    }
+
+    ColourImpl::ColourGuard&
+    ColourImpl::ColourGuard::engage( std::ostream& stream ) & {
+        engageImpl( stream );
+        return *this;
+    }
+
+    ColourImpl::ColourGuard&&
+    ColourImpl::ColourGuard::engage( std::ostream& stream ) && {
+        engageImpl( stream );
+        return CATCH_MOVE(*this);
+    }
+
+    namespace {
+        //! A do-nothing implementation of colour, used as fallback for unknown
+        //! platforms, and when the user asks to deactivate all colours.
+        class NoColourImpl : public ColourImpl {
+        public:
+            NoColourImpl( IStream* stream ): ColourImpl( stream ) {}
+
+        private:
+            void use( Colour::Code ) const override {}
+        };
+    } // namespace
+
+
+} // namespace Catch
+
+
+#if defined ( CATCH_CONFIG_COLOUR_WIN32 ) /////////////////////////////////////////
+
+namespace Catch {
+namespace {
+
+    class Win32ColourImpl : public ColourImpl {
+    public:
+        Win32ColourImpl(IStream* stream):
+            ColourImpl(stream) {
+            CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
+            GetConsoleScreenBufferInfo( GetStdHandle( STD_OUTPUT_HANDLE ),
+                                        &csbiInfo );
+            originalForegroundAttributes = csbiInfo.wAttributes & ~( BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_INTENSITY );
+            originalBackgroundAttributes = csbiInfo.wAttributes & ~( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY );
+        }
+
+        static bool useImplementationForStream(IStream const& stream) {
+            // Win32 text colour APIs can only be used on console streams
+            // We cannot check that the output hasn't been redirected,
+            // so we just check that the original stream is console stream.
+            return stream.isConsole();
+        }
+
+    private:
+        void use( Colour::Code _colourCode ) const 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" );
+            }
+        }
+
+        void setTextAttribute( WORD _textAttribute ) const {
+            SetConsoleTextAttribute( GetStdHandle( STD_OUTPUT_HANDLE ),
+                                     _textAttribute |
+                                         originalBackgroundAttributes );
+        }
+        WORD originalForegroundAttributes;
+        WORD originalBackgroundAttributes;
+    };
+
+} // end anon namespace
+} // end namespace Catch
+
+#endif // Windows/ ANSI/ None
+
+
+#if defined( CATCH_PLATFORM_LINUX ) || defined( CATCH_PLATFORM_MAC )
+#    define CATCH_INTERNAL_HAS_ISATTY
+#    include <unistd.h>
+#endif
+
+namespace Catch {
+namespace {
+
+    class ANSIColourImpl : public ColourImpl {
+    public:
+        ANSIColourImpl( IStream* stream ): ColourImpl( stream ) {}
+
+        static bool useImplementationForStream(IStream const& stream) {
+            // This is kinda messy due to trying to support a bunch of
+            // different platforms at once.
+            // The basic idea is that if we are asked to do autodetection (as
+            // opposed to being told to use posixy colours outright), then we
+            // only want to use the colours if we are writing to console.
+            // However, console might be redirected, so we make an attempt at
+            // checking for that on platforms where we know how to do that.
+            bool useColour = stream.isConsole();
+#if defined( CATCH_INTERNAL_HAS_ISATTY ) && \
+    !( defined( __DJGPP__ ) && defined( __STRICT_ANSI__ ) )
+            ErrnoGuard _; // for isatty
+            useColour = useColour && isatty( STDOUT_FILENO );
+#    endif
+#    if defined( CATCH_PLATFORM_MAC ) || defined( CATCH_PLATFORM_IPHONE )
+            useColour = useColour && !isDebuggerActive();
+#    endif
+
+            return useColour;
+        }
+
+    private:
+        void use( Colour::Code _colourCode ) const override {
+            auto setColour = [&out =
+                                  m_stream->stream()]( char const* escapeCode ) {
+                // The escape sequence must be flushed to console, otherwise
+                // if stdin and stderr are intermixed, we'd get accidentally
+                // coloured output.
+                out << '\033' << escapeCode << std::flush;
+            };
+            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" );
+            }
+        }
+    };
+
+} // end anon namespace
+} // end namespace Catch
+
+namespace Catch {
+
+    Detail::unique_ptr<ColourImpl> makeColourImpl( ColourMode implSelection,
+                                                   IStream* stream ) {
+#if defined( CATCH_CONFIG_COLOUR_WIN32 )
+        if ( implSelection == ColourMode::Win32 ) {
+            return Detail::make_unique<Win32ColourImpl>( stream );
+        }
+#endif
+        if ( implSelection == ColourMode::ANSI ) {
+            return Detail::make_unique<ANSIColourImpl>( stream );
+        }
+        if ( implSelection == ColourMode::None ) {
+            return Detail::make_unique<NoColourImpl>( stream );
+        }
+
+        if ( implSelection == ColourMode::PlatformDefault) {
+#if defined( CATCH_CONFIG_COLOUR_WIN32 )
+            if ( Win32ColourImpl::useImplementationForStream( *stream ) ) {
+                return Detail::make_unique<Win32ColourImpl>( stream );
+            }
+#endif
+            if ( ANSIColourImpl::useImplementationForStream( *stream ) ) {
+                return Detail::make_unique<ANSIColourImpl>( stream );
+            }
+            return Detail::make_unique<NoColourImpl>( stream );
+        }
+
+        CATCH_ERROR( "Could not create colour impl for selection " << static_cast<int>(implSelection) );
+    }
+
+    bool isColourImplAvailable( ColourMode colourSelection ) {
+        switch ( colourSelection ) {
+#if defined( CATCH_CONFIG_COLOUR_WIN32 )
+        case ColourMode::Win32:
+#endif
+        case ColourMode::ANSI:
+        case ColourMode::None:
+        case ColourMode::PlatformDefault:
+            return true;
+        default:
+            return false;
+        }
+    }
+
+
+} // end namespace Catch
+
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#endif
+
+
+
+
+namespace Catch {
+
+    class Context : public IMutableContext, private Detail::NonCopyable {
+
+    public: // IContext
+        IResultCapture* getResultCapture() override {
+            return m_resultCapture;
+        }
+
+        IConfig const* getConfig() const override {
+            return m_config;
+        }
+
+        ~Context() override;
+
+    public: // IMutableContext
+        void setResultCapture( IResultCapture* resultCapture ) override {
+            m_resultCapture = resultCapture;
+        }
+        void setConfig( IConfig const* config ) override {
+            m_config = config;
+        }
+
+        friend IMutableContext& getCurrentMutableContext();
+
+    private:
+        IConfig const* m_config = nullptr;
+        IResultCapture* m_resultCapture = nullptr;
+    };
+
+    IMutableContext *IMutableContext::currentContext = nullptr;
+
+    void IMutableContext::createContext()
+    {
+        currentContext = new Context();
+    }
+
+    void cleanUpContext() {
+        delete IMutableContext::currentContext;
+        IMutableContext::currentContext = nullptr;
+    }
+    IContext::~IContext() = default;
+    IMutableContext::~IMutableContext() = default;
+    Context::~Context() = default;
+
+
+    SimplePcg32& sharedRng() {
+        static SimplePcg32 s_rng;
+        return s_rng;
+    }
+
+}
+
+
+
+
+
+#include <ostream>
+
+#if defined(CATCH_CONFIG_ANDROID_LOGWRITE)
+#include <android/log.h>
+
+    namespace Catch {
+        void writeToDebugConsole( std::string const& text ) {
+            __android_log_write( ANDROID_LOG_DEBUG, "Catch", text.c_str() );
+        }
+    }
+
+#elif defined(CATCH_PLATFORM_WINDOWS)
+
+    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
+
+
+
+#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
+
+#  include <cassert>
+#  include <sys/types.h>
+#  include <unistd.h>
+#  include <cstddef>
+#  include <ostream>
+
+#ifdef __apple_build_version__
+    // These headers will only compile with AppleClang (XCode)
+    // For other compilers (Clang, GCC, ... ) we need to exclude them
+#  include <sys/sysctl.h>
+#endif
+
+    namespace Catch {
+        #ifdef __apple_build_version__
+        // The following function is taken directly from the following technical note:
+        // https://developer.apple.com/library/archive/qa/qa1361/_index.html
+
+        // Returns true if the current process is being debugged (either
+        // running under the debugger or has a debugger attached post facto).
+        bool isDebuggerActive(){
+            int                 mib[4];
+            struct kinfo_proc   info;
+            std::size_t         size;
+
+            // Initialize the flags so that, if sysctl fails for some bizarre
+            // reason, we get a predictable result.
+
+            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.
+
+            mib[0] = CTL_KERN;
+            mib[1] = KERN_PROC;
+            mib[2] = KERN_PROC_PID;
+            mib[3] = getpid();
+
+            // Call sysctl.
+
+            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\n" << std::flush;
+                return false;
+            }
+
+            // We're being debugged if the P_TRACED flag is set.
+
+            return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
+        }
+        #else
+        bool isDebuggerActive() {
+            // We need to find another way to determine this for non-appleclang compilers on macOS
+            return false;
+        }
+        #endif
+    } // 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
+
+
+
+
+namespace Catch {
+
+    ITransientExpression::~ITransientExpression() = default;
+
+    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;
+    }
+}
+
+
+
+#include <stdexcept>
+
+
+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
+
+    [[noreturn]]
+    void throw_logic_error(std::string const& msg) {
+        throw_exception(std::logic_error(msg));
+    }
+
+    [[noreturn]]
+    void throw_domain_error(std::string const& msg) {
+        throw_exception(std::domain_error(msg));
+    }
+
+    [[noreturn]]
+    void throw_runtime_error(std::string const& msg) {
+        throw_exception(std::runtime_error(msg));
+    }
+
+
+
+} // namespace Catch;
+
+
+
+#include <cassert>
+
+namespace Catch {
+
+    IMutableEnumValuesRegistry::~IMutableEnumValuesRegistry() = default;
+
+    namespace Detail {
+
+        namespace {
+            // Extracts the actual name part of an enum instance
+            // In other words, it returns the Blue part of Bikeshed::Colour::Blue
+            StringRef extractInstanceName(StringRef enumInstance) {
+                // Find last occurrence of ":"
+                size_t name_start = enumInstance.size();
+                while (name_start > 0 && enumInstance[name_start - 1] != ':') {
+                    --name_start;
+                }
+                return enumInstance.substr(name_start, enumInstance.size() - name_start);
+            }
+        }
+
+        std::vector<StringRef> parseEnums( StringRef enums ) {
+            auto enumValues = splitStringRef( enums, ',' );
+            std::vector<StringRef> parsed;
+            parsed.reserve( enumValues.size() );
+            for( auto const& enumValue : enumValues ) {
+                parsed.push_back(trim(extractInstanceName(enumValue)));
+            }
+            return parsed;
+        }
+
+        EnumInfo::~EnumInfo() {}
+
+        StringRef EnumInfo::lookup( int value ) const {
+            for( auto const& valueToName : m_values ) {
+                if( valueToName.first == value )
+                    return valueToName.second;
+            }
+            return "{** unexpected enum value **}"_sr;
+        }
+
+        Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
+            auto enumInfo = Catch::Detail::make_unique<EnumInfo>();
+            enumInfo->m_name = enumName;
+            enumInfo->m_values.reserve( values.size() );
+
+            const auto valueNames = Catch::Detail::parseEnums( allValueNames );
+            assert( valueNames.size() == values.size() );
+            std::size_t i = 0;
+            for( auto value : values )
+                enumInfo->m_values.emplace_back(value, valueNames[i++]);
+
+            return enumInfo;
+        }
+
+        EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
+            m_enumInfos.push_back(makeEnumInfo(enumName, allValueNames, values));
+            return *m_enumInfos.back();
+        }
+
+    } // Detail
+} // Catch
+
+
+
+
+
+#include <cerrno>
+
+namespace Catch {
+        ErrnoGuard::ErrnoGuard():m_oldErrno(errno){}
+        ErrnoGuard::~ErrnoGuard() { errno = m_oldErrno; }
+}
+
+
+
+namespace Catch {
+
+    ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry() {
+    }
+
+    void ExceptionTranslatorRegistry::registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator ) {
+        m_translators.push_back( CATCH_MOVE( translator ) );
+    }
+
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+    std::string ExceptionTranslatorRegistry::translateActiveException() const {
+        // Compiling a mixed mode project with MSVC means that CLR
+        // exceptions will be caught in (...) as well. However, these do
+        // 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.";
+        }
+
+        // First we try user-registered translators. If none of them can
+        // handle the exception, it will be rethrown handled by our defaults.
+        try {
+            return tryTranslators();
+        }
+        // To avoid having to handle TFE explicitly everywhere, we just
+        // rethrow it so that it goes back up the caller.
+        catch( TestFailureException& ) {
+            std::rethrow_exception(std::current_exception());
+        }
+        catch( std::exception const& ex ) {
+            return ex.what();
+        }
+        catch( std::string const& 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());
+        }
+    }
+
+#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!");
+    }
+
+    std::string ExceptionTranslatorRegistry::tryTranslators() const {
+        CATCH_INTERNAL_ERROR("Attempted to use exception translators under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
+    }
+#endif
+
+
+}
+
+
+
+/** \file
+ * This file provides platform specific implementations of FatalConditionHandler
+ *
+ * This means that there is a lot of conditional compilation, and platform
+ * specific code. Currently, Catch2 supports a dummy handler (if no
+ * handler is desired), and 2 platform specific handlers:
+ *  * Windows' SEH
+ *  * POSIX signals
+ *
+ * Consequently, various pieces of code below are compiled if either of
+ * the platform specific handlers is enabled, or if none of them are
+ * enabled. It is assumed that both cannot be enabled at the same time,
+ * and doing so should cause a compilation error.
+ *
+ * If another platform specific handler is added, the compile guards
+ * below will need to be updated taking these assumptions into account.
+ */
+
+
+
+#include <algorithm>
+
+#if !defined( CATCH_CONFIG_WINDOWS_SEH ) && !defined( CATCH_CONFIG_POSIX_SIGNALS )
+
+namespace Catch {
+
+    // If neither SEH nor signal handling is required, the handler impls
+    // do not have to do anything, and can be empty.
+    void FatalConditionHandler::engage_platform() {}
+    void FatalConditionHandler::disengage_platform() noexcept {}
+    FatalConditionHandler::FatalConditionHandler() = default;
+    FatalConditionHandler::~FatalConditionHandler() = default;
+
+} // end namespace Catch
+
+#endif // !CATCH_CONFIG_WINDOWS_SEH && !CATCH_CONFIG_POSIX_SIGNALS
+
+#if defined( CATCH_CONFIG_WINDOWS_SEH ) && defined( CATCH_CONFIG_POSIX_SIGNALS )
+#error "Inconsistent configuration: Windows' SEH handling and POSIX signals cannot be enabled at the same time"
+#endif // CATCH_CONFIG_WINDOWS_SEH && CATCH_CONFIG_POSIX_SIGNALS
+
+#if defined( CATCH_CONFIG_WINDOWS_SEH ) || defined( CATCH_CONFIG_POSIX_SIGNALS )
+
+namespace {
+    //! Signals fatal error message to the run context
+    void reportFatal( char const * const message ) {
+        Catch::getCurrentContext().getResultCapture()->handleFatalErrorCondition( message );
+    }
+
+    //! Minimal size Catch2 needs for its own fatal error handling.
+    //! Picked empirically, so it might not be sufficient on all
+    //! platforms, and for all configurations.
+    constexpr std::size_t minStackSizeForErrors = 32 * 1024;
+} // end unnamed namespace
+
+#endif // CATCH_CONFIG_WINDOWS_SEH || CATCH_CONFIG_POSIX_SIGNALS
+
+#if defined( CATCH_CONFIG_WINDOWS_SEH )
+
+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" },
+    };
+
+    static LONG CALLBACK topLevelExceptionFilter(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;
+    }
+
+    // Since we do not support multiple instantiations, we put these
+    // into global variables and rely on cleaning them up in outlined
+    // constructors/destructors
+    static LPTOP_LEVEL_EXCEPTION_FILTER previousTopLevelExceptionFilter = nullptr;
+
+
+    // For MSVC, we reserve part of the stack memory for handling
+    // memory overflow structured exception.
+    FatalConditionHandler::FatalConditionHandler() {
+        ULONG guaranteeSize = static_cast<ULONG>(minStackSizeForErrors);
+        if (!SetThreadStackGuarantee(&guaranteeSize)) {
+            // We do not want to fully error out, because needing
+            // the stack reserve should be rare enough anyway.
+            Catch::cerr()
+                << "Failed to reserve piece of stack."
+                << " Stack overflows will not be reported successfully.";
+        }
+    }
+
+    // We do not attempt to unset the stack guarantee, because
+    // Windows does not support lowering the stack size guarantee.
+    FatalConditionHandler::~FatalConditionHandler() = default;
+
+
+    void FatalConditionHandler::engage_platform() {
+        // Register as a the top level exception filter.
+        previousTopLevelExceptionFilter = SetUnhandledExceptionFilter(topLevelExceptionFilter);
+    }
+
+    void FatalConditionHandler::disengage_platform() noexcept {
+        if (SetUnhandledExceptionFilter(previousTopLevelExceptionFilter) != topLevelExceptionFilter) {
+            Catch::cerr()
+                << "Unexpected SEH unhandled exception filter on disengage."
+                << " The filter was restored, but might be rolled back unexpectedly.";
+        }
+        previousTopLevelExceptionFilter = nullptr;
+    }
+
+} // end namespace Catch
+
+#endif // CATCH_CONFIG_WINDOWS_SEH
+
+#if defined( CATCH_CONFIG_POSIX_SIGNALS )
+
+#include <signal.h>
+
+namespace Catch {
+
+    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" }
+    };
+
+// Older GCCs trigger -Wmissing-field-initializers for T foo = {}
+// which is zero initialization, but not explicit. We want to avoid
+// that.
+#if defined(__GNUC__)
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+#endif
+
+    static char* altStackMem = nullptr;
+    static std::size_t altStackSize = 0;
+    static stack_t oldSigStack{};
+    static struct sigaction oldSigActions[sizeof(signalDefs) / sizeof(SignalDefs)]{};
+
+    static void restorePreviousSignalHandlers() noexcept {
+        // We set signal handlers back to the previous ones. Hopefully
+        // nobody overwrote them in the meantime, and doesn't expect
+        // their signal handlers to live past ours given that they
+        // installed them after ours..
+        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);
+    }
+
+    static void handleSignal( int sig ) {
+        char const * name = "<unknown signal>";
+        for (auto const& def : signalDefs) {
+            if (sig == def.id) {
+                name = def.name;
+                break;
+            }
+        }
+        // We need to restore previous signal handlers and let them do
+        // their thing, so that the users can have the debugger break
+        // when a signal is raised, and so on.
+        restorePreviousSignalHandlers();
+        reportFatal( name );
+        raise( sig );
+    }
+
+    FatalConditionHandler::FatalConditionHandler() {
+        assert(!altStackMem && "Cannot initialize POSIX signal handler when one already exists");
+        if (altStackSize == 0) {
+            altStackSize = std::max(static_cast<size_t>(SIGSTKSZ), minStackSizeForErrors);
+        }
+        altStackMem = new char[altStackSize]();
+    }
+
+    FatalConditionHandler::~FatalConditionHandler() {
+        delete[] altStackMem;
+        // We signal that another instance can be constructed by zeroing
+        // out the pointer.
+        altStackMem = nullptr;
+    }
+
+    void FatalConditionHandler::engage_platform() {
+        stack_t sigStack;
+        sigStack.ss_sp = altStackMem;
+        sigStack.ss_size = altStackSize;
+        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]);
+        }
+    }
+
+#if defined(__GNUC__)
+#    pragma GCC diagnostic pop
+#endif
+
+
+    void FatalConditionHandler::disengage_platform() noexcept {
+        restorePreviousSignalHandlers();
+    }
+
+} // end namespace Catch
+
+#endif // CATCH_CONFIG_POSIX_SIGNALS
+
+
+
+
+#include <cstring>
+
+namespace Catch {
+    namespace Detail {
+
+        uint32_t convertToBits(float f) {
+            static_assert(sizeof(float) == sizeof(uint32_t), "Important ULP matcher assumption violated");
+            uint32_t i;
+            std::memcpy(&i, &f, sizeof(f));
+            return i;
+        }
+
+        uint64_t convertToBits(double d) {
+            static_assert(sizeof(double) == sizeof(uint64_t), "Important ULP matcher assumption violated");
+            uint64_t i;
+            std::memcpy(&i, &d, sizeof(d));
+            return i;
+        }
+
+    } // end namespace Detail
+} // end namespace Catch
+
+
+
+
+
+#include <cstdio>
+#include <fstream>
+#include <sstream>
+#include <vector>
+
+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 override {
+                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 ) {
+                if ( !str.empty() ) {
+                    writeToDebugConsole( str );
+                }
+            }
+        };
+
+        ///////////////////////////////////////////////////////////////////////////
+
+        class FileStream : public IStream {
+            std::ofstream m_ofs;
+        public:
+            FileStream( std::string const& filename ) {
+                m_ofs.open( filename.c_str() );
+                CATCH_ENFORCE( !m_ofs.fail(), "Unable to open file: '" << filename << '\'' );
+                m_ofs << std::unitbuf;
+            }
+            ~FileStream() override = default;
+        public: // IStream
+            std::ostream& stream() override {
+                return m_ofs;
+            }
+        };
+
+        ///////////////////////////////////////////////////////////////////////////
+
+        class CoutStream : public IStream {
+            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() override { return m_os; }
+            bool isConsole() const override { return true; }
+        };
+
+        class CerrStream : public IStream {
+            std::ostream m_os;
+
+        public:
+            // Store the streambuf from cerr up-front because
+            // cout may get redirected when running tests
+            CerrStream(): m_os( Catch::cerr().rdbuf() ) {}
+            ~CerrStream() override = default;
+
+        public: // IStream
+            std::ostream& stream() override { return m_os; }
+            bool isConsole() const override { return true; }
+        };
+
+        ///////////////////////////////////////////////////////////////////////////
+
+        class DebugOutStream : public IStream {
+            Detail::unique_ptr<StreamBufImpl<OutputDebugWriter>> m_streamBuf;
+            std::ostream m_os;
+        public:
+            DebugOutStream()
+            :   m_streamBuf( Detail::make_unique<StreamBufImpl<OutputDebugWriter>>() ),
+                m_os( m_streamBuf.get() )
+            {}
+
+            ~DebugOutStream() override = default;
+
+        public: // IStream
+            std::ostream& stream() override { return m_os; }
+        };
+
+    } // unnamed namespace
+} // namespace Detail
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    auto makeStream( std::string const& filename ) -> Detail::unique_ptr<IStream> {
+        if ( filename.empty() || filename == "-" ) {
+            return Detail::make_unique<Detail::CoutStream>();
+        }
+        if( filename[0] == '%' ) {
+            if ( filename == "%debug" ) {
+                return Detail::make_unique<Detail::DebugOutStream>();
+            } else if ( filename == "%stderr" ) {
+                return Detail::make_unique<Detail::CerrStream>();
+            } else if ( filename == "%stdout" ) {
+                return Detail::make_unique<Detail::CoutStream>();
+            } else {
+                CATCH_ERROR( "Unrecognised stream: '" << filename << '\'' );
+            }
+        }
+        return Detail::make_unique<Detail::FileStream>( filename );
+    }
+
+}
+
+
+
+
+namespace Catch {
+
+    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;
+    }
+
+} // namespace Catch
+
+
+
+
+#ifdef CATCH_CONFIG_WINDOWS_CRTDBG
+#include <crtdbg.h>
+
+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);
+    }
+}
+
+#else // ^^ Windows crt debug heap enabled // Windows crt debug heap disabled vv
+
+    Catch::LeakDetector::LeakDetector() {}
+
+#endif // CATCH_CONFIG_WINDOWS_CRTDBG
+
+Catch::LeakDetector::~LeakDetector() {
+    Catch::cleanUp();
+}
+
+
+
+
+
+namespace Catch {
+    namespace {
+
+        void listTests(IEventListener& reporter, IConfig const& config) {
+            auto const& testSpec = config.testSpec();
+            auto matchedTestCases = filterTests(getAllTestCasesSorted(config), testSpec, config);
+            reporter.listTests(matchedTestCases);
+        }
+
+        void listTags(IEventListener& reporter, IConfig const& config) {
+            auto const& testSpec = config.testSpec();
+            std::vector<TestCaseHandle> matchedTestCases = filterTests(getAllTestCasesSorted(config), testSpec, config);
+
+            std::map<StringRef, TagInfo, Detail::CaseInsensitiveLess> tagCounts;
+            for (auto const& testCase : matchedTestCases) {
+                for (auto const& tagName : testCase.getTestCaseInfo().tags) {
+                    auto it = tagCounts.find(tagName.original);
+                    if (it == tagCounts.end())
+                        it = tagCounts.insert(std::make_pair(tagName.original, TagInfo())).first;
+                    it->second.add(tagName.original);
+                }
+            }
+
+            std::vector<TagInfo> infos; infos.reserve(tagCounts.size());
+            for (auto& tagc : tagCounts) {
+                infos.push_back(CATCH_MOVE(tagc.second));
+            }
+
+            reporter.listTags(infos);
+        }
+
+        void listReporters(IEventListener& reporter) {
+            std::vector<ReporterDescription> descriptions;
+
+            IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
+            descriptions.reserve(factories.size());
+            for (auto const& fac : factories) {
+                descriptions.push_back({ fac.first, fac.second->getDescription() });
+            }
+
+            reporter.listReporters(descriptions);
+        }
+
+        void listListeners(IEventListener& reporter) {
+            std::vector<ListenerDescription> descriptions;
+
+            auto const& factories =
+                getRegistryHub().getReporterRegistry().getListeners();
+            descriptions.reserve( factories.size() );
+            for ( auto const& fac : factories ) {
+                descriptions.push_back( { fac->getName(), fac->getDescription() } );
+            }
+
+            reporter.listListeners( descriptions );
+        }
+
+    } // end anonymous namespace
+
+    void TagInfo::add( StringRef spelling ) {
+        ++count;
+        spellings.insert( spelling );
+    }
+
+    std::string TagInfo::all() const {
+        // 2 per tag for brackets '[' and ']'
+        size_t size =  spellings.size() * 2;
+        for (auto const& spelling : spellings) {
+            size += spelling.size();
+        }
+
+        std::string out; out.reserve(size);
+        for (auto const& spelling : spellings) {
+            out += '[';
+            out += spelling;
+            out += ']';
+        }
+        return out;
+    }
+
+    bool list( IEventListener& reporter, Config const& config ) {
+        bool listed = false;
+        if (config.listTests()) {
+            listed = true;
+            listTests(reporter, config);
+        }
+        if (config.listTags()) {
+            listed = true;
+            listTags(reporter, config);
+        }
+        if (config.listReporters()) {
+            listed = true;
+            listReporters(reporter);
+        }
+        if ( config.listListeners() ) {
+            listed = true;
+            listListeners( reporter );
+        }
+        return listed;
+    }
+
+} // end namespace Catch
+
+
+
+namespace Catch {
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+    static LeakDetector leakDetector;
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+}
+
+// Allow users of amalgamated .cpp file to remove our main and provide their own.
+#if !defined(CATCH_AMALGAMATED_CUSTOM_MAIN)
+
+#if defined(CATCH_CONFIG_WCHAR) && defined(CATCH_PLATFORM_WINDOWS) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
+// Standard C/C++ Win32 Unicode wmain entry point
+extern "C" int __cdecl wmain (int argc, wchar_t * argv[], wchar_t * []) {
+#else
+// Standard C/C++ main entry point
+int main (int argc, char * argv[]) {
+#endif
+
+    // We want to force the linker not to discard the global variable
+    // and its constructor, as it (optionally) registers leak detector
+    (void)&Catch::leakDetector;
+
+    return Catch::Session().run( argc, argv );
+}
+
+#endif // !defined(CATCH_AMALGAMATED_CUSTOM_MAIN
+
+
+
+
+namespace Catch {
+
+    MessageInfo::MessageInfo(   StringRef _macroName,
+                                SourceLineInfo const& _lineInfo,
+                                ResultWas::OfType _type )
+    :   macroName( _macroName ),
+        lineInfo( _lineInfo ),
+        type( _type ),
+        sequence( ++globalCount )
+    {}
+
+    // This may need protecting if threading support is added
+    unsigned int MessageInfo::globalCount = 0;
+
+} // end namespace Catch
+
+
+
+#include <cstdio>
+#include <cstring>
+#include <sstream>
+
+#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(); }
+
+    RedirectedStreams::RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr)
+    :   m_redirectedCout(redirectedCout),
+        m_redirectedCerr(redirectedCerr)
+    {}
+
+    RedirectedStreams::~RedirectedStreams() {
+        m_redirectedCout += m_redirectedStdOut.str();
+        m_redirectedCerr += m_redirectedStdErr.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("Could not 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
+
+
+
+
+#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
+
+
+
+namespace Catch {
+
+namespace {
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4146) // we negate uint32 during the rotate
+#endif
+        // Safe rotr implementation thanks to John Regehr
+        uint32_t rotate_right(uint32_t val, uint32_t count) {
+            const uint32_t mask = 31;
+            count &= mask;
+            return (val >> count) | (val << (-count & mask));
+        }
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+}
+
+
+    SimplePcg32::SimplePcg32(result_type seed_) {
+        seed(seed_);
+    }
+
+
+    void SimplePcg32::seed(result_type seed_) {
+        m_state = 0;
+        (*this)();
+        m_state += seed_;
+        (*this)();
+    }
+
+    void SimplePcg32::discard(uint64_t skip) {
+        // We could implement this to run in O(log n) steps, but this
+        // should suffice for our use case.
+        for (uint64_t s = 0; s < skip; ++s) {
+            static_cast<void>((*this)());
+        }
+    }
+
+    SimplePcg32::result_type SimplePcg32::operator()() {
+        // prepare the output value
+        const uint32_t xorshifted = static_cast<uint32_t>(((m_state >> 18u) ^ m_state) >> 27u);
+        const auto output = rotate_right(xorshifted, m_state >> 59u);
+
+        // advance state
+        m_state = m_state * 6364136223846793005ULL + s_inc;
+
+        return output;
+    }
+
+    bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
+        return lhs.m_state == rhs.m_state;
+    }
+
+    bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
+        return lhs.m_state != rhs.m_state;
+    }
+}
+
+
+
+
+
+#include <ctime>
+#include <random>
+
+namespace Catch {
+
+    std::uint32_t generateRandomSeed( GenerateFrom from ) {
+        switch ( from ) {
+        case GenerateFrom::Time:
+            return static_cast<std::uint32_t>( std::time( nullptr ) );
+
+        case GenerateFrom::Default:
+        case GenerateFrom::RandomDevice:
+            // In theory, a platform could have random_device that returns just
+            // 16 bits. That is still some randomness, so we don't care too much
+            return static_cast<std::uint32_t>( std::random_device{}() );
+
+        default:
+            CATCH_ERROR("Unknown generation method");
+        }
+    }
+
+} // end namespace Catch
+
+
+
+
+namespace Catch {
+
+    ReporterRegistry::ReporterRegistry() {
+        // Because it is impossible to move out of initializer list,
+        // we have to add the elements manually
+        m_factories["Automake"] = Detail::make_unique<ReporterFactory<AutomakeReporter>>();
+        m_factories["compact"] = Detail::make_unique<ReporterFactory<CompactReporter>>();
+        m_factories["console"] = Detail::make_unique<ReporterFactory<ConsoleReporter>>();
+        m_factories["JUnit"] = Detail::make_unique<ReporterFactory<JunitReporter>>();
+        m_factories["SonarQube"] = Detail::make_unique<ReporterFactory<SonarQubeReporter>>();
+        m_factories["TAP"] = Detail::make_unique<ReporterFactory<TAPReporter>>();
+        m_factories["TeamCity"] = Detail::make_unique<ReporterFactory<TeamCityReporter>>();
+        m_factories["XML"] = Detail::make_unique<ReporterFactory<XmlReporter>>();
+    }
+
+    ReporterRegistry::~ReporterRegistry() = default;
+
+
+    IEventListenerPtr ReporterRegistry::create( std::string const& name, ReporterConfig&& config ) const {
+        auto it =  m_factories.find( name );
+        if( it == m_factories.end() )
+            return nullptr;
+        return it->second->create( CATCH_MOVE(config) );
+    }
+
+    void ReporterRegistry::registerReporter( std::string const& name, IReporterFactoryPtr factory ) {
+        CATCH_ENFORCE( name.find( "::" ) == name.npos,
+                       "'::' is not allowed in reporter name: '" + name + '\'' );
+        auto ret = m_factories.emplace(name, CATCH_MOVE(factory));
+        CATCH_ENFORCE( ret.second, "reporter using '" + name + "' as name was already registered" );
+    }
+    void ReporterRegistry::registerListener(
+        Detail::unique_ptr<EventListenerFactory> factory ) {
+        m_listeners.push_back( CATCH_MOVE(factory) );
+    }
+
+    IReporterRegistry::FactoryMap const& ReporterRegistry::getFactories() const {
+        return m_factories;
+    }
+    IReporterRegistry::Listeners const& ReporterRegistry::getListeners() const {
+        return m_listeners;
+    }
+
+}
+
+
+
+
+
+#include <algorithm>
+
+namespace Catch {
+
+    namespace {
+        struct kvPair {
+            StringRef key, value;
+        };
+
+        kvPair splitKVPair(StringRef kvString) {
+            auto splitPos = static_cast<size_t>( std::distance(
+                kvString.begin(),
+                std::find( kvString.begin(), kvString.end(), '=' ) ) );
+
+            return { kvString.substr( 0, splitPos ),
+                     kvString.substr( splitPos + 1, kvString.size() ) };
+        }
+    }
+
+    namespace Detail {
+        std::vector<std::string> splitReporterSpec( StringRef reporterSpec ) {
+            static constexpr auto separator = "::";
+            static constexpr size_t separatorSize = 2;
+
+            size_t separatorPos = 0;
+            auto findNextSeparator = [&reporterSpec]( size_t startPos ) {
+                static_assert(
+                    separatorSize == 2,
+                    "The code below currently assumes 2 char separator" );
+
+                auto currentPos = startPos;
+                do {
+                    while ( currentPos < reporterSpec.size() &&
+                            reporterSpec[currentPos] != separator[0] ) {
+                        ++currentPos;
+                    }
+                    if ( currentPos + 1 < reporterSpec.size() &&
+                         reporterSpec[currentPos + 1] == separator[1] ) {
+                        return currentPos;
+                    }
+                    ++currentPos;
+                } while ( currentPos < reporterSpec.size() );
+
+                return static_cast<size_t>( -1 );
+            };
+
+            std::vector<std::string> parts;
+
+            while ( separatorPos < reporterSpec.size() ) {
+                const auto nextSeparator = findNextSeparator( separatorPos );
+                parts.push_back( static_cast<std::string>( reporterSpec.substr(
+                    separatorPos, nextSeparator - separatorPos ) ) );
+
+                if ( nextSeparator == static_cast<size_t>( -1 ) ) {
+                    break;
+                }
+                separatorPos = nextSeparator + separatorSize;
+            }
+
+            // Handle a separator at the end.
+            // This is not a valid spec, but we want to do validation in a
+            // centralized place
+            if ( separatorPos == reporterSpec.size() ) {
+                parts.emplace_back();
+            }
+
+            return parts;
+        }
+
+        Optional<ColourMode> stringToColourMode( StringRef colourMode ) {
+            if ( colourMode == "default" ) {
+                return ColourMode::PlatformDefault;
+            } else if ( colourMode == "ansi" ) {
+                return ColourMode::ANSI;
+            } else if ( colourMode == "win32" ) {
+                return ColourMode::Win32;
+            } else if ( colourMode == "none" ) {
+                return ColourMode::None;
+            } else {
+                return {};
+            }
+        }
+    } // namespace Detail
+
+
+    bool operator==( ReporterSpec const& lhs, ReporterSpec const& rhs ) {
+        return lhs.m_name == rhs.m_name &&
+               lhs.m_outputFileName == rhs.m_outputFileName &&
+               lhs.m_colourMode == rhs.m_colourMode &&
+               lhs.m_customOptions == rhs.m_customOptions;
+    }
+
+    Optional<ReporterSpec> parseReporterSpec( StringRef reporterSpec ) {
+        auto parts = Detail::splitReporterSpec( reporterSpec );
+
+        assert( parts.size() > 0 && "Split should never return empty vector" );
+
+        std::map<std::string, std::string> kvPairs;
+        Optional<std::string> outputFileName;
+        Optional<ColourMode> colourMode;
+
+        // First part is always reporter name, so we skip it
+        for ( size_t i = 1; i < parts.size(); ++i ) {
+            auto kv = splitKVPair( parts[i] );
+            auto key = kv.key, value = kv.value;
+
+            if ( key.empty() || value.empty() ) {
+                return {};
+            } else if ( key[0] == 'X' ) {
+                // This is a reporter-specific option, we don't check these
+                // apart from basic sanity checks
+                if ( key.size() == 1 ) {
+                    return {};
+                }
+
+                auto ret = kvPairs.emplace( std::string(kv.key), std::string(kv.value) );
+                if ( !ret.second ) {
+                    // Duplicated key. We might want to handle this differently,
+                    // e.g. by overwriting the existing value?
+                    return {};
+                }
+            } else if ( key == "out" ) {
+                // Duplicated key
+                if ( outputFileName ) {
+                    return {};
+                }
+                outputFileName = static_cast<std::string>( value );
+            } else if ( key == "colour-mode" ) {
+                // Duplicated key
+                if ( colourMode ) {
+                    return {};
+                }
+                colourMode = Detail::stringToColourMode( value );
+                // Parsing failed
+                if ( !colourMode ) {
+                    return {};
+                }
+            } else {
+                // Unrecognized option
+                return {};
+            }
+        }
+
+        return ReporterSpec{ CATCH_MOVE( parts[0] ),
+                             CATCH_MOVE( outputFileName ),
+                             CATCH_MOVE( colourMode ),
+                             CATCH_MOVE( kvPairs ) };
+    }
+
+ReporterSpec::ReporterSpec(
+        std::string name,
+        Optional<std::string> outputFileName,
+        Optional<ColourMode> colourMode,
+        std::map<std::string, std::string> customOptions ):
+        m_name( CATCH_MOVE( name ) ),
+        m_outputFileName( CATCH_MOVE( outputFileName ) ),
+        m_colourMode( CATCH_MOVE( colourMode ) ),
+        m_customOptions( CATCH_MOVE( customOptions ) ) {}
+
+} // namespace Catch
+
+
+
+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
+
+
+
+#include <cstdio>
+#include <sstream>
+#include <vector>
+
+namespace Catch {
+
+    // This class encapsulates the idea of a pool of ostringstreams that can be reused.
+    struct StringStreams {
+        std::vector<Detail::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( Detail::make_unique<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 );
+    }
+
+    std::string ReusableStringStream::str() const {
+        return static_cast<std::ostringstream*>( m_oss )->str();
+    }
+
+    void ReusableStringStream::str( std::string const& str ) {
+        static_cast<std::ostringstream*>( m_oss )->str( str );
+    }
+
+
+}
+
+
+
+
+#include <cassert>
+#include <algorithm>
+
+namespace Catch {
+
+    namespace Generators {
+        struct GeneratorTracker : TestCaseTracking::TrackerBase, IGeneratorTracker {
+            GeneratorBasePtr m_generator;
+
+            GeneratorTracker( TestCaseTracking::NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
+            :   TrackerBase( nameAndLocation, ctx, parent )
+            {}
+            ~GeneratorTracker() override;
+
+            static GeneratorTracker& acquire( TrackerContext& ctx, TestCaseTracking::NameAndLocation const& nameAndLocation ) {
+                GeneratorTracker* tracker;
+
+                ITracker& currentTracker = ctx.currentTracker();
+                // Under specific circumstances, the generator we want
+                // to acquire is also the current tracker. If this is
+                // the case, we have to avoid looking through current
+                // tracker's children, and instead return the current
+                // tracker.
+                // A case where this check is important is e.g.
+                //     for (int i = 0; i < 5; ++i) {
+                //         int n = GENERATE(1, 2);
+                //     }
+                //
+                // without it, the code above creates 5 nested generators.
+                if ( currentTracker.nameAndLocation() == nameAndLocation ) {
+                    auto thisTracker =
+                        currentTracker.parent()->findChild( nameAndLocation );
+                    assert( thisTracker );
+                    assert( thisTracker->isGeneratorTracker() );
+                    tracker = static_cast<GeneratorTracker*>( thisTracker );
+                } else if ( ITracker* childTracker =
+                                currentTracker.findChild( nameAndLocation ) ) {
+                    assert( childTracker );
+                    assert( childTracker->isGeneratorTracker() );
+                    tracker = static_cast<GeneratorTracker*>( childTracker );
+                } else {
+                    auto newTracker =
+                        Catch::Detail::make_unique<GeneratorTracker>(
+                            nameAndLocation, ctx, &currentTracker );
+                    tracker = newTracker.get();
+                    currentTracker.addChild( CATCH_MOVE(newTracker) );
+                }
+
+                if( !tracker->isComplete() ) {
+                    tracker->open();
+                }
+
+                return *tracker;
+            }
+
+            // TrackerBase interface
+            bool isGeneratorTracker() const override { return true; }
+            auto hasGenerator() const -> bool override {
+                return !!m_generator;
+            }
+            void close() override {
+                TrackerBase::close();
+                // If a generator has a child (it is followed by a section)
+                // and none of its children have started, then we must wait
+                // until later to start consuming its values.
+                // This catches cases where `GENERATE` is placed between two
+                // `SECTION`s.
+                // **The check for m_children.empty cannot be removed**.
+                // doing so would break `GENERATE` _not_ followed by `SECTION`s.
+                const bool should_wait_for_child = [&]() {
+                    // No children -> nobody to wait for
+                    if ( m_children.empty() ) {
+                        return false;
+                    }
+                    // If at least one child started executing, don't wait
+                    if ( std::find_if(
+                             m_children.begin(),
+                             m_children.end(),
+                             []( TestCaseTracking::ITrackerPtr const& tracker ) {
+                                 return tracker->hasStarted();
+                             } ) != m_children.end() ) {
+                        return false;
+                    }
+
+                    // No children have started. We need to check if they _can_
+                    // start, and thus we should wait for them, or they cannot
+                    // start (due to filters), and we shouldn't wait for them
+                    ITracker* parent = m_parent;
+                    // This is safe: there is always at least one section
+                    // tracker in a test case tracking tree
+                    while ( !parent->isSectionTracker() ) {
+                        parent = parent->parent();
+                    }
+                    assert( parent &&
+                            "Missing root (test case) level section" );
+
+                    auto const& parentSection =
+                        static_cast<SectionTracker const&>( *parent );
+                    auto const& filters = parentSection.getFilters();
+                    // No filters -> no restrictions on running sections
+                    if ( filters.empty() ) {
+                        return true;
+                    }
+
+                    for ( auto const& child : m_children ) {
+                        if ( child->isSectionTracker() &&
+                             std::find(
+                                 filters.begin(),
+                                 filters.end(),
+                                 static_cast<SectionTracker const&>( *child )
+                                     .trimmedName() ) != filters.end() ) {
+                            return true;
+                        }
+                    }
+                    return false;
+                }();
+
+                // This check is a bit tricky, because m_generator->next()
+                // has a side-effect, where it consumes generator's current
+                // value, but we do not want to invoke the side-effect if
+                // this generator is still waiting for any child to start.
+                if ( should_wait_for_child ||
+                     ( m_runState == CompletedSuccessfully &&
+                       m_generator->countedNext() ) ) {
+                    m_children.clear();
+                    m_runState = Executing;
+                }
+            }
+
+            // IGeneratorTracker interface
+            auto getGenerator() const -> GeneratorBasePtr const& override {
+                return m_generator;
+            }
+            void setGenerator( GeneratorBasePtr&& generator ) override {
+                m_generator = CATCH_MOVE( generator );
+            }
+        };
+        GeneratorTracker::~GeneratorTracker() = default;
+    }
+
+    RunContext::RunContext(IConfig const* _config, IEventListenerPtr&& reporter)
+    :   m_runInfo(_config->name()),
+        m_context(getCurrentMutableContext()),
+        m_config(_config),
+        m_reporter(CATCH_MOVE(reporter)),
+        m_lastAssertionInfo{ StringRef(), SourceLineInfo("",0), StringRef(), ResultDisposition::Normal },
+        m_includeSuccessfulResults( m_config->includeSuccessfulResults() || m_reporter->getPreferences().shouldReportAllAssertions )
+    {
+        m_context.setResultCapture(this);
+        m_reporter->testRunStarting(m_runInfo);
+    }
+
+    RunContext::~RunContext() {
+        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting()));
+    }
+
+    Totals RunContext::runTest(TestCaseHandle const& testCase) {
+        const 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());
+
+        // We intentionally only seed the internal RNG once per test case,
+        // before it is first invoked. The reason for that is a complex
+        // interplay of generator/section implementation details and the
+        // Random*Generator types.
+        //
+        // The issue boils down to us needing to seed the Random*Generators
+        // with different seed each, so that they return different sequences
+        // of random numbers. We do this by giving them a number from the
+        // shared RNG instance as their seed.
+        //
+        // However, this runs into an issue if the reseeding happens each
+        // time the test case is entered (as opposed to first time only),
+        // because multiple generators could get the same seed, e.g. in
+        // ```cpp
+        // TEST_CASE() {
+        //     auto i = GENERATE(take(10, random(0, 100));
+        //     SECTION("A") {
+        //         auto j = GENERATE(take(10, random(0, 100));
+        //     }
+        //     SECTION("B") {
+        //         auto k = GENERATE(take(10, random(0, 100));
+        //     }
+        // }
+        // ```
+        // `i` and `j` would properly return values from different sequences,
+        // but `i` and `k` would return the same sequence, because their seed
+        // would be the same.
+        // (The reason their seeds would be the same is that the generator
+        //  for k would be initialized when the test case is entered the second
+        //  time, after the shared RNG instance was reset to the same value
+        //  it had when the generator for i was initialized.)
+        seedRng( *m_config );
+
+        uint64_t testRuns = 0;
+        do {
+            m_trackerContext.startCycle();
+            m_testCaseTracker = &SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(testInfo.name, testInfo.lineInfo));
+
+            m_reporter->testCasePartialStarting(testInfo, testRuns);
+
+            const auto beforeRunTotals = m_totals;
+            std::string oneRunCout, oneRunCerr;
+            runCurrentTest(oneRunCout, oneRunCerr);
+            redirectedCout += oneRunCout;
+            redirectedCerr += oneRunCerr;
+
+            const auto singleRunTotals = m_totals.delta(beforeRunTotals);
+            auto statsForOneRun = TestCaseStats(testInfo, singleRunTotals, oneRunCout, oneRunCerr, aborting());
+
+            m_reporter->testCasePartialEnded(statsForOneRun, testRuns);
+            ++testRuns;
+        } 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;
+    }
+
+
+    void RunContext::assertionEnded(AssertionResult const & result) {
+        if (result.getResultType() == ResultWas::Ok) {
+            m_totals.assertions.passed++;
+            m_lastAssertionPassed = true;
+        } else if (!result.succeeded()) {
+            m_lastAssertionPassed = false;
+            if (result.isOk()) {
+            }
+            else if( m_activeTestCase->getTestCaseInfo().okToFail() )
+                m_totals.assertions.failedButOk++;
+            else
+                m_totals.assertions.failed++;
+        }
+        else {
+            m_lastAssertionPassed = true;
+        }
+
+        m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals));
+
+        if (result.getResultType() != ResultWas::Warning)
+            m_messageScopes.clear();
+
+        // 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( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
+        using namespace Generators;
+        GeneratorTracker& tracker = GeneratorTracker::acquire(m_trackerContext,
+                                                              TestCaseTracking::NameAndLocation( static_cast<std::string>(generatorName), lineInfo ) );
+        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();
+        m_messageScopes.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::benchmarkPreparing( StringRef name ) {
+        m_reporter->benchmarkPreparing(name);
+    }
+    void RunContext::benchmarkStarting( BenchmarkInfo const& info ) {
+        m_reporter->benchmarkStarting( info );
+    }
+    void RunContext::benchmarkEnded( BenchmarkStats<> const& stats ) {
+        m_reporter->benchmarkEnded( stats );
+    }
+    void RunContext::benchmarkFailed( StringRef error ) {
+        m_reporter->benchmarkFailed( error );
+    }
+
+    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());
+    }
+
+    void RunContext::emplaceUnscopedMessage( MessageBuilder const& builder ) {
+        m_messageScopes.emplace_back( builder );
+    }
+
+    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 = static_cast<std::string>(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++;
+        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();
+        m_messageScopes.clear();
+    }
+
+    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 };
+
+        Timer timer;
+        CATCH_TRY {
+            if (m_reporter->getPreferences().shouldRedirectStdOut) {
+#if !defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
+                RedirectedStreams redirectedStreams(redirectedCout, redirectedCerr);
+
+                timer.start();
+                invokeActiveTestCase();
+#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();
+        m_messageScopes.clear();
+
+        SectionStats testCaseSectionStats(testCaseSection, assertions, duration, missingAssertions);
+        m_reporter->sectionEnded(testCaseSectionStats);
+    }
+
+    void RunContext::invokeActiveTestCase() {
+        // We need to engage a handler for signals/structured exceptions
+        // before running the tests themselves, or the binary can crash
+        // without failed test being reported.
+        FatalConditionHandlerGuard _(&m_fatalConditionhandler);
+        // We keep having issue where some compilers warn about an unused
+        // variable, even though the type has non-trivial constructor and
+        // destructor. This is annoying and ugly, but it makes them stfu.
+        (void)_;
+
+        m_activeTestCase->invoke();
+    }
+
+    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 message,
+            AssertionReaction& reaction
+    ) {
+        m_reporter->assertionStarting( info );
+
+        m_lastAssertionInfo = info;
+
+        AssertionResultData data( resultType, LazyExpression( false ) );
+        data.message = static_cast<std::string>(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");
+    }
+
+    void seedRng(IConfig const& config) {
+        sharedRng().seed(config.rngSeed());
+    }
+
+    unsigned int rngSeed() {
+        return getCurrentContext().getConfig()->rngSeed();
+    }
+
+}
+
+
+
+namespace Catch {
+
+    Section::Section( SectionInfo&& info ):
+        m_info( CATCH_MOVE( info ) ),
+        m_sectionIncluded(
+            getResultCapture().sectionStarted( m_info, m_assertions ) ) {
+        // Non-"included" sections will not use the timing information
+        // anyway, so don't bother with the potential syscall.
+        if (m_sectionIncluded) {
+            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
+
+
+
+#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() = default;
+
+    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
+
+
+
+#include <cstring>
+#include <ostream>
+
+namespace Catch {
+
+    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
+        os << info.file << ':' << info.line;
+#endif
+        return os;
+    }
+
+} // end namespace Catch
+
+
+
+
+namespace Catch {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+    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;
+    }
+#endif
+
+} // end namespace Catch
+
+
+
+
+
+#include <iostream>
+
+namespace Catch {
+
+// If you #define this you must implement these functions
+#if !defined( CATCH_CONFIG_NOSTDOUT )
+    std::ostream& cout() { return std::cout; }
+    std::ostream& cerr() { return std::cerr; }
+    std::ostream& clog() { return std::clog; }
+#endif
+
+} // namespace Catch
+
+
+
+#include <algorithm>
+#include <ostream>
+#include <cstring>
+#include <cctype>
+#include <vector>
+
+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( StringRef 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(), []( char c ) {
+            return toLower( c );
+        } );
+    }
+    std::string toLower( std::string const& s ) {
+        std::string lc = s;
+        toLowerInPlace( lc );
+        return lc;
+    }
+    char toLower(char c) {
+        return static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
+    }
+
+    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();
+    }
+
+    StringRef trim(StringRef ref) {
+        const auto is_ws = [](char c) {
+            return c == ' ' || c == '\t' || c == '\n' || c == '\r';
+        };
+        size_t real_begin = 0;
+        while (real_begin < ref.size() && is_ws(ref[real_begin])) { ++real_begin; }
+        size_t real_end = ref.size();
+        while (real_end > real_begin && is_ws(ref[real_end - 1])) { --real_end; }
+
+        return ref.substr(real_begin, real_end - real_begin);
+    }
+
+    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;
+    }
+
+    std::vector<StringRef> splitStringRef( StringRef str, char delimiter ) {
+        std::vector<StringRef> subStrings;
+        std::size_t start = 0;
+        for(std::size_t pos = 0; pos < str.size(); ++pos ) {
+            if( str[pos] == delimiter ) {
+                if( pos - start > 1 )
+                    subStrings.push_back( str.substr( start, pos-start ) );
+                start = pos+1;
+            }
+        }
+        if( start < str.size() )
+            subStrings.push_back( str.substr( start, str.size()-start ) );
+        return subStrings;
+    }
+
+    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;
+    }
+
+}
+
+
+
+#include <algorithm>
+#include <ostream>
+#include <cstring>
+#include <cstdint>
+
+namespace Catch {
+    StringRef::StringRef( char const* rawChars ) noexcept
+    : StringRef( rawChars, std::strlen(rawChars) )
+    {}
+
+    auto StringRef::operator == ( StringRef other ) const noexcept -> bool {
+        return m_size == other.m_size
+            && (std::memcmp( m_start, other.m_start, m_size ) == 0);
+    }
+
+    bool StringRef::operator<(StringRef rhs) const noexcept {
+        if (m_size < rhs.m_size) {
+            return strncmp(m_start, rhs.m_start, m_size) <= 0;
+        }
+        return strncmp(m_start, rhs.m_start, rhs.m_size) < 0;
+    }
+
+    int StringRef::compare( StringRef rhs ) const {
+        auto cmpResult =
+            strncmp( m_start, rhs.m_start, std::min( m_size, rhs.m_size ) );
+
+        // This means that strncmp found a difference before the strings
+        // ended, and we can return it directly
+        if ( cmpResult != 0 ) {
+            return cmpResult;
+        }
+
+        // If strings are equal up to length, then their comparison results on
+        // their size
+        if ( m_size < rhs.m_size ) {
+            return -1;
+        } else if ( m_size > rhs.m_size ) {
+            return 1;
+        } else {
+            return 0;
+        }
+    }
+
+    auto operator << ( std::ostream& os, StringRef str ) -> std::ostream& {
+        return os.write(str.data(), static_cast<std::streamsize>(str.size()));
+    }
+
+    std::string operator+(StringRef lhs, StringRef rhs) {
+        std::string ret;
+        ret.reserve(lhs.size() + rhs.size());
+        ret += lhs;
+        ret += rhs;
+        return ret;
+    }
+
+    auto operator+=( std::string& lhs, StringRef rhs ) -> std::string& {
+        lhs.append(rhs.data(), rhs.size());
+        return lhs;
+    }
+
+} // namespace Catch
+
+
+
+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() = default;
+
+    ITagAliasRegistry const& ITagAliasRegistry::get() {
+        return getRegistryHub().getTagAliasRegistry();
+    }
+
+} // end namespace Catch
+
+
+
+
+namespace Catch {
+    TestCaseInfoHasher::TestCaseInfoHasher( hash_t seed ): m_seed( seed ) {}
+
+    uint32_t TestCaseInfoHasher::operator()( TestCaseInfo const& t ) const {
+        // FNV-1a hash algorithm that is designed for uniqueness:
+        const hash_t prime = 1099511628211u;
+        hash_t hash = 14695981039346656037u;
+        for ( const char c : t.name ) {
+            hash ^= c;
+            hash *= prime;
+        }
+        for ( const char c : t.className ) {
+            hash ^= c;
+            hash *= prime;
+        }
+        for ( const Tag& tag : t.tags ) {
+            for ( const char c : tag.original ) {
+                hash ^= c;
+                hash *= prime;
+            }
+        }
+        hash ^= m_seed;
+        hash *= prime;
+        const uint32_t low{ static_cast<uint32_t>( hash ) };
+        const uint32_t high{ static_cast<uint32_t>( hash >> 32 ) };
+        return low * high;
+    }
+} // namespace Catch
+
+
+
+
+#include <algorithm>
+#include <set>
+
+namespace Catch {
+
+    std::vector<TestCaseHandle> sortTests( IConfig const& config, std::vector<TestCaseHandle> const& unsortedTestCases ) {
+        switch (config.runOrder()) {
+        case TestRunOrder::Declared:
+            return unsortedTestCases;
+
+        case TestRunOrder::LexicographicallySorted: {
+            std::vector<TestCaseHandle> sorted = unsortedTestCases;
+            std::sort(
+                sorted.begin(),
+                sorted.end(),
+                []( TestCaseHandle const& lhs, TestCaseHandle const& rhs ) {
+                    return lhs.getTestCaseInfo() < rhs.getTestCaseInfo();
+                }
+            );
+            return sorted;
+        }
+        case TestRunOrder::Randomized: {
+            seedRng(config);
+            using TestWithHash = std::pair<TestCaseInfoHasher::hash_t, TestCaseHandle>;
+
+            TestCaseInfoHasher h{ config.rngSeed() };
+            std::vector<TestWithHash> indexed_tests;
+            indexed_tests.reserve(unsortedTestCases.size());
+
+            for (auto const& handle : unsortedTestCases) {
+                indexed_tests.emplace_back(h(handle.getTestCaseInfo()), handle);
+            }
+
+            std::sort( indexed_tests.begin(),
+                       indexed_tests.end(),
+                       []( TestWithHash const& lhs, TestWithHash const& rhs ) {
+                           if ( lhs.first == rhs.first ) {
+                               return lhs.second.getTestCaseInfo() <
+                                      rhs.second.getTestCaseInfo();
+                           }
+                           return lhs.first < rhs.first;
+                       } );
+
+            std::vector<TestCaseHandle> randomized;
+            randomized.reserve(indexed_tests.size());
+
+            for (auto const& indexed : indexed_tests) {
+                randomized.push_back(indexed.second);
+            }
+
+            return randomized;
+        }
+        }
+
+        CATCH_INTERNAL_ERROR("Unknown test order value!");
+    }
+
+    bool isThrowSafe( TestCaseHandle const& testCase, IConfig const& config ) {
+        return !testCase.getTestCaseInfo().throws() || config.allowThrows();
+    }
+
+    bool matchTest( TestCaseHandle const& testCase, TestSpec const& testSpec, IConfig const& config ) {
+        return testSpec.matches( testCase.getTestCaseInfo() ) && isThrowSafe( testCase, config );
+    }
+
+    void
+    enforceNoDuplicateTestCases( std::vector<TestCaseHandle> const& tests ) {
+        auto testInfoCmp = []( TestCaseInfo const* lhs,
+                               TestCaseInfo const* rhs ) {
+            return *lhs < *rhs;
+        };
+        std::set<TestCaseInfo const*, decltype(testInfoCmp)> seenTests(testInfoCmp);
+        for ( auto const& test : tests ) {
+            const auto infoPtr = &test.getTestCaseInfo();
+            const auto prev = seenTests.insert( infoPtr );
+            CATCH_ENFORCE(
+                prev.second,
+                "error: test case \"" << infoPtr->name << "\", with tags \""
+                    << infoPtr->tagsAsString() << "\" already defined.\n"
+                    << "\tFirst seen at " << ( *prev.first )->lineInfo << "\n"
+                    << "\tRedefined at " << infoPtr->lineInfo );
+        }
+    }
+
+    std::vector<TestCaseHandle> filterTests( std::vector<TestCaseHandle> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
+        std::vector<TestCaseHandle> filtered;
+        filtered.reserve( testCases.size() );
+        for (auto const& testCase : testCases) {
+            if ((!testSpec.hasFilters() && !testCase.getTestCaseInfo().isHidden()) ||
+                (testSpec.hasFilters() && matchTest(testCase, testSpec, config))) {
+                filtered.push_back(testCase);
+            }
+        }
+        return createShard(filtered, config.shardCount(), config.shardIndex());
+    }
+    std::vector<TestCaseHandle> const& getAllTestCasesSorted( IConfig const& config ) {
+        return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config );
+    }
+
+    void TestRegistry::registerTest(Detail::unique_ptr<TestCaseInfo> testInfo, Detail::unique_ptr<ITestInvoker> testInvoker) {
+        m_handles.emplace_back(testInfo.get(), testInvoker.get());
+        m_viewed_test_infos.push_back(testInfo.get());
+        m_owned_test_infos.push_back(CATCH_MOVE(testInfo));
+        m_invokers.push_back(CATCH_MOVE(testInvoker));
+    }
+
+    std::vector<TestCaseInfo*> const& TestRegistry::getAllInfos() const {
+        return m_viewed_test_infos;
+    }
+
+    std::vector<TestCaseHandle> const& TestRegistry::getAllTests() const {
+        return m_handles;
+    }
+    std::vector<TestCaseHandle> const& TestRegistry::getAllTestsSorted( IConfig const& config ) const {
+        if( m_sortedFunctions.empty() )
+            enforceNoDuplicateTestCases( m_handles );
+
+        if(  m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) {
+            m_sortedFunctions = sortTests( config, m_handles );
+            m_currentSortOrder = config.runOrder();
+        }
+        return m_sortedFunctions;
+    }
+
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    void TestInvokerAsFunction::invoke() const {
+        m_testAsFunction();
+    }
+
+} // end namespace Catch
+
+
+
+
+#include <algorithm>
+#include <cassert>
+
+#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;
+
+    void ITracker::markAsNeedingAnotherRun() {
+        m_runState = NeedsAnotherRun;
+    }
+
+    void ITracker::addChild( ITrackerPtr&& child ) {
+        m_children.push_back( CATCH_MOVE(child) );
+    }
+
+    ITracker* ITracker::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->get() : nullptr;
+    }
+
+    bool ITracker::isSectionTracker() const { return false; }
+    bool ITracker::isGeneratorTracker() const { return false; }
+
+    bool ITracker::isSuccessfullyCompleted() const {
+        return m_runState == CompletedSuccessfully;
+    }
+
+    bool ITracker::isOpen() const {
+        return m_runState != NotStarted && !isComplete();
+    }
+
+    bool ITracker::hasStarted() const { return m_runState != NotStarted; }
+
+    void ITracker::openChild() {
+        if (m_runState != ExecutingChildren) {
+            m_runState = ExecutingChildren;
+            if (m_parent) {
+                m_parent->openChild();
+            }
+        }
+    }
+
+    ITracker& TrackerContext::startRun() {
+        using namespace std::string_literals;
+        m_rootTracker = Catch::Detail::make_unique<SectionTracker>(
+            NameAndLocation( "{root}"s, 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 ):
+        ITracker(nameAndLocation, parent),
+        m_ctx( ctx )
+    {}
+
+    bool TrackerBase::isComplete() const {
+        return m_runState == CompletedSuccessfully || m_runState == Failed;
+    }
+
+    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( std::all_of(m_children.begin(), m_children.end(), [](ITrackerPtr const& t){ return t->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::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 ),
+        m_trimmed_name(trim(nameAndLocation.name))
+    {
+        if( parent ) {
+            while( !parent->isSectionTracker() )
+                parent = parent->parent();
+
+            SectionTracker& parentSection = static_cast<SectionTracker&>( *parent );
+            addNextFilters( parentSection.m_filters );
+        }
+    }
+
+    bool SectionTracker::isComplete() const {
+        bool complete = true;
+
+        if (m_filters.empty()
+            || m_filters[0].empty()
+            || std::find(m_filters.begin(), m_filters.end(), m_trimmed_name) != m_filters.end()) {
+            complete = TrackerBase::isComplete();
+        }
+        return complete;
+    }
+
+    bool SectionTracker::isSectionTracker() const { return true; }
+
+    SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation ) {
+        SectionTracker* section;
+
+        ITracker& currentTracker = ctx.currentTracker();
+        if ( ITracker* childTracker =
+                 currentTracker.findChild( nameAndLocation ) ) {
+            assert( childTracker );
+            assert( childTracker->isSectionTracker() );
+            section = static_cast<SectionTracker*>( childTracker );
+        } else {
+            auto newSection = Catch::Detail::make_unique<SectionTracker>(
+                nameAndLocation, ctx, &currentTracker );
+            section = newSection.get();
+            currentTracker.addChild( CATCH_MOVE( newSection ) );
+        }
+        if( !ctx.completedCycle() )
+            section->tryOpen();
+        return *section;
+    }
+
+    void SectionTracker::tryOpen() {
+        if( !isComplete() )
+            open();
+    }
+
+    void SectionTracker::addInitialFilters( std::vector<std::string> const& filters ) {
+        if( !filters.empty() ) {
+            m_filters.reserve( m_filters.size() + filters.size() + 2 );
+            m_filters.emplace_back(StringRef{}); // Root - should never be consulted
+            m_filters.emplace_back(StringRef{}); // Test Case - not a section filter
+            m_filters.insert( m_filters.end(), filters.begin(), filters.end() );
+        }
+    }
+    void SectionTracker::addNextFilters( std::vector<StringRef> const& filters ) {
+        if( filters.size() > 1 )
+            m_filters.insert( m_filters.end(), filters.begin()+1, filters.end() );
+    }
+
+    std::vector<StringRef> const& SectionTracker::getFilters() const {
+        return m_filters;
+    }
+
+    StringRef SectionTracker::trimmedName() const {
+        return m_trimmed_name;
+    }
+
+} // namespace TestCaseTracking
+
+} // namespace Catch
+
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#endif
+
+
+
+#include <algorithm>
+#include <iterator>
+
+namespace Catch {
+
+    namespace {
+        StringRef extractClassName( StringRef classOrMethodName ) {
+            if ( !startsWith( classOrMethodName, '&' ) ) {
+                return classOrMethodName;
+            }
+
+            // Remove the leading '&' to avoid having to special case it later
+            const auto methodName =
+                classOrMethodName.substr( 1, classOrMethodName.size() );
+
+            auto reverseStart = std::make_reverse_iterator( methodName.end() );
+            auto reverseEnd = std::make_reverse_iterator( methodName.begin() );
+
+            // We make a simplifying assumption that ":" is only present
+            // in the input as part of "::" from C++ typenames (this is
+            // relatively safe assumption because the input is generated
+            // as stringification of type through preprocessor).
+            auto lastColons = std::find( reverseStart, reverseEnd, ':' ) + 1;
+            auto secondLastColons =
+                std::find( lastColons + 1, reverseEnd, ':' );
+
+            auto const startIdx = reverseEnd - secondLastColons;
+            auto const classNameSize = secondLastColons - lastColons - 1;
+
+            return methodName.substr(
+                static_cast<std::size_t>( startIdx ),
+                static_cast<std::size_t>( classNameSize ) );
+        }
+    } // namespace
+
+    Detail::unique_ptr<ITestInvoker> makeTestInvoker( void(*testAsFunction)() ) {
+        return Detail::make_unique<TestInvokerAsFunction>( testAsFunction );
+    }
+
+    AutoReg::AutoReg( Detail::unique_ptr<ITestInvoker> invoker, SourceLineInfo const& lineInfo, StringRef classOrMethod, NameAndTags const& nameAndTags ) noexcept {
+        CATCH_TRY {
+            getMutableRegistryHub()
+                    .registerTest(
+                        makeTestCaseInfo(
+                            extractClassName( classOrMethod ),
+                            nameAndTags,
+                            lineInfo),
+                        CATCH_MOVE(invoker)
+                    );
+        } CATCH_CATCH_ALL {
+            // Do not throw when constructing global objects, instead register the exception to be processed later
+            getMutableRegistryHub().registerStartupException();
+        }
+    }
+}
+
+
+
+
+
+namespace Catch {
+
+    TestSpecParser::TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {}
+
+    TestSpecParser& TestSpecParser::parse( std::string const& arg ) {
+        m_mode = None;
+        m_exclusion = false;
+        m_arg = m_tagAliases->expandAliases( arg );
+        m_escapeChars.clear();
+        m_substring.reserve(m_arg.size());
+        m_patternName.reserve(m_arg.size());
+        m_realPatternPos = 0;
+
+        for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
+          //if visitChar fails
+           if( !visitChar( m_arg[m_pos] ) ){
+               m_testSpec.m_invalidSpecs.push_back(arg);
+               break;
+           }
+        endMode();
+        return *this;
+    }
+    TestSpec TestSpecParser::testSpec() {
+        addFilter();
+        return CATCH_MOVE(m_testSpec);
+    }
+    bool TestSpecParser::visitChar( char c ) {
+        if( (m_mode != EscapedName) && (c == '\\') ) {
+            escape();
+            addCharToPattern(c);
+            return true;
+        }else if((m_mode != EscapedName) && (c == ',') )  {
+            return separate();
+        }
+
+        switch( m_mode ) {
+        case None:
+            if( processNoneChar( c ) )
+                return true;
+            break;
+        case Name:
+            processNameChar( c );
+            break;
+        case EscapedName:
+            endMode();
+            addCharToPattern(c);
+            return true;
+        default:
+        case Tag:
+        case QuotedName:
+            if( processOtherChar( c ) )
+                return true;
+            break;
+        }
+
+        m_substring += c;
+        if( !isControlChar( c ) ) {
+            m_patternName += c;
+            m_realPatternPos++;
+        }
+        return true;
+    }
+    // Two of the processing methods return true to signal the caller to return
+    // without adding the given character to the current pattern strings
+    bool TestSpecParser::processNoneChar( char c ) {
+        switch( c ) {
+        case ' ':
+            return true;
+        case '~':
+            m_exclusion = true;
+            return false;
+        case '[':
+            startNewMode( Tag );
+            return false;
+        case '"':
+            startNewMode( QuotedName );
+            return false;
+        default:
+            startNewMode( Name );
+            return false;
+        }
+    }
+    void TestSpecParser::processNameChar( char c ) {
+        if( c == '[' ) {
+            if( m_substring == "exclude:" )
+                m_exclusion = true;
+            else
+                endMode();
+            startNewMode( Tag );
+        }
+    }
+    bool TestSpecParser::processOtherChar( char c ) {
+        if( !isControlChar( c ) )
+            return false;
+        m_substring += c;
+        endMode();
+        return true;
+    }
+    void TestSpecParser::startNewMode( Mode mode ) {
+        m_mode = mode;
+    }
+    void TestSpecParser::endMode() {
+        switch( m_mode ) {
+        case Name:
+        case QuotedName:
+            return addNamePattern();
+        case Tag:
+            return addTagPattern();
+        case EscapedName:
+            revertBackToLastMode();
+            return;
+        case None:
+        default:
+            return startNewMode( None );
+        }
+    }
+    void TestSpecParser::escape() {
+        saveLastMode();
+        m_mode = EscapedName;
+        m_escapeChars.push_back(m_realPatternPos);
+    }
+    bool TestSpecParser::isControlChar( char c ) const {
+        switch( m_mode ) {
+            default:
+                return false;
+            case None:
+                return c == '~';
+            case Name:
+                return c == '[';
+            case EscapedName:
+                return true;
+            case QuotedName:
+                return c == '"';
+            case Tag:
+                return c == '[' || c == ']';
+        }
+    }
+
+    void TestSpecParser::addFilter() {
+        if( !m_currentFilter.m_required.empty() || !m_currentFilter.m_forbidden.empty() ) {
+            m_testSpec.m_filters.push_back( CATCH_MOVE(m_currentFilter) );
+            m_currentFilter = TestSpec::Filter();
+        }
+    }
+
+    void TestSpecParser::saveLastMode() {
+      lastMode = m_mode;
+    }
+
+    void TestSpecParser::revertBackToLastMode() {
+      m_mode = lastMode;
+    }
+
+    bool TestSpecParser::separate() {
+      if( (m_mode==QuotedName) || (m_mode==Tag) ){
+         //invalid argument, signal failure to previous scope.
+         m_mode = None;
+         m_pos = m_arg.size();
+         m_substring.clear();
+         m_patternName.clear();
+         m_realPatternPos = 0;
+         return false;
+      }
+      endMode();
+      addFilter();
+      return true; //success
+    }
+
+    std::string TestSpecParser::preprocessPattern() {
+        std::string token = m_patternName;
+        for (std::size_t i = 0; i < m_escapeChars.size(); ++i)
+            token = token.substr(0, m_escapeChars[i] - i) + token.substr(m_escapeChars[i] - i + 1);
+        m_escapeChars.clear();
+        if (startsWith(token, "exclude:")) {
+            m_exclusion = true;
+            token = token.substr(8);
+        }
+
+        m_patternName.clear();
+        m_realPatternPos = 0;
+
+        return token;
+    }
+
+    void TestSpecParser::addNamePattern() {
+        auto token = preprocessPattern();
+
+        if (!token.empty()) {
+            if (m_exclusion) {
+                m_currentFilter.m_forbidden.emplace_back(Detail::make_unique<TestSpec::NamePattern>(token, m_substring));
+            } else {
+                m_currentFilter.m_required.emplace_back(Detail::make_unique<TestSpec::NamePattern>(token, m_substring));
+            }
+        }
+        m_substring.clear();
+        m_exclusion = false;
+        m_mode = None;
+    }
+
+    void TestSpecParser::addTagPattern() {
+        auto token = preprocessPattern();
+
+        if (!token.empty()) {
+            // If the tag pattern is the "hide and tag" shorthand (e.g. [.foo])
+            // we have to create a separate hide tag and shorten the real one
+            if (token.size() > 1 && token[0] == '.') {
+                token.erase(token.begin());
+                if (m_exclusion) {
+                    m_currentFilter.m_forbidden.emplace_back(Detail::make_unique<TestSpec::TagPattern>(".", m_substring));
+                    m_currentFilter.m_forbidden.emplace_back(Detail::make_unique<TestSpec::TagPattern>(token, m_substring));
+                } else {
+                    m_currentFilter.m_required.emplace_back(Detail::make_unique<TestSpec::TagPattern>(".", m_substring));
+                    m_currentFilter.m_required.emplace_back(Detail::make_unique<TestSpec::TagPattern>(token, m_substring));
+                }
+            }
+            if (m_exclusion) {
+                m_currentFilter.m_forbidden.emplace_back(Detail::make_unique<TestSpec::TagPattern>(token, m_substring));
+            } else {
+                m_currentFilter.m_required.emplace_back(Detail::make_unique<TestSpec::TagPattern>(token, m_substring));
+            }
+        }
+        m_substring.clear();
+        m_exclusion = false;
+        m_mode = None;
+    }
+
+    TestSpec parseTestSpec( std::string const& arg ) {
+        return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec();
+    }
+
+} // namespace Catch
+
+
+
+#include <algorithm>
+#include <cstring>
+#include <ostream>
+
+namespace {
+    bool isWhitespace( char c ) {
+        return c == ' ' || c == '\t' || c == '\n' || c == '\r';
+    }
+
+    bool isBreakableBefore( char c ) {
+        static const char chars[] = "[({<|";
+        return std::memchr( chars, c, sizeof( chars ) - 1 ) != nullptr;
+    }
+
+    bool isBreakableAfter( char c ) {
+        static const char chars[] = "])}>.,:;*+-=&/\\";
+        return std::memchr( chars, c, sizeof( chars ) - 1 ) != nullptr;
+    }
+
+    bool isBoundary( std::string const& line, size_t at ) {
+        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] );
+    }
+
+} // namespace
+
+namespace Catch {
+    namespace TextFlow {
+
+        void Column::const_iterator::calcLength() {
+            m_addHyphen = false;
+            m_parsedTo = m_lineStart;
+
+            std::string const& current_line = m_column.m_string;
+            if ( current_line[m_lineStart] == '\n' ) {
+                ++m_parsedTo;
+            }
+
+            const auto maxLineLength = m_column.m_width - indentSize();
+            const auto maxParseTo = std::min(current_line.size(), m_lineStart + maxLineLength);
+            while ( m_parsedTo < maxParseTo &&
+                    current_line[m_parsedTo] != '\n' ) {
+                ++m_parsedTo;
+            }
+
+            // If we encountered a newline before the column is filled,
+            // then we linebreak at the newline and consider this line
+            // finished.
+            if ( m_parsedTo < m_lineStart + maxLineLength ) {
+                m_lineLength = m_parsedTo - m_lineStart;
+            } else {
+                // Look for a natural linebreak boundary in the column
+                // (We look from the end, so that the first found boundary is
+                // the right one)
+                size_t newLineLength = maxLineLength;
+                while ( newLineLength > 0 && !isBoundary( current_line, m_lineStart + newLineLength ) ) {
+                    --newLineLength;
+                }
+                while ( newLineLength > 0 &&
+                        isWhitespace( current_line[m_lineStart + newLineLength - 1] ) ) {
+                    --newLineLength;
+                }
+
+                // If we found one, then that is where we linebreak
+                if ( newLineLength > 0 ) {
+                    m_lineLength = newLineLength;
+                } else {
+                    // Otherwise we have to split text with a hyphen
+                    m_addHyphen = true;
+                    m_lineLength = maxLineLength - 1;
+                }
+            }
+        }
+
+        size_t Column::const_iterator::indentSize() const {
+            auto initial =
+                m_lineStart == 0 ? m_column.m_initialIndent : std::string::npos;
+            return initial == std::string::npos ? m_column.m_indent : initial;
+        }
+
+        std::string
+        Column::const_iterator::addIndentAndSuffix( size_t position,
+                                              size_t length ) const {
+            std::string ret;
+            const auto desired_indent = indentSize();
+            ret.reserve( desired_indent + length + m_addHyphen );
+            ret.append( desired_indent, ' ' );
+            ret.append( m_column.m_string, position, length );
+            if ( m_addHyphen ) {
+                ret.push_back( '-' );
+            }
+
+            return ret;
+        }
+
+        Column::const_iterator::const_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_lineLength == 0 ) {
+                m_lineStart = m_column.m_string.size();
+            }
+        }
+
+        std::string Column::const_iterator::operator*() const {
+            assert( m_lineStart <= m_parsedTo );
+            return addIndentAndSuffix( m_lineStart, m_lineLength );
+        }
+
+        Column::const_iterator& Column::const_iterator::operator++() {
+            m_lineStart += m_lineLength;
+            std::string const& current_line = m_column.m_string;
+            if ( m_lineStart < current_line.size() && current_line[m_lineStart] == '\n' ) {
+                m_lineStart += 1;
+            } else {
+                while ( m_lineStart < current_line.size() &&
+                        isWhitespace( current_line[m_lineStart] ) ) {
+                    ++m_lineStart;
+                }
+            }
+
+            if ( m_lineStart != current_line.size() ) {
+                calcLength();
+            }
+            return *this;
+        }
+
+        Column::const_iterator Column::const_iterator::operator++( int ) {
+            const_iterator prev( *this );
+            operator++();
+            return prev;
+        }
+
+        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;
+        }
+
+        Column Spacer( size_t spaceWidth ) {
+            Column ret{ "" };
+            ret.width( spaceWidth );
+            return ret;
+        }
+
+        Columns::iterator::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() );
+            }
+        }
+
+        Columns::iterator::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() );
+            }
+        }
+
+        std::string Columns::iterator::operator*() const {
+            std::string row, padding;
+
+            for ( size_t i = 0; i < m_columns.size(); ++i ) {
+                const auto width = m_columns[i].width();
+                if ( m_iterators[i] != m_columns[i].end() ) {
+                    std::string col = *m_iterators[i];
+                    row += padding;
+                    row += col;
+
+                    padding.clear();
+                    if ( col.size() < width ) {
+                        padding.append( width - col.size(), ' ' );
+                    }
+                } else {
+                    padding.append( width, ' ' );
+                }
+            }
+            return row;
+        }
+
+        Columns::iterator& Columns::iterator::operator++() {
+            for ( size_t i = 0; i < m_columns.size(); ++i ) {
+                if ( m_iterators[i] != m_columns[i].end() ) {
+                    ++m_iterators[i];
+                }
+            }
+            return *this;
+        }
+
+        Columns::iterator Columns::iterator::operator++( int ) {
+            iterator prev( *this );
+            operator++();
+            return prev;
+        }
+
+        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;
+        }
+
+        Columns Column::operator+( Column const& other ) {
+            Columns cols;
+            cols += *this;
+            cols += other;
+            return cols;
+        }
+
+        Columns& Columns::operator+=( Column const& col ) {
+            m_columns.push_back( col );
+            return *this;
+        }
+
+        Columns Columns::operator+( Column const& col ) {
+            Columns combined = *this;
+            combined += col;
+            return combined;
+        }
+
+    } // namespace TextFlow
+} // namespace Catch
+
+
+
+
+#include <exception>
+
+namespace Catch {
+    bool uncaught_exceptions() {
+#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+        return false;
+#elif defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
+        return std::uncaught_exceptions() > 0;
+#else
+        return std::uncaught_exception();
+#endif
+  }
+} // end namespace Catch
+
+
+
+namespace Catch {
+
+    WildcardPattern::WildcardPattern( std::string const& pattern,
+                                      CaseSensitive caseSensitivity )
+    :   m_caseSensitivity( caseSensitivity ),
+        m_pattern( normaliseString( 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 == normaliseString( str );
+            case WildcardAtStart:
+                return endsWith( normaliseString( str ), m_pattern );
+            case WildcardAtEnd:
+                return startsWith( normaliseString( str ), m_pattern );
+            case WildcardAtBothEnds:
+                return contains( normaliseString( str ), m_pattern );
+            default:
+                CATCH_INTERNAL_ERROR( "Unknown enum" );
+        }
+    }
+
+    std::string WildcardPattern::normaliseString( std::string const& str ) const {
+        return trim( m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str );
+    }
+}
+
+
+// Note: swapping these two includes around causes MSVC to error out
+//       while in /permissive- mode. No, I don't know why.
+//       Tested on VS 2019, 18.{3, 4}.x
+
+#include <iomanip>
+#include <type_traits>
+
+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) {
+        std::ios_base::fmtflags f(os.flags());
+        os << "\\x"
+            << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
+            << static_cast<int>(c);
+        os.flags(f);
+    }
+
+    bool shouldNewline(XmlFormatting fmt) {
+        return !!(static_cast<std::underlying_type_t<XmlFormatting>>(fmt & XmlFormatting::Newline));
+    }
+
+    bool shouldIndent(XmlFormatting fmt) {
+        return !!(static_cast<std::underlying_type_t<XmlFormatting>>(fmt & XmlFormatting::Indent));
+    }
+
+} // anonymous namespace
+
+    XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs) {
+        return static_cast<XmlFormatting>(
+            static_cast<std::underlying_type_t<XmlFormatting>>(lhs) |
+            static_cast<std::underlying_type_t<XmlFormatting>>(rhs)
+        );
+    }
+
+    XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs) {
+        return static_cast<XmlFormatting>(
+            static_cast<std::underlying_type_t<XmlFormatting>>(lhs) &
+            static_cast<std::underlying_type_t<XmlFormatting>>(rhs)
+        );
+    }
+
+
+    XmlEncode::XmlEncode( StringRef 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 ) {
+            unsigned char c = static_cast<unsigned char>(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) {
+                    unsigned char nc = static_cast<unsigned char>(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, XmlFormatting fmt )
+    :   m_writer( writer ),
+        m_fmt(fmt)
+    {}
+
+    XmlWriter::ScopedElement::ScopedElement( ScopedElement&& other ) noexcept
+    :   m_writer( other.m_writer ),
+        m_fmt(other.m_fmt)
+    {
+        other.m_writer = nullptr;
+        other.m_fmt = XmlFormatting::None;
+    }
+    XmlWriter::ScopedElement& XmlWriter::ScopedElement::operator=( ScopedElement&& other ) noexcept {
+        if ( m_writer ) {
+            m_writer->endElement();
+        }
+        m_writer = other.m_writer;
+        other.m_writer = nullptr;
+        m_fmt = other.m_fmt;
+        other.m_fmt = XmlFormatting::None;
+        return *this;
+    }
+
+
+    XmlWriter::ScopedElement::~ScopedElement() {
+        if (m_writer) {
+            m_writer->endElement(m_fmt);
+        }
+    }
+
+    XmlWriter::ScopedElement&
+    XmlWriter::ScopedElement::writeText( StringRef text, XmlFormatting fmt ) {
+        m_writer->writeText( text, fmt );
+        return *this;
+    }
+
+    XmlWriter::ScopedElement&
+    XmlWriter::ScopedElement::writeAttribute( StringRef name,
+                                              StringRef attribute ) {
+        m_writer->writeAttribute( name, attribute );
+        return *this;
+    }
+
+
+    XmlWriter::XmlWriter( std::ostream& os ) : m_os( os )
+    {
+        writeDeclaration();
+    }
+
+    XmlWriter::~XmlWriter() {
+        while (!m_tags.empty()) {
+            endElement();
+        }
+        newlineIfNecessary();
+    }
+
+    XmlWriter& XmlWriter::startElement( std::string const& name, XmlFormatting fmt ) {
+        ensureTagClosed();
+        newlineIfNecessary();
+        if (shouldIndent(fmt)) {
+            m_os << m_indent;
+            m_indent += "  ";
+        }
+        m_os << '<' << name;
+        m_tags.push_back( name );
+        m_tagIsOpen = true;
+        applyFormatting(fmt);
+        return *this;
+    }
+
+    XmlWriter::ScopedElement XmlWriter::scopedElement( std::string const& name, XmlFormatting fmt ) {
+        ScopedElement scoped( this, fmt );
+        startElement( name, fmt );
+        return scoped;
+    }
+
+    XmlWriter& XmlWriter::endElement(XmlFormatting fmt) {
+        m_indent = m_indent.substr(0, m_indent.size() - 2);
+
+        if( m_tagIsOpen ) {
+            m_os << "/>";
+            m_tagIsOpen = false;
+        } else {
+            newlineIfNecessary();
+            if (shouldIndent(fmt)) {
+                m_os << m_indent;
+            }
+            m_os << "</" << m_tags.back() << '>';
+        }
+        m_os << std::flush;
+        applyFormatting(fmt);
+        m_tags.pop_back();
+        return *this;
+    }
+
+    XmlWriter& XmlWriter::writeAttribute( StringRef name,
+                                          StringRef attribute ) {
+        if( !name.empty() && !attribute.empty() )
+            m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
+        return *this;
+    }
+
+    XmlWriter& XmlWriter::writeAttribute( StringRef name, bool attribute ) {
+        writeAttribute(name, (attribute ? "true"_sr : "false"_sr));
+        return *this;
+    }
+
+    XmlWriter& XmlWriter::writeAttribute( StringRef name,
+                                          char const* attribute ) {
+        writeAttribute( name, StringRef( attribute ) );
+        return *this;
+    }
+
+    XmlWriter& XmlWriter::writeText( StringRef text, XmlFormatting fmt ) {
+        CATCH_ENFORCE(!m_tags.empty(), "Cannot write text as top level element");
+        if( !text.empty() ){
+            bool tagWasOpen = m_tagIsOpen;
+            ensureTagClosed();
+            if (tagWasOpen && shouldIndent(fmt)) {
+                m_os << m_indent;
+            }
+            m_os << XmlEncode( text, XmlEncode::ForTextNodes );
+            applyFormatting(fmt);
+        }
+        return *this;
+    }
+
+    XmlWriter& XmlWriter::writeComment( StringRef text, XmlFormatting fmt ) {
+        ensureTagClosed();
+        if (shouldIndent(fmt)) {
+            m_os << m_indent;
+        }
+        m_os << "<!-- " << text << " -->";
+        applyFormatting(fmt);
+        return *this;
+    }
+
+    void XmlWriter::writeStylesheetRef( StringRef url ) {
+        m_os << R"(<?xml-stylesheet type="text/xsl" href=")" << url << R"("?>)" << '\n';
+    }
+
+    void XmlWriter::ensureTagClosed() {
+        if( m_tagIsOpen ) {
+            m_os << '>' << std::flush;
+            newlineIfNecessary();
+            m_tagIsOpen = false;
+        }
+    }
+
+    void XmlWriter::applyFormatting(XmlFormatting fmt) {
+        m_needsNewline = shouldNewline(fmt);
+    }
+
+    void XmlWriter::writeDeclaration() {
+        m_os << R"(<?xml version="1.0" encoding="UTF-8"?>)" << '\n';
+    }
+
+    void XmlWriter::newlineIfNecessary() {
+        if( m_needsNewline ) {
+            m_os << '\n' << std::flush;
+            m_needsNewline = false;
+        }
+    }
+}
+
+
+
+
+
+namespace Catch {
+namespace Matchers {
+
+    std::string MatcherUntypedBase::toString() const {
+        if (m_cachedToString.empty()) {
+            m_cachedToString = describe();
+        }
+        return m_cachedToString;
+    }
+
+    MatcherUntypedBase::~MatcherUntypedBase() = default;
+
+} // namespace Matchers
+} // namespace Catch
+
+
+
+
+namespace Catch {
+namespace Matchers {
+
+    std::string IsEmptyMatcher::describe() const {
+        return "is empty";
+    }
+
+    std::string HasSizeMatcher::describe() const {
+        ReusableStringStream sstr;
+        sstr << "has size == " << m_target_size;
+        return sstr.str();
+    }
+
+    IsEmptyMatcher IsEmpty() {
+        return {};
+    }
+
+    HasSizeMatcher SizeIs(std::size_t sz) {
+        return HasSizeMatcher{ sz };
+    }
+
+} // end namespace Matchers
+} // end namespace Catch
+
+
+
+namespace Catch {
+namespace Matchers {
+
+bool ExceptionMessageMatcher::match(std::exception const& ex) const {
+    return ex.what() == m_message;
+}
+
+std::string ExceptionMessageMatcher::describe() const {
+    return "exception message matches \"" + m_message + '"';
+}
+
+ExceptionMessageMatcher Message(std::string const& message) {
+    return ExceptionMessageMatcher(message);
+}
+
+} // namespace Matchers
+} // namespace Catch
+
+
+
+#include <algorithm>
+#include <cmath>
+#include <cstdlib>
+#include <cstdint>
+#include <sstream>
+#include <iomanip>
+#include <limits>
+
+
+namespace Catch {
+namespace {
+
+    template <typename FP>
+    bool almostEqualUlps(FP lhs, FP rhs, uint64_t 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;
+        }
+
+        // This should also handle positive and negative zeros, infinities
+        const auto ulpDist = ulpDistance(lhs, rhs);
+
+        return ulpDist <= maxUlpDiff;
+    }
+
+#if defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
+
+    float nextafter(float x, float y) {
+        return ::nextafterf(x, y);
+    }
+
+    double nextafter(double x, double y) {
+        return ::nextafter(x, y);
+    }
+
+#endif // ^^^ CATCH_CONFIG_GLOBAL_NEXTAFTER ^^^
+
+template <typename FP>
+FP step(FP start, FP direction, uint64_t steps) {
+    for (uint64_t i = 0; i < steps; ++i) {
+#if defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
+        start = Catch::nextafter(start, direction);
+#else
+        start = std::nextafter(start, direction);
+#endif
+    }
+    return start;
+}
+
+// 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);
+}
+
+template <typename FloatingPoint>
+void write(std::ostream& out, FloatingPoint num) {
+    out << std::scientific
+        << std::setprecision(std::numeric_limits<FloatingPoint>::max_digits10 - 1)
+        << num;
+}
+
+} // end anonymous namespace
+
+namespace Matchers {
+namespace Detail {
+
+    enum class FloatingPointKind : uint8_t {
+        Float,
+        Double
+    };
+
+} // end namespace Detail
+
+
+    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.");
+    }
+
+    // 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);
+    }
+
+    std::string WithinAbsMatcher::describe() const {
+        return "is within " + ::Catch::Detail::stringify(m_margin) + " of " + ::Catch::Detail::stringify(m_target);
+    }
+
+
+    WithinUlpsMatcher::WithinUlpsMatcher(double target, uint64_t ulps, Detail::FloatingPointKind baseType)
+        :m_target{ target }, m_ulps{ ulps }, m_type{ baseType } {
+        CATCH_ENFORCE(m_type == Detail::FloatingPointKind::Double
+                   || m_ulps < (std::numeric_limits<uint32_t>::max)(),
+            "Provided ULP is impossibly large for a float comparison.");
+        CATCH_ENFORCE( std::numeric_limits<double>::is_iec559,
+                       "WithinUlp matcher only supports platforms with "
+                       "IEEE-754 compatible floating point representation" );
+    }
+
+#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
+
+    bool WithinUlpsMatcher::match(double const& matchee) const {
+        switch (m_type) {
+        case Detail::FloatingPointKind::Float:
+            return almostEqualUlps<float>(static_cast<float>(matchee), static_cast<float>(m_target), m_ulps);
+        case Detail::FloatingPointKind::Double:
+            return almostEqualUlps<double>(matchee, m_target, m_ulps);
+        default:
+            CATCH_INTERNAL_ERROR( "Unknown Detail::FloatingPointKind value" );
+        }
+    }
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
+    std::string WithinUlpsMatcher::describe() const {
+        std::stringstream ret;
+
+        ret << "is within " << m_ulps << " ULPs of ";
+
+        if (m_type == Detail::FloatingPointKind::Float) {
+            write(ret, static_cast<float>(m_target));
+            ret << 'f';
+        } else {
+            write(ret, m_target);
+        }
+
+        ret << " ([";
+        if (m_type == Detail::FloatingPointKind::Double) {
+            write( ret,
+                   step( m_target,
+                         -std::numeric_limits<double>::infinity(),
+                         m_ulps ) );
+            ret << ", ";
+            write( ret,
+                   step( m_target,
+                         std::numeric_limits<double>::infinity(),
+                         m_ulps ) );
+        } else {
+            // We have to cast INFINITY to float because of MinGW, see #1782
+            write( ret,
+                   step( static_cast<float>( m_target ),
+                         -std::numeric_limits<float>::infinity(),
+                         m_ulps ) );
+            ret << ", ";
+            write( ret,
+                   step( static_cast<float>( m_target ),
+                         std::numeric_limits<float>::infinity(),
+                         m_ulps ) );
+        }
+        ret << "])";
+
+        return ret.str();
+    }
+
+    WithinRelMatcher::WithinRelMatcher(double target, double epsilon):
+        m_target(target),
+        m_epsilon(epsilon){
+        CATCH_ENFORCE(m_epsilon >= 0., "Relative comparison with epsilon <  0 does not make sense.");
+        CATCH_ENFORCE(m_epsilon  < 1., "Relative comparison with epsilon >= 1 does not make sense.");
+    }
+
+    bool WithinRelMatcher::match(double const& matchee) const {
+        const auto relMargin = m_epsilon * (std::max)(std::fabs(matchee), std::fabs(m_target));
+        return marginComparison(matchee, m_target,
+                                std::isinf(relMargin)? 0 : relMargin);
+    }
+
+    std::string WithinRelMatcher::describe() const {
+        Catch::ReusableStringStream sstr;
+        sstr << "and " << m_target << " are within " << m_epsilon * 100. << "% of each other";
+        return sstr.str();
+    }
+
+
+WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
+    return WithinUlpsMatcher(target, maxUlpDiff, Detail::FloatingPointKind::Double);
+}
+
+WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
+    return WithinUlpsMatcher(target, maxUlpDiff, Detail::FloatingPointKind::Float);
+}
+
+WithinAbsMatcher WithinAbs(double target, double margin) {
+    return WithinAbsMatcher(target, margin);
+}
+
+WithinRelMatcher WithinRel(double target, double eps) {
+    return WithinRelMatcher(target, eps);
+}
+
+WithinRelMatcher WithinRel(double target) {
+    return WithinRelMatcher(target, std::numeric_limits<double>::epsilon() * 100);
+}
+
+WithinRelMatcher WithinRel(float target, float eps) {
+    return WithinRelMatcher(target, eps);
+}
+
+WithinRelMatcher WithinRel(float target) {
+    return WithinRelMatcher(target, std::numeric_limits<float>::epsilon() * 100);
+}
+
+
+} // namespace Matchers
+} // namespace Catch
+
+
+
+
+std::string Catch::Matchers::Detail::finalizeDescription(const std::string& desc) {
+    if (desc.empty()) {
+        return "matches undescribed predicate";
+    } else {
+        return "matches predicate: \"" + desc + '"';
+    }
+}
+
+
+
+namespace Catch {
+    namespace Matchers {
+        std::string AllTrueMatcher::describe() const { return "contains only true"; }
+
+        AllTrueMatcher AllTrue() { return AllTrueMatcher{}; }
+
+        std::string NoneTrueMatcher::describe() const { return "contains no true"; }
+
+        NoneTrueMatcher NoneTrue() { return NoneTrueMatcher{}; }
+
+        std::string AnyTrueMatcher::describe() const { return "contains at least one true"; }
+
+        AnyTrueMatcher AnyTrue() { return AnyTrueMatcher{}; }
+    } // namespace Matchers
+} // namespace Catch
+
+
+
+#include <regex>
+
+namespace Catch {
+namespace Matchers {
+
+    CasedString::CasedString( std::string const& str, CaseSensitive 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;
+    }
+    StringRef CasedString::caseSensitivitySuffix() const {
+        return m_caseSensitivity == CaseSensitive::Yes
+                   ? StringRef()
+                   : " (case insensitive)"_sr;
+    }
+
+
+    StringMatcherBase::StringMatcherBase( StringRef 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;
+    }
+
+    StringEqualsMatcher::StringEqualsMatcher( CasedString const& comparator ) : StringMatcherBase( "equals"_sr, comparator ) {}
+
+    bool StringEqualsMatcher::match( std::string const& source ) const {
+        return m_comparator.adjustString( source ) == m_comparator.m_str;
+    }
+
+
+    StringContainsMatcher::StringContainsMatcher( CasedString const& comparator ) : StringMatcherBase( "contains"_sr, comparator ) {}
+
+    bool StringContainsMatcher::match( std::string const& source ) const {
+        return contains( m_comparator.adjustString( source ), m_comparator.m_str );
+    }
+
+
+    StartsWithMatcher::StartsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "starts with"_sr, 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"_sr, 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 caseSensitivity): m_regex(CATCH_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::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::Yes)? " case sensitively" : " case insensitively");
+    }
+
+
+    StringEqualsMatcher Equals( std::string const& str, CaseSensitive caseSensitivity ) {
+        return StringEqualsMatcher( CasedString( str, caseSensitivity) );
+    }
+    StringContainsMatcher ContainsSubstring( std::string const& str, CaseSensitive caseSensitivity ) {
+        return StringContainsMatcher( CasedString( str, caseSensitivity) );
+    }
+    EndsWithMatcher EndsWith( std::string const& str, CaseSensitive caseSensitivity ) {
+        return EndsWithMatcher( CasedString( str, caseSensitivity) );
+    }
+    StartsWithMatcher StartsWith( std::string const& str, CaseSensitive caseSensitivity ) {
+        return StartsWithMatcher( CasedString( str, caseSensitivity) );
+    }
+
+    RegexMatcher Matches(std::string const& regex, CaseSensitive caseSensitivity) {
+        return RegexMatcher(regex, caseSensitivity);
+    }
+
+} // namespace Matchers
+} // namespace Catch
+
+
+
+namespace Catch {
+namespace Matchers {
+    MatcherGenericBase::~MatcherGenericBase() = default;
+
+    namespace Detail {
+
+        std::string describe_multi_matcher(StringRef combine, std::string const* descriptions_begin, std::string const* descriptions_end) {
+            std::string description;
+            std::size_t combined_size = 4;
+            for ( auto desc = descriptions_begin; desc != descriptions_end; ++desc ) {
+                combined_size += desc->size();
+            }
+            combined_size += static_cast<size_t>(descriptions_end - descriptions_begin - 1) * combine.size();
+
+            description.reserve(combined_size);
+
+            description += "( ";
+            bool first = true;
+            for( auto desc = descriptions_begin; desc != descriptions_end; ++desc ) {
+                if( first )
+                    first = false;
+                else
+                    description += combine;
+                description += *desc;
+            }
+            description += " )";
+            return description;
+        }
+
+    } // namespace Detail
+} // namespace Matchers
+} // namespace Catch
+
+
+
+
+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 matcherString  ) {
+        std::string exceptionMessage = Catch::translateActiveException();
+        MatchExpr<std::string, StringMatcher const&> expr( CATCH_MOVE(exceptionMessage), matcher, matcherString );
+        handler.handleExpr( expr );
+    }
+
+} // namespace Catch
+
+
+
+#include <ostream>
+
+namespace Catch {
+
+    AutomakeReporter::~AutomakeReporter() {}
+
+    void AutomakeReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
+        // Possible values to emit are PASS, XFAIL, SKIP, FAIL, XPASS and ERROR.
+        m_stream << ":test-result: ";
+        if (_testCaseStats.totals.assertions.allPassed()) {
+            m_stream << "PASS";
+        } else if (_testCaseStats.totals.assertions.allOk()) {
+            m_stream << "XFAIL";
+        } else {
+            m_stream << "FAIL";
+        }
+        m_stream << ' ' << _testCaseStats.testInfo->name << '\n';
+        StreamingReporterBase::testCaseEnded(_testCaseStats);
+    }
+
+    void AutomakeReporter::skipTest(TestCaseInfo const& testInfo) {
+        m_stream << ":test-result: SKIP " << testInfo.name << '\n';
+    }
+
+} // end namespace Catch
+
+
+
+
+
+
+namespace Catch {
+    ReporterBase::ReporterBase( ReporterConfig&& config ):
+        IEventListener( config.fullConfig() ),
+        m_wrapped_stream( CATCH_MOVE(config).takeStream() ),
+        m_stream( m_wrapped_stream->stream() ),
+        m_colour( makeColourImpl( config.colourMode(), m_wrapped_stream.get() ) ),
+        m_customOptions( config.customOptions() )
+    {}
+
+    ReporterBase::~ReporterBase() = default;
+
+    void ReporterBase::listReporters(
+        std::vector<ReporterDescription> const& descriptions ) {
+        defaultListReporters(m_stream, descriptions, m_config->verbosity());
+    }
+
+    void ReporterBase::listListeners(
+        std::vector<ListenerDescription> const& descriptions ) {
+        defaultListListeners( m_stream, descriptions );
+    }
+
+    void ReporterBase::listTests(std::vector<TestCaseHandle> const& tests) {
+        defaultListTests(m_stream,
+                         m_colour.get(),
+                         tests,
+                         m_config->hasTestFilters(),
+                         m_config->verbosity());
+    }
+
+    void ReporterBase::listTags(std::vector<TagInfo> const& tags) {
+        defaultListTags( m_stream, tags, m_config->hasTestFilters() );
+    }
+
+} // namespace Catch
+
+
+
+
+#include <ostream>
+
+namespace {
+
+    constexpr Catch::StringRef bothOrAll( std::uint64_t count ) {
+        switch (count) {
+        case 1:
+            return Catch::StringRef{};
+        case 2:
+            return "both "_catch_sr;
+        default:
+            return "all "_catch_sr;
+        }
+    }
+
+} // anon namespace
+
+
+namespace Catch {
+namespace {
+
+    // Colour::LightGrey
+    static constexpr Colour::Code compactDimColour = Colour::FileName;
+
+#ifdef CATCH_PLATFORM_MAC
+    static constexpr Catch::StringRef compactFailedString = "FAILED"_sr;
+    static constexpr Catch::StringRef compactPassedString = "PASSED"_sr;
+#else
+    static constexpr Catch::StringRef compactFailedString = "failed"_sr;
+    static constexpr Catch::StringRef compactPassedString = "passed"_sr;
+#endif
+
+// 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, ColourImpl* colourImpl) {
+    if (totals.testCases.total() == 0) {
+        out << "No tests ran.";
+    } else if (totals.testCases.failed == totals.testCases.total()) {
+        auto guard = colourImpl->guardColour( Colour::ResultError ).engage( out );
+        const StringRef qualify_assertions_failed =
+            totals.assertions.failed == totals.assertions.total() ?
+            bothOrAll(totals.assertions.failed) : StringRef{};
+        out <<
+            "Failed " << bothOrAll(totals.testCases.failed)
+            << pluralise(totals.testCases.failed, "test case"_sr) << ", "
+            "failed " << qualify_assertions_failed <<
+            pluralise(totals.assertions.failed, "assertion"_sr) << '.';
+    } else if (totals.assertions.total() == 0) {
+        out <<
+            "Passed " << bothOrAll(totals.testCases.total())
+            << pluralise(totals.testCases.total(), "test case"_sr)
+            << " (no assertions).";
+    } else if (totals.assertions.failed) {
+        out << colourImpl->guardColour( Colour::ResultError ) <<
+            "Failed " << pluralise(totals.testCases.failed, "test case"_sr) << ", "
+            "failed " << pluralise(totals.assertions.failed, "assertion"_sr) << '.';
+    } else {
+        out << colourImpl->guardColour( Colour::ResultSuccess ) <<
+            "Passed " << bothOrAll(totals.testCases.passed)
+            << pluralise(totals.testCases.passed, "test case"_sr) <<
+            " with " << pluralise(totals.assertions.passed, "assertion"_sr) << '.';
+    }
+}
+
+// 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, ColourImpl* colourImpl_)
+        : stream(_stream)
+        , result(_stats.assertionResult)
+        , messages(_stats.infoMessages)
+        , itMessage(_stats.infoMessages.begin())
+        , printInfoMessages(_printInfoMessages)
+        , colourImpl(colourImpl_)
+    {}
+
+    void print() {
+        printSourceInfo();
+
+        itMessage = messages.begin();
+
+        switch (result.getResultType()) {
+        case ResultWas::Ok:
+            printResultType(Colour::ResultSuccess, compactPassedString);
+            printOriginalExpression();
+            printReconstructedExpression();
+            if (!result.hasExpression())
+                printRemainingMessages(Colour::None);
+            else
+                printRemainingMessages();
+            break;
+        case ResultWas::ExpressionFailed:
+            if (result.isOk())
+                printResultType(Colour::ResultSuccess, compactFailedString + " - but was ok"_sr);
+            else
+                printResultType(Colour::Error, compactFailedString);
+            printOriginalExpression();
+            printReconstructedExpression();
+            printRemainingMessages();
+            break;
+        case ResultWas::ThrewException:
+            printResultType(Colour::Error, compactFailedString);
+            printIssue("unexpected exception with message:");
+            printMessage();
+            printExpressionWas();
+            printRemainingMessages();
+            break;
+        case ResultWas::FatalErrorCondition:
+            printResultType(Colour::Error, compactFailedString);
+            printIssue("fatal error condition with message:");
+            printMessage();
+            printExpressionWas();
+            printRemainingMessages();
+            break;
+        case ResultWas::DidntThrowException:
+            printResultType(Colour::Error, compactFailedString);
+            printIssue("expected exception, got none");
+            printExpressionWas();
+            printRemainingMessages();
+            break;
+        case ResultWas::Info:
+            printResultType(Colour::None, "info"_sr);
+            printMessage();
+            printRemainingMessages();
+            break;
+        case ResultWas::Warning:
+            printResultType(Colour::None, "warning"_sr);
+            printMessage();
+            printRemainingMessages();
+            break;
+        case ResultWas::ExplicitFailure:
+            printResultType(Colour::Error, compactFailedString);
+            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 {
+        stream << colourImpl->guardColour( Colour::FileName )
+               << result.getSourceInfo() << ':';
+    }
+
+    void printResultType(Colour::Code colour, StringRef passOrFail) const {
+        if (!passOrFail.empty()) {
+            stream << colourImpl->guardColour(colour) << ' ' << passOrFail;
+            stream << ':';
+        }
+    }
+
+    void printIssue(char const* issue) const {
+        stream << ' ' << issue;
+    }
+
+    void printExpressionWas() {
+        if (result.hasExpression()) {
+            stream << ';';
+            {
+                stream << colourImpl->guardColour(compactDimColour) << " expression was:";
+            }
+            printOriginalExpression();
+        }
+    }
+
+    void printOriginalExpression() const {
+        if (result.hasExpression()) {
+            stream << ' ' << result.getExpression();
+        }
+    }
+
+    void printReconstructedExpression() const {
+        if (result.hasExpandedExpression()) {
+            stream << colourImpl->guardColour(compactDimColour) << " for: ";
+            stream << result.getExpandedExpression();
+        }
+    }
+
+    void printMessage() {
+        if (itMessage != messages.end()) {
+            stream << " '" << itMessage->message << '\'';
+            ++itMessage;
+        }
+    }
+
+    void printRemainingMessages(Colour::Code colour = compactDimColour) {
+        if (itMessage == messages.end())
+            return;
+
+        const auto itEnd = messages.cend();
+        const auto N = static_cast<std::size_t>(std::distance(itMessage, itEnd));
+
+        stream << colourImpl->guardColour( colour ) << " with "
+               << pluralise( N, "message"_sr ) << ':';
+
+        while (itMessage != itEnd) {
+            // If this assertion is a warning ignore any INFO messages
+            if (printInfoMessages || itMessage->type != ResultWas::Info) {
+                printMessage();
+                if (itMessage != itEnd) {
+                    stream << colourImpl->guardColour(compactDimColour) << " and";
+                }
+                continue;
+            }
+            ++itMessage;
+        }
+    }
+
+private:
+    std::ostream& stream;
+    AssertionResult const& result;
+    std::vector<MessageInfo> messages;
+    std::vector<MessageInfo>::const_iterator itMessage;
+    bool printInfoMessages;
+    ColourImpl* colourImpl;
+};
+
+} // anon namespace
+
+        std::string CompactReporter::getDescription() {
+            return "Reports test results on a single line, suitable for IDEs";
+        }
+
+        void CompactReporter::noMatchingTestCases( StringRef unmatchedSpec ) {
+            m_stream << "No test cases matched '" << unmatchedSpec << "'\n";
+        }
+
+        void CompactReporter::testRunStarting( TestRunInfo const& ) {
+            if ( m_config->testSpec().hasFilters() ) {
+                m_stream << m_colour->guardColour( Colour::BrightYellow )
+                         << "Filters: "
+                         << serializeFilters( m_config->getTestsOrTags() )
+                         << '\n';
+            }
+            m_stream << "RNG seed: " << getSeed() << '\n';
+        }
+
+        void CompactReporter::assertionEnded( AssertionStats const& _assertionStats ) {
+            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;
+                printInfoMessages = false;
+            }
+
+            AssertionPrinter printer( m_stream, _assertionStats, printInfoMessages, m_colour.get() );
+            printer.print();
+
+            m_stream << '\n' << std::flush;
+        }
+
+        void CompactReporter::sectionEnded(SectionStats const& _sectionStats) {
+            double dur = _sectionStats.durationInSeconds;
+            if ( shouldShowDuration( *m_config, dur ) ) {
+                m_stream << getFormattedDuration( dur ) << " s: " << _sectionStats.sectionInfo.name << '\n' << std::flush;
+            }
+        }
+
+        void CompactReporter::testRunEnded( TestRunStats const& _testRunStats ) {
+            printTotals( m_stream, _testRunStats.totals, m_colour.get() );
+            m_stream << "\n\n" << std::flush;
+            StreamingReporterBase::testRunEnded( _testRunStats );
+        }
+
+        CompactReporter::~CompactReporter() {}
+
+} // end namespace Catch
+
+
+
+
+#include <cstdio>
+
+#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
+
+#if defined(__clang__)
+#  pragma clang diagnostic push
+// For simplicity, benchmarking-only helpers are always enabled
+#  pragma clang diagnostic ignored "-Wunused-function"
+#endif
+
+
+
+namespace Catch {
+
+namespace {
+
+// Formatter impl for ConsoleReporter
+class ConsoleAssertionPrinter {
+public:
+    ConsoleAssertionPrinter& operator= (ConsoleAssertionPrinter const&) = delete;
+    ConsoleAssertionPrinter(ConsoleAssertionPrinter const&) = delete;
+    ConsoleAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, ColourImpl* colourImpl_, bool _printInfoMessages)
+        : stream(_stream),
+        stats(_stats),
+        result(_stats.assertionResult),
+        colour(Colour::None),
+        message(result.getMessage()),
+        messages(_stats.infoMessages),
+        colourImpl(colourImpl_),
+        printInfoMessages(_printInfoMessages) {
+        switch (result.getResultType()) {
+        case ResultWas::Ok:
+            colour = Colour::Success;
+            passOrFail = "PASSED"_sr;
+            //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"_sr;
+            } else {
+                colour = Colour::Error;
+                passOrFail = "FAILED"_sr;
+            }
+            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"_sr;
+            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"_sr;
+            messageLabel = "due to a fatal error condition";
+            break;
+        case ResultWas::DidntThrowException:
+            colour = Colour::Error;
+            passOrFail = "FAILED"_sr;
+            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"_sr;
+            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 **"_sr;
+            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()) {
+            stream << colourImpl->guardColour(colour) << passOrFail << ":\n";
+        }
+    }
+    void printOriginalExpression() const {
+        if (result.hasExpression()) {
+            stream << colourImpl->guardColour( Colour::OriginalExpression )
+                   << "  " << result.getExpressionInMacro() << '\n';
+        }
+    }
+    void printReconstructedExpression() const {
+        if (result.hasExpandedExpression()) {
+            stream << "with expansion:\n";
+            stream << colourImpl->guardColour( Colour::ReconstructedExpression )
+                   << TextFlow::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 << TextFlow::Column(msg.message).indent(2) << '\n';
+        }
+    }
+    void printSourceInfo() const {
+        stream << colourImpl->guardColour( Colour::FileName )
+               << result.getSourceInfo() << ": ";
+    }
+
+    std::ostream& stream;
+    AssertionStats const& stats;
+    AssertionResult const& result;
+    Colour::Code colour;
+    StringRef passOrFail;
+    std::string messageLabel;
+    std::string message;
+    std::vector<MessageInfo> messages;
+    ColourImpl* colourImpl;
+    bool printInfoMessages;
+};
+
+std::size_t makeRatio( std::uint64_t number, std::uint64_t total ) {
+    const auto ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number / total : 0;
+    return (ratio == 0 && number > 0) ? 1 : static_cast<std::size_t>(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;
+}
+
+enum class Justification { Left, Right };
+
+struct ColumnInfo {
+    std::string name;
+    std::size_t 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;
+
+    double m_inNanoseconds;
+    Unit m_units;
+
+public:
+    explicit Duration(double 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 m_inNanoseconds;
+        }
+    }
+    StringRef unitsAsString() const {
+        switch (m_units) {
+        case Unit::Nanoseconds:
+            return "ns"_sr;
+        case Unit::Microseconds:
+            return "us"_sr;
+        case Unit::Milliseconds:
+            return "ms"_sr;
+        case Unit::Seconds:
+            return "s"_sr;
+        case Unit::Minutes:
+            return "m"_sr;
+        default:
+            return "** internal error **"_sr;
+        }
+
+    }
+    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;
+    ReusableStringStream m_oss;
+    int m_currentColumn = -1;
+    bool m_isOpen = false;
+
+public:
+    TablePrinter( std::ostream& os, std::vector<ColumnInfo> columnInfos )
+    :   m_os( os ),
+        m_columnInfos( CATCH_MOVE( columnInfos ) ) {}
+
+    auto columnInfos() const -> std::vector<ColumnInfo> const& {
+        return m_columnInfos;
+    }
+
+    void open() {
+        if (!m_isOpen) {
+            m_isOpen = true;
+            *this << RowBreak();
+
+			TextFlow::Columns headerCols;
+			auto spacer = TextFlow::Spacer(2);
+			for (auto const& info : m_columnInfos) {
+                assert(info.width > 2);
+				headerCols += TextFlow::Column(info.name).width(info.width - 2);
+				headerCols += spacer;
+			}
+			m_os << headerCols << '\n';
+
+            m_os << lineOfChars('-') << '\n';
+        }
+    }
+    void close() {
+        if (m_isOpen) {
+            *this << RowBreak();
+            m_os << '\n' << std::flush;
+            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();
+        const auto strSize = colStr.size();
+        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 + 1 < colInfo.width)
+            ? std::string(colInfo.width - (strSize + 1), ' ')
+            : std::string();
+        if (colInfo.justification == Justification::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&& config):
+    StreamingReporterBase( CATCH_MOVE( config ) ),
+    m_tablePrinter(Detail::make_unique<TablePrinter>(m_stream,
+        [&config]() -> std::vector<ColumnInfo> {
+        if (config.fullConfig()->benchmarkNoAnalysis())
+        {
+            return{
+                { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, Justification::Left },
+                { "     samples", 14, Justification::Right },
+                { "  iterations", 14, Justification::Right },
+                { "        mean", 14, Justification::Right }
+            };
+        }
+        else
+        {
+            return{
+                { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, Justification::Left },
+                { "samples      mean       std dev", 14, Justification::Right },
+                { "iterations   low mean   low std dev", 14, Justification::Right },
+                { "estimated    high mean  high std dev", 14, Justification::Right }
+            };
+        }
+    }())) {}
+ConsoleReporter::~ConsoleReporter() = default;
+
+std::string ConsoleReporter::getDescription() {
+    return "Reports test results as plain lines of text";
+}
+
+void ConsoleReporter::noMatchingTestCases( StringRef unmatchedSpec ) {
+    m_stream << "No test cases matched '" << unmatchedSpec << "'\n";
+}
+
+void ConsoleReporter::reportInvalidTestSpec( StringRef arg ) {
+    m_stream << "Invalid Filter: " << arg << '\n';
+}
+
+void ConsoleReporter::assertionStarting(AssertionInfo const&) {}
+
+void ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) {
+    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;
+
+    lazyPrint();
+
+    ConsoleAssertionPrinter printer(m_stream, _assertionStats, m_colour.get(), includeResults);
+    printer.print();
+    m_stream << '\n' << std::flush;
+}
+
+void ConsoleReporter::sectionStarting(SectionInfo const& _sectionInfo) {
+    m_tablePrinter->close();
+    m_headerPrinted = false;
+    StreamingReporterBase::sectionStarting(_sectionInfo);
+}
+void ConsoleReporter::sectionEnded(SectionStats const& _sectionStats) {
+    m_tablePrinter->close();
+    if (_sectionStats.missingAssertions) {
+        lazyPrint();
+        auto guard =
+            m_colour->guardColour( Colour::ResultError ).engage( m_stream );
+        if (m_sectionStack.size() > 1)
+            m_stream << "\nNo assertions in section";
+        else
+            m_stream << "\nNo assertions in test case";
+        m_stream << " '" << _sectionStats.sectionInfo.name << "'\n\n" << std::flush;
+    }
+    double dur = _sectionStats.durationInSeconds;
+    if (shouldShowDuration(*m_config, dur)) {
+        m_stream << getFormattedDuration(dur) << " s: " << _sectionStats.sectionInfo.name << '\n' << std::flush;
+    }
+    if (m_headerPrinted) {
+        m_headerPrinted = false;
+    }
+    StreamingReporterBase::sectionEnded(_sectionStats);
+}
+
+void ConsoleReporter::benchmarkPreparing( StringRef name ) {
+	lazyPrintWithoutClosingBenchmarkTable();
+
+	auto nameCol = TextFlow::Column( static_cast<std::string>( 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 ConsoleReporter::benchmarkStarting(BenchmarkInfo const& info) {
+    (*m_tablePrinter) << info.samples << ColumnBreak()
+        << info.iterations << ColumnBreak();
+    if (!m_config->benchmarkNoAnalysis())
+        (*m_tablePrinter) << Duration(info.estimatedDuration) << ColumnBreak();
+}
+void ConsoleReporter::benchmarkEnded(BenchmarkStats<> const& stats) {
+    if (m_config->benchmarkNoAnalysis())
+    {
+        (*m_tablePrinter) << Duration(stats.mean.point.count()) << ColumnBreak();
+    }
+    else
+    {
+        (*m_tablePrinter) << ColumnBreak()
+            << Duration(stats.mean.point.count()) << ColumnBreak()
+            << Duration(stats.mean.lower_bound.count()) << ColumnBreak()
+            << Duration(stats.mean.upper_bound.count()) << ColumnBreak() << ColumnBreak()
+            << Duration(stats.standardDeviation.point.count()) << ColumnBreak()
+            << Duration(stats.standardDeviation.lower_bound.count()) << ColumnBreak()
+            << Duration(stats.standardDeviation.upper_bound.count()) << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak();
+    }
+}
+
+void ConsoleReporter::benchmarkFailed( StringRef error ) {
+    auto guard = m_colour->guardColour( Colour::Red ).engage( m_stream );
+    (*m_tablePrinter)
+        << "Benchmark failed (" << error << ')'
+        << ColumnBreak() << RowBreak();
+}
+
+void ConsoleReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
+    m_tablePrinter->close();
+    StreamingReporterBase::testCaseEnded(_testCaseStats);
+    m_headerPrinted = false;
+}
+void ConsoleReporter::testRunEnded(TestRunStats const& _testRunStats) {
+    printTotalsDivider(_testRunStats.totals);
+    printTotals(_testRunStats.totals);
+    m_stream << '\n' << std::flush;
+    StreamingReporterBase::testRunEnded(_testRunStats);
+}
+void ConsoleReporter::testRunStarting(TestRunInfo const& _testInfo) {
+    StreamingReporterBase::testRunStarting(_testInfo);
+    if ( m_config->testSpec().hasFilters() ) {
+        m_stream << m_colour->guardColour( Colour::BrightYellow ) << "Filters: "
+                 << serializeFilters( m_config->getTestsOrTags() ) << '\n';
+    }
+    m_stream << "Randomness seeded to: " << getSeed() << '\n';
+}
+
+void ConsoleReporter::lazyPrint() {
+
+    m_tablePrinter->close();
+    lazyPrintWithoutClosingBenchmarkTable();
+}
+
+void ConsoleReporter::lazyPrintWithoutClosingBenchmarkTable() {
+
+    if ( !m_testRunInfoPrinted ) {
+        lazyPrintRunInfo();
+    }
+    if (!m_headerPrinted) {
+        printTestCaseAndSectionHeader();
+        m_headerPrinted = true;
+    }
+}
+void ConsoleReporter::lazyPrintRunInfo() {
+    m_stream << '\n'
+             << lineOfChars( '~' ) << '\n'
+             << m_colour->guardColour( Colour::SecondaryText )
+             << currentTestRunInfo.name << " is a Catch2 v" << libraryVersion()
+             << " host application.\n"
+             << "Run with -? for options\n\n";
+
+    m_testRunInfoPrinted = true;
+}
+void ConsoleReporter::printTestCaseAndSectionHeader() {
+    assert(!m_sectionStack.empty());
+    printOpenHeader(currentTestCaseInfo->name);
+
+    if (m_sectionStack.size() > 1) {
+        auto guard = m_colour->guardColour( Colour::Headers ).engage( m_stream );
+
+        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;
+
+
+    m_stream << lineOfChars( '-' ) << '\n'
+             << m_colour->guardColour( Colour::FileName ) << lineInfo << '\n'
+             << lineOfChars( '.' ) << "\n\n"
+             << std::flush;
+}
+
+void ConsoleReporter::printClosedHeader(std::string const& _name) {
+    printOpenHeader(_name);
+    m_stream << lineOfChars('.') << '\n';
+}
+void ConsoleReporter::printOpenHeader(std::string const& _name) {
+    m_stream << lineOfChars('-') << '\n';
+    {
+        auto guard = m_colour->guardColour( Colour::Headers ).engage( m_stream );
+        printHeaderString(_name);
+    }
+}
+
+void ConsoleReporter::printHeaderString(std::string const& _string, std::size_t indent) {
+    // We want to get a bit fancy with line breaking here, so that subsequent
+    // lines start after ":" if one is present, e.g.
+    // ```
+    // blablabla: Fancy
+    //            linebreaking
+    // ```
+    // but we also want to avoid problems with overly long indentation causing
+    // the text to take up too many lines, e.g.
+    // ```
+    // blablabla: F
+    //            a
+    //            n
+    //            c
+    //            y
+    //            .
+    //            .
+    //            .
+    // ```
+    // So we limit the prefix indentation check to first quarter of the possible
+    // width
+    std::size_t idx = _string.find( ": " );
+    if ( idx != std::string::npos && idx < CATCH_CONFIG_CONSOLE_WIDTH / 4 ) {
+        idx += 2;
+    } else {
+        idx = 0;
+    }
+    m_stream << TextFlow::Column( _string )
+                  .indent( indent + idx )
+                  .initialIndent( indent )
+           << '\n';
+}
+
+struct SummaryColumn {
+
+    SummaryColumn( std::string _label, Colour::Code _colour )
+    :   label( CATCH_MOVE( _label ) ),
+        colour( _colour ) {}
+    SummaryColumn addRow( std::uint64_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) {
+        m_stream << m_colour->guardColour( Colour::Warning )
+                 << "No tests ran\n";
+    } else if (totals.assertions.total() > 0 && totals.testCases.allPassed()) {
+        m_stream << m_colour->guardColour( Colour::ResultSuccess )
+                 << "All tests passed";
+        m_stream << " ("
+            << pluralise(totals.assertions.passed, "assertion"_sr) << " in "
+            << pluralise(totals.testCases.passed, "test case"_sr) << ')'
+            << '\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"_sr, columns, 0);
+        printSummaryRow("assertions"_sr, columns, 1);
+    }
+}
+void ConsoleReporter::printSummaryRow(StringRef label, std::vector<SummaryColumn> const& cols, std::size_t row) {
+    for (auto col : cols) {
+        std::string const& value = col.rows[row];
+        if (col.label.empty()) {
+            m_stream << label << ": ";
+            if ( value != "0" ) {
+                m_stream << value;
+            } else {
+                m_stream << m_colour->guardColour( Colour::Warning )
+                         << "- none -";
+            }
+        } else if (value != "0") {
+            m_stream << m_colour->guardColour( Colour::LightGrey ) << " | "
+                     << m_colour->guardColour( col.colour ) << value << ' '
+                     << col.label;
+        }
+    }
+    m_stream << '\n';
+}
+
+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)--;
+
+        m_stream << m_colour->guardColour( Colour::Error )
+                 << std::string( failedRatio, '=' )
+                 << m_colour->guardColour( Colour::ResultExpectedFailure )
+                 << std::string( failedButOkRatio, '=' );
+        if ( totals.testCases.allPassed() ) {
+            m_stream << m_colour->guardColour( Colour::ResultSuccess )
+                     << std::string( passedRatio, '=' );
+        } else {
+            m_stream << m_colour->guardColour( Colour::Success )
+                     << std::string( passedRatio, '=' );
+        }
+    } else {
+        m_stream << m_colour->guardColour( Colour::Warning )
+                 << std::string( CATCH_CONFIG_CONSOLE_WIDTH - 1, '=' );
+    }
+    m_stream << '\n';
+}
+void ConsoleReporter::printSummaryDivider() {
+    m_stream << lineOfChars('-') << '\n';
+}
+
+} // end namespace Catch
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic pop
+#endif
+
+
+
+
+#include <algorithm>
+#include <cassert>
+
+namespace Catch {
+    namespace {
+        struct BySectionInfo {
+            BySectionInfo( SectionInfo const& other ): m_other( other ) {}
+            BySectionInfo( BySectionInfo const& other ):
+                m_other( other.m_other ) {}
+            bool operator()(
+                Detail::unique_ptr<CumulativeReporterBase::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;
+        };
+
+    } // namespace
+
+    namespace Detail {
+        AssertionOrBenchmarkResult::AssertionOrBenchmarkResult(
+            AssertionStats const& assertion ):
+            m_assertion( assertion ) {}
+
+        AssertionOrBenchmarkResult::AssertionOrBenchmarkResult(
+            BenchmarkStats<> const& benchmark ):
+            m_benchmark( benchmark ) {}
+
+        bool AssertionOrBenchmarkResult::isAssertion() const {
+            return m_assertion.some();
+        }
+        bool AssertionOrBenchmarkResult::isBenchmark() const {
+            return m_benchmark.some();
+        }
+
+        AssertionStats const& AssertionOrBenchmarkResult::asAssertion() const {
+            assert(m_assertion.some());
+
+            return *m_assertion;
+        }
+        BenchmarkStats<> const& AssertionOrBenchmarkResult::asBenchmark() const {
+            assert(m_benchmark.some());
+
+            return *m_benchmark;
+        }
+
+    }
+
+    CumulativeReporterBase::~CumulativeReporterBase() = default;
+
+    void CumulativeReporterBase::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) {
+        m_sectionStack.back()->assertionsAndBenchmarks.emplace_back(benchmarkStats);
+    }
+
+    void
+    CumulativeReporterBase::sectionStarting( SectionInfo const& sectionInfo ) {
+        SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
+        SectionNode* node;
+        if ( m_sectionStack.empty() ) {
+            if ( !m_rootSection ) {
+                m_rootSection =
+                    Detail::make_unique<SectionNode>( incompleteStats );
+            }
+            node = m_rootSection.get();
+        } else {
+            SectionNode& parentNode = *m_sectionStack.back();
+            auto it = std::find_if( parentNode.childSections.begin(),
+                                    parentNode.childSections.end(),
+                                    BySectionInfo( sectionInfo ) );
+            if ( it == parentNode.childSections.end() ) {
+                auto newNode =
+                    Detail::make_unique<SectionNode>( incompleteStats );
+                node = newNode.get();
+                parentNode.childSections.push_back( CATCH_MOVE( newNode ) );
+            } else {
+                node = it->get();
+            }
+        }
+
+        m_deepestSection = node;
+        m_sectionStack.push_back( node );
+    }
+
+    void CumulativeReporterBase::assertionEnded(
+        AssertionStats const& assertionStats ) {
+        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.
+        if ( m_shouldStoreFailedAssertions &&
+             !assertionStats.assertionResult.isOk() ) {
+            static_cast<void>(
+                assertionStats.assertionResult.getExpandedExpression() );
+        }
+        if ( m_shouldStoreSuccesfulAssertions &&
+             assertionStats.assertionResult.isOk() ) {
+            static_cast<void>(
+                assertionStats.assertionResult.getExpandedExpression() );
+        }
+        SectionNode& sectionNode = *m_sectionStack.back();
+        sectionNode.assertionsAndBenchmarks.emplace_back( assertionStats );
+    }
+
+    void CumulativeReporterBase::sectionEnded( SectionStats const& sectionStats ) {
+        assert( !m_sectionStack.empty() );
+        SectionNode& node = *m_sectionStack.back();
+        node.stats = sectionStats;
+        m_sectionStack.pop_back();
+    }
+
+    void CumulativeReporterBase::testCaseEnded(
+        TestCaseStats const& testCaseStats ) {
+        auto node = Detail::make_unique<TestCaseNode>( testCaseStats );
+        assert( m_sectionStack.size() == 0 );
+        node->children.push_back( CATCH_MOVE(m_rootSection) );
+        m_testCases.push_back( CATCH_MOVE(node) );
+
+        assert( m_deepestSection );
+        m_deepestSection->stdOut = testCaseStats.stdOut;
+        m_deepestSection->stdErr = testCaseStats.stdErr;
+    }
+
+
+    void CumulativeReporterBase::testRunEnded( TestRunStats const& testRunStats ) {
+        assert(!m_testRun && "CumulativeReporterBase assumes there can only be one test run");
+        m_testRun = Detail::make_unique<TestRunNode>( testRunStats );
+        m_testRun->children.swap( m_testCases );
+        testRunEndedCumulative();
+    }
+
+    bool CumulativeReporterBase::SectionNode::hasAnyAssertions() const {
+        return std::any_of(
+            assertionsAndBenchmarks.begin(),
+            assertionsAndBenchmarks.end(),
+            []( Detail::AssertionOrBenchmarkResult const& res ) {
+                return res.isAssertion();
+            } );
+    }
+
+} // end namespace Catch
+
+
+
+
+namespace Catch {
+
+    void EventListenerBase::fatalErrorEncountered( StringRef ) {}
+
+    void EventListenerBase::benchmarkPreparing( StringRef ) {}
+    void EventListenerBase::benchmarkStarting( BenchmarkInfo const& ) {}
+    void EventListenerBase::benchmarkEnded( BenchmarkStats<> const& ) {}
+    void EventListenerBase::benchmarkFailed( StringRef ) {}
+
+    void EventListenerBase::assertionStarting( AssertionInfo const& ) {}
+
+    void EventListenerBase::assertionEnded( AssertionStats const& ) {}
+    void EventListenerBase::listReporters(
+        std::vector<ReporterDescription> const& ) {}
+    void EventListenerBase::listListeners(
+        std::vector<ListenerDescription> const& ) {}
+    void EventListenerBase::listTests( std::vector<TestCaseHandle> const& ) {}
+    void EventListenerBase::listTags( std::vector<TagInfo> const& ) {}
+    void EventListenerBase::noMatchingTestCases( StringRef ) {}
+    void EventListenerBase::reportInvalidTestSpec( StringRef ) {}
+    void EventListenerBase::testRunStarting( TestRunInfo const& ) {}
+    void EventListenerBase::testCaseStarting( TestCaseInfo const& ) {}
+    void EventListenerBase::testCasePartialStarting(TestCaseInfo const&, uint64_t) {}
+    void EventListenerBase::sectionStarting( SectionInfo const& ) {}
+    void EventListenerBase::sectionEnded( SectionStats const& ) {}
+    void EventListenerBase::testCasePartialEnded(TestCaseStats const&, uint64_t) {}
+    void EventListenerBase::testCaseEnded( TestCaseStats const& ) {}
+    void EventListenerBase::testRunEnded( TestRunStats const& ) {}
+    void EventListenerBase::skipTest( TestCaseInfo const& ) {}
+} // namespace Catch
+
+
+
+
+#include <algorithm>
+#include <cfloat>
+#include <cstdio>
+#include <ostream>
+#include <iomanip>
+
+namespace Catch {
+
+    namespace {
+        void listTestNamesOnly(std::ostream& out,
+                               std::vector<TestCaseHandle> const& tests) {
+            for (auto const& test : tests) {
+                auto const& testCaseInfo = test.getTestCaseInfo();
+
+                if (startsWith(testCaseInfo.name, '#')) {
+                    out << '"' << testCaseInfo.name << '"';
+                } else {
+                    out << testCaseInfo.name;
+                }
+
+                out << '\n';
+            }
+            out << std::flush;
+        }
+    } // end unnamed namespace
+
+
+    // 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
+        size_t printedLength = static_cast<size_t>(
+            sprintf_s( buffer, "%.3f", duration ) );
+#else
+        size_t printedLength = static_cast<size_t>(
+            std::snprintf( buffer, maxDoubleSize, "%.3f", duration ) );
+#endif
+        return std::string( buffer, printedLength );
+    }
+
+    bool shouldShowDuration( IConfig const& config, double duration ) {
+        if ( config.showDurations() == ShowDurations::Always ) {
+            return true;
+        }
+        if ( config.showDurations() == ShowDurations::Never ) {
+            return false;
+        }
+        const double min = config.minDuration();
+        return min >= 0 && duration >= min;
+    }
+
+    std::string serializeFilters( std::vector<std::string> const& filters ) {
+        // We add a ' ' separator between each filter
+        size_t serialized_size = filters.size() - 1;
+        for (auto const& filter : filters) {
+            serialized_size += filter.size();
+        }
+
+        std::string serialized;
+        serialized.reserve(serialized_size);
+        bool first = true;
+
+        for (auto const& filter : filters) {
+            if (!first) {
+                serialized.push_back(' ');
+            }
+            first = false;
+            serialized.append(filter);
+        }
+
+        return serialized;
+    }
+
+    std::ostream& operator<<( std::ostream& out, lineOfChars value ) {
+        for ( size_t idx = 0; idx < CATCH_CONFIG_CONSOLE_WIDTH - 1; ++idx ) {
+            out.put( value.c );
+        }
+        return out;
+    }
+
+    void
+    defaultListReporters( std::ostream& out,
+                          std::vector<ReporterDescription> const& descriptions,
+                          Verbosity verbosity ) {
+        out << "Available reporters:\n";
+        const auto maxNameLen =
+            std::max_element( descriptions.begin(),
+                              descriptions.end(),
+                              []( ReporterDescription const& lhs,
+                                  ReporterDescription const& rhs ) {
+                                  return lhs.name.size() < rhs.name.size();
+                              } )
+                ->name.size();
+
+        for ( auto const& desc : descriptions ) {
+            if ( verbosity == Verbosity::Quiet ) {
+                out << TextFlow::Column( desc.name )
+                           .indent( 2 )
+                           .width( 5 + maxNameLen )
+                    << '\n';
+            } else {
+                out << TextFlow::Column( desc.name + ':' )
+                               .indent( 2 )
+                               .width( 5 + maxNameLen ) +
+                           TextFlow::Column( desc.description )
+                               .initialIndent( 0 )
+                               .indent( 2 )
+                               .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen - 8 )
+                    << '\n';
+            }
+        }
+        out << '\n' << std::flush;
+    }
+
+    void defaultListListeners( std::ostream& out,
+                               std::vector<ListenerDescription> const& descriptions ) {
+        out << "Registered listeners:\n";
+
+        if(descriptions.empty()) {
+            return;
+        }
+
+        const auto maxNameLen =
+            std::max_element( descriptions.begin(),
+                              descriptions.end(),
+                              []( ListenerDescription const& lhs,
+                                  ListenerDescription const& rhs ) {
+                                  return lhs.name.size() < rhs.name.size();
+                              } )
+                ->name.size();
+
+        for ( auto const& desc : descriptions ) {
+            out << TextFlow::Column( static_cast<std::string>( desc.name ) +
+                                     ':' )
+                           .indent( 2 )
+                           .width( maxNameLen + 5 ) +
+                       TextFlow::Column( desc.description )
+                           .initialIndent( 0 )
+                           .indent( 2 )
+                           .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen - 8 )
+                << '\n';
+        }
+
+        out << '\n' << std::flush;
+    }
+
+    void defaultListTags( std::ostream& out,
+                          std::vector<TagInfo> const& tags,
+                          bool isFiltered ) {
+        if ( isFiltered ) {
+            out << "Tags for matching test cases:\n";
+        } else {
+            out << "All available tags:\n";
+        }
+
+        for ( auto const& tagCount : tags ) {
+            ReusableStringStream rss;
+            rss << "  " << std::setw( 2 ) << tagCount.count << "  ";
+            auto str = rss.str();
+            auto wrapper = TextFlow::Column( tagCount.all() )
+                               .initialIndent( 0 )
+                               .indent( str.size() )
+                               .width( CATCH_CONFIG_CONSOLE_WIDTH - 10 );
+            out << str << wrapper << '\n';
+        }
+        out << pluralise(tags.size(), "tag"_sr) << "\n\n" << std::flush;
+    }
+
+    void defaultListTests(std::ostream& out, ColourImpl* streamColour, std::vector<TestCaseHandle> const& tests, bool isFiltered, Verbosity verbosity) {
+        // We special case this to provide the equivalent of old
+        // `--list-test-names-only`, which could then be used by the
+        // `--input-file` option.
+        if (verbosity == Verbosity::Quiet) {
+            listTestNamesOnly(out, tests);
+            return;
+        }
+
+        if (isFiltered) {
+            out << "Matching test cases:\n";
+        } else {
+            out << "All available test cases:\n";
+        }
+
+        for (auto const& test : tests) {
+            auto const& testCaseInfo = test.getTestCaseInfo();
+            Colour::Code colour = testCaseInfo.isHidden()
+                ? Colour::SecondaryText
+                : Colour::None;
+            auto colourGuard = streamColour->guardColour( colour ).engage( out );
+
+            out << TextFlow::Column(testCaseInfo.name).indent(2) << '\n';
+            if (verbosity >= Verbosity::High) {
+                out << TextFlow::Column(Catch::Detail::stringify(testCaseInfo.lineInfo)).indent(4) << '\n';
+            }
+            if (!testCaseInfo.tags.empty() &&
+                verbosity > Verbosity::Quiet) {
+                out << TextFlow::Column(testCaseInfo.tagsAsString()).indent(6) << '\n';
+            }
+        }
+
+        if (isFiltered) {
+            out << pluralise(tests.size(), "matching test case"_sr);
+        } else {
+            out << pluralise(tests.size(), "test case"_sr);
+        }
+        out << "\n\n" << std::flush;
+    }
+
+} // namespace Catch
+
+
+
+
+#include <cassert>
+#include <ctime>
+#include <algorithm>
+#include <iomanip>
+
+namespace Catch {
+
+    namespace {
+        std::string getCurrentTimestamp() {
+            time_t rawtime;
+            std::time(&rawtime);
+
+            std::tm timeInfo = {};
+#if defined (_MSC_VER) || defined (__MINGW32__)
+            gmtime_s(&timeInfo, &rawtime);
+#else
+            gmtime_r(&rawtime, &timeInfo);
+#endif
+
+            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
+            char timeStamp[timeStampSize];
+            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
+
+            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
+
+            return std::string(timeStamp, timeStampSize - 1);
+        }
+
+        std::string fileNameTag(std::vector<Tag> const& tags) {
+            auto it = std::find_if(begin(tags),
+                                   end(tags),
+                                   [] (Tag const& tag) {
+                                       return tag.original.size() > 0
+                                           && tag.original[0] == '#'; });
+            if (it != tags.end()) {
+                return static_cast<std::string>(
+                    it->original.substr(1, it->original.size() - 1)
+                );
+            }
+            return std::string();
+        }
+
+        // Formats the duration in seconds to 3 decimal places.
+        // This is done because some genius defined Maven Surefire schema
+        // in a way that only accepts 3 decimal places, and tools like
+        // Jenkins use that schema for validation JUnit reporter output.
+        std::string formatDuration( double seconds ) {
+            ReusableStringStream rss;
+            rss << std::fixed << std::setprecision( 3 ) << seconds;
+            return rss.str();
+        }
+
+        static void normalizeNamespaceMarkers(std::string& str) {
+            std::size_t pos = str.find( "::" );
+            while ( pos != str.npos ) {
+                str.replace( pos, 2, "." );
+                pos += 1;
+                pos = str.find( "::", pos );
+            }
+        }
+
+    } // anonymous namespace
+
+    JunitReporter::JunitReporter( ReporterConfig&& _config )
+        :   CumulativeReporterBase( CATCH_MOVE(_config) ),
+            xml( m_stream )
+        {
+            m_preferences.shouldRedirectStdOut = true;
+            m_preferences.shouldReportAllAssertions = true;
+            m_shouldStoreSuccesfulAssertions = false;
+        }
+
+    std::string JunitReporter::getDescription() {
+        return "Reports test results in an XML format that looks like Ant's junitreport target";
+    }
+
+    void JunitReporter::testRunStarting( TestRunInfo const& runInfo )  {
+        CumulativeReporterBase::testRunStarting( runInfo );
+        xml.startElement( "testsuites" );
+        suiteTimer.start();
+        stdOutForSuite.clear();
+        stdErrForSuite.clear();
+        unexpectedExceptions = 0;
+    }
+
+    void JunitReporter::testCaseStarting( TestCaseInfo const& testCaseInfo ) {
+        m_okToFail = testCaseInfo.okToFail();
+    }
+
+    void JunitReporter::assertionEnded( AssertionStats const& assertionStats ) {
+        if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException && !m_okToFail )
+            unexpectedExceptions++;
+        CumulativeReporterBase::assertionEnded( assertionStats );
+    }
+
+    void JunitReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+        stdOutForSuite += testCaseStats.stdOut;
+        stdErrForSuite += testCaseStats.stdErr;
+        CumulativeReporterBase::testCaseEnded( testCaseStats );
+    }
+
+    void JunitReporter::testRunEndedCumulative() {
+        const auto suiteTime = suiteTimer.getElapsedSeconds();
+        writeRun( *m_testRun, suiteTime );
+        xml.endElement();
+    }
+
+    void JunitReporter::writeRun( TestRunNode const& testRunNode, double suiteTime ) {
+        XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
+
+        TestRunStats const& stats = testRunNode.value;
+        xml.writeAttribute( "name"_sr, stats.runInfo.name );
+        xml.writeAttribute( "errors"_sr, unexpectedExceptions );
+        xml.writeAttribute( "failures"_sr, stats.totals.assertions.failed-unexpectedExceptions );
+        xml.writeAttribute( "tests"_sr, stats.totals.assertions.total() );
+        xml.writeAttribute( "hostname"_sr, "tbd"_sr ); // !TBD
+        if( m_config->showDurations() == ShowDurations::Never )
+            xml.writeAttribute( "time"_sr, ""_sr );
+        else
+            xml.writeAttribute( "time"_sr, formatDuration( suiteTime ) );
+        xml.writeAttribute( "timestamp"_sr, getCurrentTimestamp() );
+
+        // Write properties
+        {
+            auto properties = xml.scopedElement("properties");
+            xml.scopedElement("property")
+                .writeAttribute("name"_sr, "random-seed"_sr)
+                .writeAttribute("value"_sr, m_config->rngSeed());
+            if (m_config->hasTestFilters()) {
+                xml.scopedElement("property")
+                    .writeAttribute("name"_sr, "filters"_sr)
+                    .writeAttribute("value"_sr, serializeFilters(m_config->getTestsOrTags()));
+            }
+        }
+
+        // Write test cases
+        for( auto const& child : testRunNode.children )
+            writeTestCase( *child );
+
+        xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite ), XmlFormatting::Newline );
+        xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite ), XmlFormatting::Newline );
+    }
+
+    void JunitReporter::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 =
+            static_cast<std::string>( stats.testInfo->className );
+
+        if( className.empty() ) {
+            className = fileNameTag(stats.testInfo->tags);
+            if ( className.empty() ) {
+                className = "global";
+            }
+        }
+
+        if ( !m_config->name().empty() )
+            className = static_cast<std::string>(m_config->name()) + '.' + className;
+
+        normalizeNamespaceMarkers(className);
+
+        writeSection( className, "", rootSection, stats.testInfo->okToFail() );
+    }
+
+    void JunitReporter::writeSection( std::string const& className,
+                                      std::string const& rootName,
+                                      SectionNode const& sectionNode,
+                                      bool testOkToFail) {
+        std::string name = trim( sectionNode.stats.sectionInfo.name );
+        if( !rootName.empty() )
+            name = rootName + '/' + name;
+
+        if( sectionNode.hasAnyAssertions()
+           || !sectionNode.stdOut.empty()
+           || !sectionNode.stdErr.empty() ) {
+            XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
+            if( className.empty() ) {
+                xml.writeAttribute( "classname"_sr, name );
+                xml.writeAttribute( "name"_sr, "root"_sr );
+            }
+            else {
+                xml.writeAttribute( "classname"_sr, className );
+                xml.writeAttribute( "name"_sr, name );
+            }
+            xml.writeAttribute( "time"_sr, formatDuration( sectionNode.stats.durationInSeconds ) );
+            // This is not ideal, but it should be enough to mimic gtest's
+            // junit output.
+            // Ideally the JUnit reporter would also handle `skipTest`
+            // events and write those out appropriately.
+            xml.writeAttribute( "status"_sr, "run"_sr );
+
+            if (sectionNode.stats.assertions.failedButOk) {
+                xml.scopedElement("skipped")
+                    .writeAttribute("message", "TEST_CASE tagged with !mayfail");
+            }
+
+            writeAssertions( sectionNode );
+
+
+            if( !sectionNode.stdOut.empty() )
+                xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), XmlFormatting::Newline );
+            if( !sectionNode.stdErr.empty() )
+                xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), XmlFormatting::Newline );
+        }
+        for( auto const& childNode : sectionNode.childSections )
+            if( className.empty() )
+                writeSection( name, "", *childNode, testOkToFail );
+            else
+                writeSection( className, name, *childNode, testOkToFail );
+    }
+
+    void JunitReporter::writeAssertions( SectionNode const& sectionNode ) {
+        for (auto const& assertionOrBenchmark : sectionNode.assertionsAndBenchmarks) {
+            if (assertionOrBenchmark.isAssertion()) {
+                writeAssertion(assertionOrBenchmark.asAssertion());
+            }
+        }
+    }
+
+    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:
+                case ResultWas::ExpressionFailed:
+                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"_sr, result.getExpression() );
+            xml.writeAttribute( "type"_sr, result.getTestMacroName() );
+
+            ReusableStringStream rss;
+            if (stats.totals.assertions.total() > 0) {
+                rss << "FAILED" << ":\n";
+                if (result.hasExpression()) {
+                    rss << "  ";
+                    rss << result.getExpressionInMacro();
+                    rss << '\n';
+                }
+                if (result.hasExpandedExpression()) {
+                    rss << "with expansion:\n";
+                    rss << TextFlow::Column(result.getExpandedExpression()).indent(2) << '\n';
+                }
+            } else {
+                rss << '\n';
+            }
+
+            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(), XmlFormatting::Newline );
+        }
+    }
+
+} // end namespace Catch
+
+
+
+
+#include <ostream>
+
+namespace Catch {
+    void MultiReporter::updatePreferences(IEventListener const& reporterish) {
+        m_preferences.shouldRedirectStdOut |=
+            reporterish.getPreferences().shouldRedirectStdOut;
+        m_preferences.shouldReportAllAssertions |=
+            reporterish.getPreferences().shouldReportAllAssertions;
+    }
+
+    void MultiReporter::addListener( IEventListenerPtr&& listener ) {
+        updatePreferences(*listener);
+        m_reporterLikes.insert(m_reporterLikes.begin() + m_insertedListeners, CATCH_MOVE(listener) );
+        ++m_insertedListeners;
+    }
+
+    void MultiReporter::addReporter( IEventListenerPtr&& reporter ) {
+        updatePreferences(*reporter);
+
+        // We will need to output the captured stdout if there are reporters
+        // that do not want it captured.
+        // We do not consider listeners, because it is generally assumed that
+        // listeners are output-transparent, even though they can ask for stdout
+        // capture to do something with it.
+        m_haveNoncapturingReporters |= !reporter->getPreferences().shouldRedirectStdOut;
+
+        // Reporters can always be placed to the back without breaking the
+        // reporting order
+        m_reporterLikes.push_back( CATCH_MOVE( reporter ) );
+    }
+
+    void MultiReporter::noMatchingTestCases( StringRef unmatchedSpec ) {
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->noMatchingTestCases( unmatchedSpec );
+        }
+    }
+
+    void MultiReporter::fatalErrorEncountered( StringRef error ) {
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->fatalErrorEncountered( error );
+        }
+    }
+
+    void MultiReporter::reportInvalidTestSpec( StringRef arg ) {
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->reportInvalidTestSpec( arg );
+        }
+    }
+
+    void MultiReporter::benchmarkPreparing( StringRef name ) {
+        for (auto& reporterish : m_reporterLikes) {
+            reporterish->benchmarkPreparing(name);
+        }
+    }
+    void MultiReporter::benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) {
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->benchmarkStarting( benchmarkInfo );
+        }
+    }
+    void MultiReporter::benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) {
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->benchmarkEnded( benchmarkStats );
+        }
+    }
+
+    void MultiReporter::benchmarkFailed( StringRef error ) {
+        for (auto& reporterish : m_reporterLikes) {
+            reporterish->benchmarkFailed(error);
+        }
+    }
+
+    void MultiReporter::testRunStarting( TestRunInfo const& testRunInfo ) {
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->testRunStarting( testRunInfo );
+        }
+    }
+
+    void MultiReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->testCaseStarting( testInfo );
+        }
+    }
+
+    void
+    MultiReporter::testCasePartialStarting( TestCaseInfo const& testInfo,
+                                                uint64_t partNumber ) {
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->testCasePartialStarting( testInfo, partNumber );
+        }
+    }
+
+    void MultiReporter::sectionStarting( SectionInfo const& sectionInfo ) {
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->sectionStarting( sectionInfo );
+        }
+    }
+
+    void MultiReporter::assertionStarting( AssertionInfo const& assertionInfo ) {
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->assertionStarting( assertionInfo );
+        }
+    }
+
+    // The return value indicates if the messages buffer should be cleared:
+    void MultiReporter::assertionEnded( AssertionStats const& assertionStats ) {
+        const bool reportByDefault =
+            assertionStats.assertionResult.getResultType() != ResultWas::Ok ||
+            m_config->includeSuccessfulResults();
+
+        for ( auto & reporterish : m_reporterLikes ) {
+            if ( reportByDefault ||
+                 reporterish->getPreferences().shouldReportAllAssertions ) {
+                    reporterish->assertionEnded( assertionStats );
+            }
+        }
+    }
+
+    void MultiReporter::sectionEnded( SectionStats const& sectionStats ) {
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->sectionEnded( sectionStats );
+        }
+    }
+
+    void MultiReporter::testCasePartialEnded( TestCaseStats const& testStats,
+                                                  uint64_t partNumber ) {
+        if ( m_preferences.shouldRedirectStdOut &&
+             m_haveNoncapturingReporters ) {
+            if ( !testStats.stdOut.empty() ) {
+                Catch::cout() << testStats.stdOut << std::flush;
+            }
+            if ( !testStats.stdErr.empty() ) {
+                Catch::cerr() << testStats.stdErr << std::flush;
+            }
+        }
+
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->testCasePartialEnded( testStats, partNumber );
+        }
+    }
+
+    void MultiReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->testCaseEnded( testCaseStats );
+        }
+    }
+
+    void MultiReporter::testRunEnded( TestRunStats const& testRunStats ) {
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->testRunEnded( testRunStats );
+        }
+    }
+
+
+    void MultiReporter::skipTest( TestCaseInfo const& testInfo ) {
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->skipTest( testInfo );
+        }
+    }
+
+    void MultiReporter::listReporters(std::vector<ReporterDescription> const& descriptions) {
+        for (auto& reporterish : m_reporterLikes) {
+            reporterish->listReporters(descriptions);
+        }
+    }
+
+    void MultiReporter::listListeners(
+        std::vector<ListenerDescription> const& descriptions ) {
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->listListeners( descriptions );
+        }
+    }
+
+    void MultiReporter::listTests(std::vector<TestCaseHandle> const& tests) {
+        for (auto& reporterish : m_reporterLikes) {
+            reporterish->listTests(tests);
+        }
+    }
+
+    void MultiReporter::listTags(std::vector<TagInfo> const& tags) {
+        for (auto& reporterish : m_reporterLikes) {
+            reporterish->listTags(tags);
+        }
+    }
+
+} // end namespace Catch
+
+
+
+
+
+namespace Catch {
+    namespace Detail {
+
+        void registerReporterImpl( std::string const& name,
+                                   IReporterFactoryPtr reporterPtr ) {
+            CATCH_TRY {
+                getMutableRegistryHub().registerReporter(
+                    name, CATCH_MOVE( reporterPtr ) );
+            }
+            CATCH_CATCH_ALL {
+                // Do not throw when constructing global objects, instead
+                // register the exception to be processed later
+                getMutableRegistryHub().registerStartupException();
+            }
+        }
+
+    } // namespace Detail
+} // namespace Catch
+
+
+
+
+#include <map>
+
+namespace Catch {
+
+    namespace {
+        std::string createRngSeedString(uint32_t seed) {
+            ReusableStringStream sstr;
+            sstr << "rng-seed=" << seed;
+            return sstr.str();
+        }
+    }
+
+    void SonarQubeReporter::testRunStarting(TestRunInfo const& testRunInfo) {
+        CumulativeReporterBase::testRunStarting(testRunInfo);
+
+        xml.writeComment( createRngSeedString( m_config->rngSeed() ) );
+        xml.startElement("testExecutions");
+        xml.writeAttribute("version"_sr, '1');
+    }
+
+    void SonarQubeReporter::writeRun( TestRunNode const& runNode ) {
+        std::map<std::string, std::vector<TestCaseNode const*>> testsPerFile;
+
+        for ( auto const& child : runNode.children ) {
+            testsPerFile[child->value.testInfo->lineInfo.file].push_back(
+                child.get() );
+        }
+
+        for ( auto const& kv : testsPerFile ) {
+            writeTestFile( kv.first, kv.second );
+        }
+    }
+
+    void SonarQubeReporter::writeTestFile(std::string const& filename, std::vector<TestCaseNode const*> const& testCaseNodes) {
+        XmlWriter::ScopedElement e = xml.scopedElement("file");
+        xml.writeAttribute("path"_sr, filename);
+
+        for (auto const& child : testCaseNodes)
+            writeTestCase(*child);
+    }
+
+    void SonarQubeReporter::writeTestCase(TestCaseNode const& testCaseNode) {
+        // 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();
+        writeSection("", rootSection, testCaseNode.value.testInfo->okToFail());
+    }
+
+    void SonarQubeReporter::writeSection(std::string const& rootName, SectionNode const& sectionNode, bool okToFail) {
+        std::string name = trim(sectionNode.stats.sectionInfo.name);
+        if (!rootName.empty())
+            name = rootName + '/' + name;
+
+        if ( sectionNode.hasAnyAssertions()
+            || !sectionNode.stdOut.empty()
+            ||  !sectionNode.stdErr.empty() ) {
+            XmlWriter::ScopedElement e = xml.scopedElement("testCase");
+            xml.writeAttribute("name"_sr, name);
+            xml.writeAttribute("duration"_sr, static_cast<long>(sectionNode.stats.durationInSeconds * 1000));
+
+            writeAssertions(sectionNode, okToFail);
+        }
+
+        for (auto const& childNode : sectionNode.childSections)
+            writeSection(name, *childNode, okToFail);
+    }
+
+    void SonarQubeReporter::writeAssertions(SectionNode const& sectionNode, bool okToFail) {
+        for (auto const& assertionOrBenchmark : sectionNode.assertionsAndBenchmarks) {
+            if (assertionOrBenchmark.isAssertion()) {
+                writeAssertion(assertionOrBenchmark.asAssertion(), okToFail);
+            }
+        }
+    }
+
+    void SonarQubeReporter::writeAssertion(AssertionStats const& stats, bool okToFail) {
+        AssertionResult const& result = stats.assertionResult;
+        if (!result.isOk()) {
+            std::string elementName;
+            if (okToFail) {
+                elementName = "skipped";
+            } else {
+                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);
+
+            ReusableStringStream messageRss;
+            messageRss << result.getTestMacroName() << '(' << result.getExpression() << ')';
+            xml.writeAttribute("message"_sr, messageRss.str());
+
+            ReusableStringStream textRss;
+            if (stats.totals.assertions.total() > 0) {
+                textRss << "FAILED:\n";
+                if (result.hasExpression()) {
+                    textRss << '\t' << result.getExpressionInMacro() << '\n';
+                }
+                if (result.hasExpandedExpression()) {
+                    textRss << "with expansion:\n\t" << result.getExpandedExpression() << '\n';
+                }
+            }
+
+            if (!result.getMessage().empty())
+                textRss << result.getMessage() << '\n';
+
+            for (auto const& msg : stats.infoMessages)
+                if (msg.type == ResultWas::Info)
+                    textRss << msg.message << '\n';
+
+            textRss << "at " << result.getSourceInfo();
+            xml.writeText(textRss.str(), XmlFormatting::Newline);
+        }
+    }
+
+} // end namespace Catch
+
+
+
+namespace Catch {
+
+    StreamingReporterBase::~StreamingReporterBase() = default;
+
+    void
+    StreamingReporterBase::testRunStarting( TestRunInfo const& _testRunInfo ) {
+        currentTestRunInfo = _testRunInfo;
+    }
+
+    void StreamingReporterBase::testRunEnded( TestRunStats const& ) {
+        currentTestCaseInfo = nullptr;
+    }
+
+} // end namespace Catch
+
+
+
+#include <algorithm>
+#include <iterator>
+#include <ostream>
+
+namespace Catch {
+
+    namespace {
+        // Yes, this has to be outside the class and namespaced by naming.
+        // Making older compiler happy is hard.
+        static constexpr StringRef tapFailedString = "not ok"_sr;
+        static constexpr StringRef tapPassedString = "ok"_sr;
+        static constexpr Colour::Code tapDimColour = Colour::FileName;
+
+        class TapAssertionPrinter {
+        public:
+            TapAssertionPrinter& operator= (TapAssertionPrinter const&) = delete;
+            TapAssertionPrinter(TapAssertionPrinter const&) = delete;
+            TapAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, std::size_t _counter, ColourImpl* colour_)
+                : stream(_stream)
+                , result(_stats.assertionResult)
+                , messages(_stats.infoMessages)
+                , itMessage(_stats.infoMessages.begin())
+                , printInfoMessages(true)
+                , counter(_counter)
+                , colourImpl( colour_ ) {}
+
+            void print() {
+                itMessage = messages.begin();
+
+                switch (result.getResultType()) {
+                case ResultWas::Ok:
+                    printResultType(tapPassedString);
+                    printOriginalExpression();
+                    printReconstructedExpression();
+                    if (!result.hasExpression())
+                        printRemainingMessages(Colour::None);
+                    else
+                        printRemainingMessages();
+                    break;
+                case ResultWas::ExpressionFailed:
+                    if (result.isOk()) {
+                        printResultType(tapPassedString);
+                    } else {
+                        printResultType(tapFailedString);
+                    }
+                    printOriginalExpression();
+                    printReconstructedExpression();
+                    if (result.isOk()) {
+                        printIssue(" # TODO");
+                    }
+                    printRemainingMessages();
+                    break;
+                case ResultWas::ThrewException:
+                    printResultType(tapFailedString);
+                    printIssue("unexpected exception with message:"_sr);
+                    printMessage();
+                    printExpressionWas();
+                    printRemainingMessages();
+                    break;
+                case ResultWas::FatalErrorCondition:
+                    printResultType(tapFailedString);
+                    printIssue("fatal error condition with message:"_sr);
+                    printMessage();
+                    printExpressionWas();
+                    printRemainingMessages();
+                    break;
+                case ResultWas::DidntThrowException:
+                    printResultType(tapFailedString);
+                    printIssue("expected exception, got none"_sr);
+                    printExpressionWas();
+                    printRemainingMessages();
+                    break;
+                case ResultWas::Info:
+                    printResultType("info"_sr);
+                    printMessage();
+                    printRemainingMessages();
+                    break;
+                case ResultWas::Warning:
+                    printResultType("warning"_sr);
+                    printMessage();
+                    printRemainingMessages();
+                    break;
+                case ResultWas::ExplicitFailure:
+                    printResultType(tapFailedString);
+                    printIssue("explicitly"_sr);
+                    printRemainingMessages(Colour::None);
+                    break;
+                    // These cases are here to prevent compiler warnings
+                case ResultWas::Unknown:
+                case ResultWas::FailureBit:
+                case ResultWas::Exception:
+                    printResultType("** internal error **"_sr);
+                    break;
+                }
+            }
+
+        private:
+            void printResultType(StringRef passOrFail) const {
+                if (!passOrFail.empty()) {
+                    stream << passOrFail << ' ' << counter << " -";
+                }
+            }
+
+            void printIssue(StringRef issue) const {
+                stream << ' ' << issue;
+            }
+
+            void printExpressionWas() {
+                if (result.hasExpression()) {
+                    stream << ';';
+                    stream << colourImpl->guardColour( tapDimColour )
+                           << " expression was:";
+                    printOriginalExpression();
+                }
+            }
+
+            void printOriginalExpression() const {
+                if (result.hasExpression()) {
+                    stream << ' ' << result.getExpression();
+                }
+            }
+
+            void printReconstructedExpression() const {
+                if (result.hasExpandedExpression()) {
+                    stream << colourImpl->guardColour( tapDimColour ) << " for: ";
+
+                    std::string expr = result.getExpandedExpression();
+                    std::replace(expr.begin(), expr.end(), '\n', ' ');
+                    stream << expr;
+                }
+            }
+
+            void printMessage() {
+                if (itMessage != messages.end()) {
+                    stream << " '" << itMessage->message << '\'';
+                    ++itMessage;
+                }
+            }
+
+            void printRemainingMessages(Colour::Code colour = tapDimColour) {
+                if (itMessage == messages.end()) {
+                    return;
+                }
+
+                // using messages.end() directly (or auto) yields compilation error:
+                std::vector<MessageInfo>::const_iterator itEnd = messages.end();
+                const std::size_t N = static_cast<std::size_t>(std::distance(itMessage, itEnd));
+
+                stream << colourImpl->guardColour( colour ) << " with "
+                       << pluralise( N, "message"_sr ) << ':';
+
+                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) {
+                            stream << colourImpl->guardColour(tapDimColour) << " and";
+                        }
+                    }
+                }
+            }
+
+        private:
+            std::ostream& stream;
+            AssertionResult const& result;
+            std::vector<MessageInfo> messages;
+            std::vector<MessageInfo>::const_iterator itMessage;
+            bool printInfoMessages;
+            std::size_t counter;
+            ColourImpl* colourImpl;
+        };
+
+    } // End anonymous namespace
+
+    void TAPReporter::testRunStarting( TestRunInfo const& ) {
+        m_stream << "# rng-seed: " << m_config->rngSeed() << '\n';
+    }
+
+    void TAPReporter::noMatchingTestCases( StringRef unmatchedSpec ) {
+        m_stream << "# No test cases matched '" << unmatchedSpec << "'\n";
+    }
+
+    void TAPReporter::assertionEnded(AssertionStats const& _assertionStats) {
+        ++counter;
+
+        m_stream << "# " << currentTestCaseInfo->name << '\n';
+        TapAssertionPrinter printer(m_stream, _assertionStats, counter, m_colour.get());
+        printer.print();
+
+        m_stream << '\n' << std::flush;
+    }
+
+    void TAPReporter::testRunEnded(TestRunStats const& _testRunStats) {
+        m_stream << "1.." << _testRunStats.totals.assertions.total();
+        if (_testRunStats.totals.testCases.total() == 0) {
+            m_stream << " # Skipped: No tests ran.";
+        }
+        m_stream << "\n\n" << std::flush;
+        StreamingReporterBase::testRunEnded(_testRunStats);
+    }
+
+
+
+
+} // end namespace Catch
+
+
+
+
+#include <cassert>
+#include <ostream>
+
+namespace Catch {
+
+    namespace {
+        // if string has a : in first line will set indent to follow it on
+        // subsequent lines
+        void printHeaderString(std::ostream& os, 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;
+            os << TextFlow::Column(_string)
+                  .indent(indent + i)
+                  .initialIndent(indent) << '\n';
+        }
+
+        std::string escape(StringRef str) {
+            std::string escaped = static_cast<std::string>(str);
+            replaceInPlace(escaped, "|", "||");
+            replaceInPlace(escaped, "'", "|'");
+            replaceInPlace(escaped, "\n", "|n");
+            replaceInPlace(escaped, "\r", "|r");
+            replaceInPlace(escaped, "[", "|[");
+            replaceInPlace(escaped, "]", "|]");
+            return escaped;
+        }
+    } // end anonymous namespace
+
+
+    TeamCityReporter::~TeamCityReporter() {}
+
+    void TeamCityReporter::testRunStarting( TestRunInfo const& runInfo ) {
+        m_stream << "##teamcity[testSuiteStarted name='" << escape( runInfo.name )
+               << "']\n";
+    }
+
+    void TeamCityReporter::testRunEnded( TestRunStats const& runStats ) {
+        m_stream << "##teamcity[testSuiteFinished name='"
+               << escape( runStats.runInfo.name ) << "']\n";
+    }
+
+    void TeamCityReporter::assertionEnded(AssertionStats const& assertionStats) {
+        AssertionResult const& result = assertionStats.assertionResult;
+        if (!result.isOk()) {
+
+            ReusableStringStream msg;
+            if (!m_headerPrintedForThisSection)
+                printSectionHeader(msg.get());
+            m_headerPrintedForThisSection = true;
+
+            msg << result.getSourceInfo() << '\n';
+
+            switch (result.getResultType()) {
+            case ResultWas::ExpressionFailed:
+                msg << "expression failed";
+                break;
+            case ResultWas::ThrewException:
+                msg << "unexpected exception";
+                break;
+            case ResultWas::FatalErrorCondition:
+                msg << "fatal error condition";
+                break;
+            case ResultWas::DidntThrowException:
+                msg << "no exception was thrown where one was expected";
+                break;
+            case ResultWas::ExplicitFailure:
+                msg << "explicit failure";
+                break;
+
+                // We shouldn't get here because of the isOk() test
+            case ResultWas::Ok:
+            case ResultWas::Info:
+            case ResultWas::Warning:
+                CATCH_ERROR("Internal error in TeamCity reporter");
+                // These cases are here to prevent compiler warnings
+            case ResultWas::Unknown:
+            case ResultWas::FailureBit:
+            case ResultWas::Exception:
+                CATCH_ERROR("Not implemented");
+            }
+            if (assertionStats.infoMessages.size() == 1)
+                msg << " with message:";
+            if (assertionStats.infoMessages.size() > 1)
+                msg << " with messages:";
+            for (auto const& messageInfo : assertionStats.infoMessages)
+                msg << "\n  \"" << messageInfo.message << '"';
+
+
+            if (result.hasExpression()) {
+                msg <<
+                    "\n  " << result.getExpressionInMacro() << "\n"
+                    "with expansion:\n"
+                    "  " << result.getExpandedExpression() << '\n';
+            }
+
+            if (currentTestCaseInfo->okToFail()) {
+                msg << "- failure ignore as test marked as 'ok to fail'\n";
+                m_stream << "##teamcity[testIgnored"
+                    << " name='" << escape(currentTestCaseInfo->name) << '\''
+                    << " message='" << escape(msg.str()) << '\''
+                    << "]\n";
+            } else {
+                m_stream << "##teamcity[testFailed"
+                    << " name='" << escape(currentTestCaseInfo->name) << '\''
+                    << " message='" << escape(msg.str()) << '\''
+                    << "]\n";
+            }
+        }
+        m_stream.flush();
+    }
+
+    void TeamCityReporter::testCaseStarting(TestCaseInfo const& testInfo) {
+        m_testTimer.start();
+        StreamingReporterBase::testCaseStarting(testInfo);
+        m_stream << "##teamcity[testStarted name='"
+            << escape(testInfo.name) << "']\n";
+        m_stream.flush();
+    }
+
+    void TeamCityReporter::testCaseEnded(TestCaseStats const& testCaseStats) {
+        StreamingReporterBase::testCaseEnded(testCaseStats);
+        auto const& testCaseInfo = *testCaseStats.testInfo;
+        if (!testCaseStats.stdOut.empty())
+            m_stream << "##teamcity[testStdOut name='"
+            << escape(testCaseInfo.name)
+            << "' out='" << escape(testCaseStats.stdOut) << "']\n";
+        if (!testCaseStats.stdErr.empty())
+            m_stream << "##teamcity[testStdErr name='"
+            << escape(testCaseInfo.name)
+            << "' out='" << escape(testCaseStats.stdErr) << "']\n";
+        m_stream << "##teamcity[testFinished name='"
+            << escape(testCaseInfo.name) << "' duration='"
+            << m_testTimer.getElapsedMilliseconds() << "']\n";
+        m_stream.flush();
+    }
+
+    void TeamCityReporter::printSectionHeader(std::ostream& os) {
+        assert(!m_sectionStack.empty());
+
+        if (m_sectionStack.size() > 1) {
+            os << lineOfChars('-') << '\n';
+
+            std::vector<SectionInfo>::const_iterator
+                it = m_sectionStack.begin() + 1, // Skip first section (test case)
+                itEnd = m_sectionStack.end();
+            for (; it != itEnd; ++it)
+                printHeaderString(os, it->name);
+            os << lineOfChars('-') << '\n';
+        }
+
+        SourceLineInfo lineInfo = m_sectionStack.front().lineInfo;
+
+        os << lineInfo << '\n';
+        os << lineOfChars('.') << "\n\n";
+    }
+
+} // end namespace Catch
+
+
+
+
+#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 {
+    XmlReporter::XmlReporter( ReporterConfig&& _config )
+    :   StreamingReporterBase( CATCH_MOVE(_config) ),
+        m_xml(m_stream)
+    {
+        m_preferences.shouldRedirectStdOut = true;
+        m_preferences.shouldReportAllAssertions = true;
+    }
+
+    XmlReporter::~XmlReporter() = default;
+
+    std::string XmlReporter::getDescription() {
+        return "Reports test results as an XML document";
+    }
+
+    std::string XmlReporter::getStylesheetRef() const {
+        return std::string();
+    }
+
+    void XmlReporter::writeSourceInfo( SourceLineInfo const& sourceInfo ) {
+        m_xml
+            .writeAttribute( "filename"_sr, sourceInfo.file )
+            .writeAttribute( "line"_sr, sourceInfo.line );
+    }
+
+    void XmlReporter::testRunStarting( TestRunInfo const& testInfo ) {
+        StreamingReporterBase::testRunStarting( testInfo );
+        std::string stylesheetRef = getStylesheetRef();
+        if( !stylesheetRef.empty() )
+            m_xml.writeStylesheetRef( stylesheetRef );
+        m_xml.startElement("Catch2TestRun")
+             .writeAttribute("name"_sr, m_config->name())
+             .writeAttribute("rng-seed"_sr, m_config->rngSeed())
+             .writeAttribute("catch2-version"_sr, libraryVersion());
+        if (m_config->testSpec().hasFilters())
+            m_xml.writeAttribute( "filters"_sr, serializeFilters( m_config->getTestsOrTags() ) );
+    }
+
+    void XmlReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
+        StreamingReporterBase::testCaseStarting(testInfo);
+        m_xml.startElement( "TestCase" )
+            .writeAttribute( "name"_sr, trim( testInfo.name ) )
+            .writeAttribute( "tags"_sr, testInfo.tagsAsString() );
+
+        writeSourceInfo( testInfo.lineInfo );
+
+        if ( m_config->showDurations() == ShowDurations::Always )
+            m_testCaseTimer.start();
+        m_xml.ensureTagClosed();
+    }
+
+    void XmlReporter::sectionStarting( SectionInfo const& sectionInfo ) {
+        StreamingReporterBase::sectionStarting( sectionInfo );
+        if( m_sectionDepth++ > 0 ) {
+            m_xml.startElement( "Section" )
+                .writeAttribute( "name"_sr, trim( sectionInfo.name ) );
+            writeSourceInfo( sectionInfo.lineInfo );
+            m_xml.ensureTagClosed();
+        }
+    }
+
+    void XmlReporter::assertionStarting( AssertionInfo const& ) { }
+
+    void 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;
+
+
+        // Print the expression if there is one.
+        if( result.hasExpression() ) {
+            m_xml.startElement( "Expression" )
+                .writeAttribute( "success"_sr, result.succeeded() )
+                .writeAttribute( "type"_sr, 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();
+    }
+
+    void XmlReporter::sectionEnded( SectionStats const& sectionStats ) {
+        StreamingReporterBase::sectionEnded( sectionStats );
+        if( --m_sectionDepth > 0 ) {
+            XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
+            e.writeAttribute( "successes"_sr, sectionStats.assertions.passed );
+            e.writeAttribute( "failures"_sr, sectionStats.assertions.failed );
+            e.writeAttribute( "expectedFailures"_sr, sectionStats.assertions.failedButOk );
+
+            if ( m_config->showDurations() == ShowDurations::Always )
+                e.writeAttribute( "durationInSeconds"_sr, sectionStats.durationInSeconds );
+
+            m_xml.endElement();
+        }
+    }
+
+    void XmlReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+        StreamingReporterBase::testCaseEnded( testCaseStats );
+        XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
+        e.writeAttribute( "success"_sr, testCaseStats.totals.assertions.allOk() );
+
+        if ( m_config->showDurations() == ShowDurations::Always )
+            e.writeAttribute( "durationInSeconds"_sr, m_testCaseTimer.getElapsedSeconds() );
+
+        if( !testCaseStats.stdOut.empty() )
+            m_xml.scopedElement( "StdOut" ).writeText( trim( testCaseStats.stdOut ), XmlFormatting::Newline );
+        if( !testCaseStats.stdErr.empty() )
+            m_xml.scopedElement( "StdErr" ).writeText( trim( testCaseStats.stdErr ), XmlFormatting::Newline );
+
+        m_xml.endElement();
+    }
+
+    void XmlReporter::testRunEnded( TestRunStats const& testRunStats ) {
+        StreamingReporterBase::testRunEnded( testRunStats );
+        m_xml.scopedElement( "OverallResults" )
+            .writeAttribute( "successes"_sr, testRunStats.totals.assertions.passed )
+            .writeAttribute( "failures"_sr, testRunStats.totals.assertions.failed )
+            .writeAttribute( "expectedFailures"_sr, testRunStats.totals.assertions.failedButOk );
+        m_xml.scopedElement( "OverallResultsCases")
+            .writeAttribute( "successes"_sr, testRunStats.totals.testCases.passed )
+            .writeAttribute( "failures"_sr, testRunStats.totals.testCases.failed )
+            .writeAttribute( "expectedFailures"_sr, testRunStats.totals.testCases.failedButOk );
+        m_xml.endElement();
+    }
+
+    void XmlReporter::benchmarkPreparing( StringRef name ) {
+        m_xml.startElement("BenchmarkResults")
+             .writeAttribute("name"_sr, name);
+    }
+
+    void XmlReporter::benchmarkStarting(BenchmarkInfo const &info) {
+        m_xml.writeAttribute("samples"_sr, info.samples)
+            .writeAttribute("resamples"_sr, info.resamples)
+            .writeAttribute("iterations"_sr, info.iterations)
+            .writeAttribute("clockResolution"_sr, info.clockResolution)
+            .writeAttribute("estimatedDuration"_sr, info.estimatedDuration)
+            .writeComment("All values in nano seconds"_sr);
+    }
+
+    void XmlReporter::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) {
+        m_xml.startElement("mean")
+            .writeAttribute("value"_sr, benchmarkStats.mean.point.count())
+            .writeAttribute("lowerBound"_sr, benchmarkStats.mean.lower_bound.count())
+            .writeAttribute("upperBound"_sr, benchmarkStats.mean.upper_bound.count())
+            .writeAttribute("ci"_sr, benchmarkStats.mean.confidence_interval);
+        m_xml.endElement();
+        m_xml.startElement("standardDeviation")
+            .writeAttribute("value"_sr, benchmarkStats.standardDeviation.point.count())
+            .writeAttribute("lowerBound"_sr, benchmarkStats.standardDeviation.lower_bound.count())
+            .writeAttribute("upperBound"_sr, benchmarkStats.standardDeviation.upper_bound.count())
+            .writeAttribute("ci"_sr, benchmarkStats.standardDeviation.confidence_interval);
+        m_xml.endElement();
+        m_xml.startElement("outliers")
+            .writeAttribute("variance"_sr, benchmarkStats.outlierVariance)
+            .writeAttribute("lowMild"_sr, benchmarkStats.outliers.low_mild)
+            .writeAttribute("lowSevere"_sr, benchmarkStats.outliers.low_severe)
+            .writeAttribute("highMild"_sr, benchmarkStats.outliers.high_mild)
+            .writeAttribute("highSevere"_sr, benchmarkStats.outliers.high_severe);
+        m_xml.endElement();
+        m_xml.endElement();
+    }
+
+    void XmlReporter::benchmarkFailed(StringRef error) {
+        m_xml.scopedElement("failed").
+            writeAttribute("message"_sr, error);
+        m_xml.endElement();
+    }
+
+    void XmlReporter::listReporters(std::vector<ReporterDescription> const& descriptions) {
+        auto outerTag = m_xml.scopedElement("AvailableReporters");
+        for (auto const& reporter : descriptions) {
+            auto inner = m_xml.scopedElement("Reporter");
+            m_xml.startElement("Name", XmlFormatting::Indent)
+                 .writeText(reporter.name, XmlFormatting::None)
+                 .endElement(XmlFormatting::Newline);
+            m_xml.startElement("Description", XmlFormatting::Indent)
+                 .writeText(reporter.description, XmlFormatting::None)
+                 .endElement(XmlFormatting::Newline);
+        }
+    }
+
+    void XmlReporter::listListeners(std::vector<ListenerDescription> const& descriptions) {
+        auto outerTag = m_xml.scopedElement( "RegisteredListeners" );
+        for ( auto const& listener : descriptions ) {
+            auto inner = m_xml.scopedElement( "Listener" );
+            m_xml.startElement( "Name", XmlFormatting::Indent )
+                .writeText( listener.name, XmlFormatting::None )
+                .endElement( XmlFormatting::Newline );
+            m_xml.startElement( "Description", XmlFormatting::Indent )
+                .writeText( listener.description, XmlFormatting::None )
+                .endElement( XmlFormatting::Newline );
+        }
+    }
+
+    void XmlReporter::listTests(std::vector<TestCaseHandle> const& tests) {
+        auto outerTag = m_xml.scopedElement("MatchingTests");
+        for (auto const& test : tests) {
+            auto innerTag = m_xml.scopedElement("TestCase");
+            auto const& testInfo = test.getTestCaseInfo();
+            m_xml.startElement("Name", XmlFormatting::Indent)
+                 .writeText(testInfo.name, XmlFormatting::None)
+                 .endElement(XmlFormatting::Newline);
+            m_xml.startElement("ClassName", XmlFormatting::Indent)
+                 .writeText(testInfo.className, XmlFormatting::None)
+                 .endElement(XmlFormatting::Newline);
+            m_xml.startElement("Tags", XmlFormatting::Indent)
+                 .writeText(testInfo.tagsAsString(), XmlFormatting::None)
+                 .endElement(XmlFormatting::Newline);
+
+            auto sourceTag = m_xml.scopedElement("SourceInfo");
+            m_xml.startElement("File", XmlFormatting::Indent)
+                 .writeText(testInfo.lineInfo.file, XmlFormatting::None)
+                 .endElement(XmlFormatting::Newline);
+            m_xml.startElement("Line", XmlFormatting::Indent)
+                 .writeText(std::to_string(testInfo.lineInfo.line), XmlFormatting::None)
+                 .endElement(XmlFormatting::Newline);
+        }
+    }
+
+    void XmlReporter::listTags(std::vector<TagInfo> const& tags) {
+        auto outerTag = m_xml.scopedElement("TagsFromMatchingTests");
+        for (auto const& tag : tags) {
+            auto innerTag = m_xml.scopedElement("Tag");
+            m_xml.startElement("Count", XmlFormatting::Indent)
+                 .writeText(std::to_string(tag.count), XmlFormatting::None)
+                 .endElement(XmlFormatting::Newline);
+            auto aliasTag = m_xml.scopedElement("Aliases");
+            for (auto const& alias : tag.spellings) {
+                m_xml.startElement("Alias", XmlFormatting::Indent)
+                     .writeText(alias, XmlFormatting::None)
+                     .endElement(XmlFormatting::Newline);
+            }
+        }
+    }
+
+} // end namespace Catch
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
diff --git a/Tests/Contrib/Catch/catch_amalgamated.hpp b/Tests/Contrib/Catch/catch_amalgamated.hpp
new file mode 100644
index 000000000..cff2cedfa
--- /dev/null
+++ b/Tests/Contrib/Catch/catch_amalgamated.hpp
@@ -0,0 +1,12260 @@
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+//  Catch v3.1.1
+//  Generated: 2022-10-17 18:47:20.510385
+//  ----------------------------------------------------------
+//  This file is an amalgamation of multiple different files.
+//  You probably shouldn't edit it directly.
+//  ----------------------------------------------------------
+#ifndef CATCH_AMALGAMATED_HPP_INCLUDED
+#define CATCH_AMALGAMATED_HPP_INCLUDED
+
+
+/** \file
+ * This is a convenience header for Catch2. It includes **all** of Catch2 headers.
+ *
+ * Generally the Catch2 users should use specific includes they need,
+ * but this header can be used instead for ease-of-experimentation, or
+ * just plain convenience, at the cost of (significantly) increased
+ * compilation times.
+ *
+ * When a new header is added to either the top level folder, or to the
+ * corresponding internal subfolder, it should be added here. Headers
+ * added to the various subparts (e.g. matchers, generators, etc...),
+ * should go their respective catch-all headers.
+ */
+
+#ifndef CATCH_ALL_HPP_INCLUDED
+#define CATCH_ALL_HPP_INCLUDED
+
+
+
+/** \file
+ * This is a convenience header for Catch2's benchmarking. It includes
+ * **all** of Catch2 headers related to benchmarking.
+ *
+ * Generally the Catch2 users should use specific includes they need,
+ * but this header can be used instead for ease-of-experimentation, or
+ * just plain convenience, at the cost of (significantly) increased
+ * compilation times.
+ *
+ * When a new header is added to either the `benchmark` folder, or to
+ * the corresponding internal (detail) subfolder, it should be added here.
+ */
+
+#ifndef CATCH_BENCHMARK_ALL_HPP_INCLUDED
+#define CATCH_BENCHMARK_ALL_HPP_INCLUDED
+
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_BENCHMARK_HPP_INCLUDED
+#define CATCH_BENCHMARK_HPP_INCLUDED
+
+
+
+#ifndef CATCH_INTERFACES_CONFIG_HPP_INCLUDED
+#define CATCH_INTERFACES_CONFIG_HPP_INCLUDED
+
+
+
+#ifndef CATCH_NONCOPYABLE_HPP_INCLUDED
+#define CATCH_NONCOPYABLE_HPP_INCLUDED
+
+namespace Catch {
+    namespace Detail {
+
+        //! Deriving classes become noncopyable and nonmovable
+        class NonCopyable {
+            NonCopyable( NonCopyable const& ) = delete;
+            NonCopyable( NonCopyable&& ) = delete;
+            NonCopyable& operator=( NonCopyable const& ) = delete;
+            NonCopyable& operator=( NonCopyable&& ) = delete;
+
+        protected:
+            NonCopyable() noexcept = default;
+        };
+
+    } // namespace Detail
+} // namespace Catch
+
+#endif // CATCH_NONCOPYABLE_HPP_INCLUDED
+
+
+#ifndef CATCH_STRINGREF_HPP_INCLUDED
+#define CATCH_STRINGREF_HPP_INCLUDED
+
+#include <cstddef>
+#include <string>
+#include <iosfwd>
+#include <cassert>
+
+namespace Catch {
+
+    /// 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.
+    class StringRef {
+    public:
+        using size_type = std::size_t;
+        using const_iterator = const char*;
+
+    private:
+        static constexpr char const* const s_empty = "";
+
+        char const* m_start = s_empty;
+        size_type m_size = 0;
+
+    public: // construction
+        constexpr StringRef() noexcept = default;
+
+        StringRef( char const* rawChars ) noexcept;
+
+        constexpr StringRef( char const* rawChars, size_type size ) noexcept
+        :   m_start( rawChars ),
+            m_size( size )
+        {}
+
+        StringRef( std::string const& stdString ) noexcept
+        :   m_start( stdString.c_str() ),
+            m_size( stdString.size() )
+        {}
+
+        explicit operator std::string() const {
+            return std::string(m_start, m_size);
+        }
+
+    public: // operators
+        auto operator == ( StringRef other ) const noexcept -> bool;
+        auto operator != (StringRef other) const noexcept -> bool {
+            return !(*this == other);
+        }
+
+        constexpr auto operator[] ( size_type index ) const noexcept -> char {
+            assert(index < m_size);
+            return m_start[index];
+        }
+
+        bool operator<(StringRef rhs) const noexcept;
+
+    public: // named queries
+        constexpr auto empty() const noexcept -> bool {
+            return m_size == 0;
+        }
+        constexpr auto size() const noexcept -> size_type {
+            return m_size;
+        }
+
+        // Returns a substring of [start, start + length).
+        // If start + length > size(), then the substring is [start, start + size()).
+        // If start > size(), then the substring is empty.
+        constexpr StringRef substr(size_type start, size_type length) const noexcept {
+            if (start < m_size) {
+                const auto shortened_size = m_size - start;
+                return StringRef(m_start + start, (shortened_size < length) ? shortened_size : length);
+            } else {
+                return StringRef();
+            }
+        }
+
+        // Returns the current start pointer. May not be null-terminated.
+        constexpr char const* data() const noexcept {
+            return m_start;
+        }
+
+        constexpr const_iterator begin() const { return m_start; }
+        constexpr const_iterator end() const { return m_start + m_size; }
+
+
+        friend std::string& operator += (std::string& lhs, StringRef sr);
+        friend std::ostream& operator << (std::ostream& os, StringRef sr);
+        friend std::string operator+(StringRef lhs, StringRef rhs);
+
+        /**
+         * Provides a three-way comparison with rhs
+         *
+         * Returns negative number if lhs < rhs, 0 if lhs == rhs, and a positive
+         * number if lhs > rhs
+         */
+        int compare( StringRef rhs ) const;
+    };
+
+
+    constexpr auto operator ""_sr( char const* rawChars, std::size_t size ) noexcept -> StringRef {
+        return StringRef( rawChars, size );
+    }
+} // namespace Catch
+
+constexpr auto operator ""_catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef {
+    return Catch::StringRef( rawChars, size );
+}
+
+#endif // CATCH_STRINGREF_HPP_INCLUDED
+
+#include <chrono>
+#include <iosfwd>
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+    enum class Verbosity {
+        Quiet = 0,
+        Normal,
+        High
+    };
+
+    struct WarnAbout { enum What {
+        Nothing = 0x00,
+        //! A test case or leaf section did not run any assertions
+        NoAssertions = 0x01,
+        //! A command line test spec matched no test cases
+        UnmatchedTestSpec = 0x02,
+    }; };
+
+    enum class ShowDurations {
+        DefaultForReporter,
+        Always,
+        Never
+    };
+    enum class TestRunOrder {
+        Declared,
+        LexicographicallySorted,
+        Randomized
+    };
+    enum class ColourMode : std::uint8_t {
+        //! Let Catch2 pick implementation based on platform detection
+        PlatformDefault,
+        //! Use ANSI colour code escapes
+        ANSI,
+        //! Use Win32 console colour API
+        Win32,
+        //! Don't use any colour
+        None
+    };
+    struct WaitForKeypress { enum When {
+        Never,
+        BeforeStart = 1,
+        BeforeExit = 2,
+        BeforeStartAndExit = BeforeStart | BeforeExit
+    }; };
+
+    class TestSpec;
+    class IStream;
+
+    class IConfig : public Detail::NonCopyable {
+    public:
+        virtual ~IConfig();
+
+        virtual bool allowThrows() const = 0;
+        virtual StringRef name() const = 0;
+        virtual bool includeSuccessfulResults() const = 0;
+        virtual bool shouldDebugBreak() const = 0;
+        virtual bool warnAboutMissingAssertions() const = 0;
+        virtual bool warnAboutUnmatchedTestSpecs() const = 0;
+        virtual bool zeroTestsCountAsSuccess() const = 0;
+        virtual int abortAfter() const = 0;
+        virtual bool showInvisibles() const = 0;
+        virtual ShowDurations showDurations() const = 0;
+        virtual double minDuration() const = 0;
+        virtual TestSpec const& testSpec() const = 0;
+        virtual bool hasTestFilters() const = 0;
+        virtual std::vector<std::string> const& getTestsOrTags() const = 0;
+        virtual TestRunOrder runOrder() const = 0;
+        virtual uint32_t rngSeed() const = 0;
+        virtual unsigned int shardCount() const = 0;
+        virtual unsigned int shardIndex() const = 0;
+        virtual ColourMode defaultColourMode() const = 0;
+        virtual std::vector<std::string> const& getSectionsToRun() const = 0;
+        virtual Verbosity verbosity() const = 0;
+
+        virtual bool skipBenchmarks() const = 0;
+        virtual bool benchmarkNoAnalysis() const = 0;
+        virtual unsigned int benchmarkSamples() const = 0;
+        virtual double benchmarkConfidenceInterval() const = 0;
+        virtual unsigned int benchmarkResamples() const = 0;
+        virtual std::chrono::milliseconds benchmarkWarmupTime() const = 0;
+    };
+}
+
+#endif // CATCH_INTERFACES_CONFIG_HPP_INCLUDED
+
+
+#ifndef CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
+#define CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
+
+// Detect a number of compiler features - by compiler
+// The following features are defined:
+//
+// 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
+// ****************
+
+// In general each macro has a _NO_<feature name> form
+// (e.g. CATCH_CONFIG_NO_POSIX_SIGNALS) which disables the feature.
+// Many features, at point of detection, define an _INTERNAL_ macro, so they
+// can be combined, en-mass, with the _NO_ forms later.
+
+
+
+#ifndef CATCH_PLATFORM_HPP_INCLUDED
+#define CATCH_PLATFORM_HPP_INCLUDED
+
+// See e.g.:
+// https://opensource.apple.com/source/CarbonHeaders/CarbonHeaders-18.1/TargetConditionals.h.auto.html
+#ifdef __APPLE__
+#  include <TargetConditionals.h>
+#  if (defined(TARGET_OS_OSX) && TARGET_OS_OSX == 1) || \
+      (defined(TARGET_OS_MAC) && TARGET_OS_MAC == 1)
+#    define CATCH_PLATFORM_MAC
+#  elif (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE == 1)
+#    define CATCH_PLATFORM_IPHONE
+#  endif
+
+#elif defined(linux) || defined(__linux) || defined(__linux__)
+#  define CATCH_PLATFORM_LINUX
+
+#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__)
+#  define CATCH_PLATFORM_WINDOWS
+
+#  if defined( WINAPI_FAMILY ) && ( WINAPI_FAMILY == WINAPI_FAMILY_APP )
+#      define CATCH_PLATFORM_WINDOWS_UWP
+#  endif
+#endif
+
+#endif // CATCH_PLATFORM_HPP_INCLUDED
+
+#ifdef __cplusplus
+
+#  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
+
+// Only GCC compiler should be used in this block, so other compilers trying to
+// mask themselves as GCC should be ignored.
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && !defined(__CUDACC__) && !defined(__LCC__)
+#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic push" )
+#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "GCC diagnostic pop" )
+
+// This only works on GCC 9+. so we have to also add a global suppression of Wparentheses
+// for older versions of GCC.
+#    define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+         _Pragma( "GCC diagnostic ignored \"-Wparentheses\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+         _Pragma( "GCC diagnostic ignored \"-Wunused-variable\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
+         _Pragma( "GCC diagnostic ignored \"-Wuseless-cast\"" )
+
+#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
+
+#endif
+
+#if defined(__CUDACC__) && !defined(__clang__)
+#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "nv_diagnostic push" )
+#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "nv_diagnostic pop" )
+#    define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS _Pragma( "nv_diag_suppress 177" )
+#endif
+
+// clang-cl defines _MSC_VER as well as __clang__, which could cause the
+// start/stop internal suppression macros to be double defined.
+#if defined(__clang__) && !defined(_MSC_VER)
+
+#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" )
+#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "clang diagnostic pop" )
+
+#endif // __clang__ && !_MSC_VER
+
+#if defined(__clang__)
+
+// As of this writing, IBM XL's implementation of __builtin_constant_p has a bug
+// which results in calls to destructors being emitted for each temporary,
+// without a matching initialization. In practice, this can result in something
+// like `std::string::~string` being called on an uninitialized value.
+//
+// For example, this code will likely segfault under IBM XL:
+// ```
+// REQUIRE(std::string("12") + "34" == "1234")
+// ```
+//
+// Similarly, NVHPC's implementation of `__builtin_constant_p` has a bug which
+// results in calls to the immediately evaluated lambda expressions to be
+// reported as unevaluated lambdas.
+// https://developer.nvidia.com/nvidia_bug/3321845.
+//
+// Therefore, `CATCH_INTERNAL_IGNORE_BUT_WARN` is not implemented.
+#  if !defined(__ibmxl__) && !defined(__CUDACC__) && !defined( __NVCOMPILER )
+#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__) /* NOLINT(cppcoreguidelines-pro-type-vararg, hicpp-vararg) */
+#  endif
+
+
+#    define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
+         _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
+
+#    define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wunused-template\"" )
+
+#endif // __clang__
+
+
+////////////////////////////////////////////////////////////////////////////////
+// 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__
+#       define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
+#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__
+
+// 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++
+#if defined(_MSC_VER)
+
+#  define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION __pragma( warning(push) )
+#  define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  __pragma( warning(pop) )
+
+// Universal Windows platform does not support SEH
+// Or console colours (or console at all...)
+#  if defined(CATCH_PLATFORM_WINDOWS_UWP)
+#    define CATCH_INTERNAL_CONFIG_NO_COLOUR_WIN32
+#  else
+#    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(__clang__) // Handle Clang masquerading for msvc
+#    if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL)
+#      define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#    endif // MSVC_TRADITIONAL
+#  endif // __clang__
+
+#endif // _MSC_VER
+
+#if defined(_REENTRANT) || defined(_MSC_VER)
+// Enable async processing, as -pthread is specified or no additional linking is required
+# define CATCH_INTERNAL_CONFIG_USE_ASYNC
+#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
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Embarcadero C++Build
+#if defined(__BORLANDC__)
+    #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+
+// RTX is a special version of Windows that is real time.
+// This means that it is detected as Windows, but does not provide
+// the same set of capabilities as real Windows does.
+#if defined(UNDER_RTSS) || defined(RTX64_BUILD)
+    #define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
+    #define CATCH_INTERNAL_CONFIG_NO_ASYNC
+    #define CATCH_INTERNAL_CONFIG_NO_COLOUR_WIN32
+#endif
+
+#if !defined(_GLIBCXX_USE_C99_MATH_TR1)
+#define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER
+#endif
+
+// Various stdlib support checks that require __has_include
+#if defined(__has_include)
+  // Check if string_view is available and usable
+  #if __has_include(<string_view>) && defined(CATCH_CPP17_OR_GREATER)
+  #    define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW
+  #endif
+
+  // Check if optional is available and usable
+  #  if __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
+  #    define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL
+  #  endif // __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
+
+  // Check if byte is available and usable
+  #  if __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
+  #    include <cstddef>
+  #    if defined(__cpp_lib_byte) && (__cpp_lib_byte > 0)
+  #      define CATCH_INTERNAL_CONFIG_CPP17_BYTE
+  #    endif
+  #  endif // __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
+
+  // Check if variant is available and usable
+  #  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)
+  #    else
+  #      define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
+  #    endif // defined(__clang__) && (__clang_major__ < 8)
+  #  endif // __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
+#endif // defined(__has_include)
+
+
+#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_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
+
+#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_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL)
+#  define CATCH_CONFIG_CPP17_OPTIONAL
+#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_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE)
+#  define CATCH_CONFIG_CPP17_BYTE
+#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 ) &&          \
+    !defined( CATCH_CONFIG_NO_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_CONFIG_USE_ASYNC)  && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC)
+#  define CATCH_CONFIG_USE_ASYNC
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
+#  define CATCH_CONFIG_GLOBAL_NEXTAFTER
+#endif
+
+
+// Even if we do not think the compiler has that warning, we still have
+// to provide a macro that can be used by the code.
+#if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION)
+#   define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
+#endif
+#if !defined(CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION)
+#   define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
+#endif
+
+// The goal of this macro is to avoid evaluation of the arguments, but
+// still have the compiler warn on problems inside...
+#if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN)
+#   define CATCH_INTERNAL_IGNORE_BUT_WARN(...)
+#endif
+
+#if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10)
+#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#elif defined(__clang__) && (__clang_major__ < 5)
+#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#endif
+
+#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_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
+
+#if defined( CATCH_PLATFORM_WINDOWS ) &&       \
+    !defined( CATCH_CONFIG_COLOUR_WIN32 ) && \
+    !defined( CATCH_CONFIG_NO_COLOUR_WIN32 ) && \
+    !defined( CATCH_INTERNAL_CONFIG_NO_COLOUR_WIN32 )
+#    define CATCH_CONFIG_COLOUR_WIN32
+#endif
+
+#if defined( CATCH_CONFIG_SHARED_LIBRARY ) && defined( _MSC_VER ) && \
+    !defined( CATCH_CONFIG_STATIC )
+#    ifdef Catch2_EXPORTS
+#        define CATCH_EXPORT //__declspec( dllexport ) // not needed
+#    else
+#        define CATCH_EXPORT __declspec( dllimport )
+#    endif
+#else
+#    define CATCH_EXPORT
+#endif
+
+#endif // CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
+
+
+#ifndef CATCH_CONTEXT_HPP_INCLUDED
+#define CATCH_CONTEXT_HPP_INCLUDED
+
+
+namespace Catch {
+
+    class IResultCapture;
+    class IConfig;
+
+    class IContext {
+    public:
+        virtual ~IContext(); // = default
+
+        virtual IResultCapture* getResultCapture() = 0;
+        virtual IConfig const* getConfig() const = 0;
+    };
+
+    class IMutableContext : public IContext {
+    public:
+        ~IMutableContext() override; // = default
+        virtual void setResultCapture( IResultCapture* resultCapture ) = 0;
+        virtual void setConfig( IConfig const* config ) = 0;
+
+    private:
+        CATCH_EXPORT static IMutableContext* currentContext;
+        friend IMutableContext& getCurrentMutableContext();
+        friend void cleanUpContext();
+        static void createContext();
+    };
+
+    inline IMutableContext& getCurrentMutableContext()
+    {
+        if( !IMutableContext::currentContext )
+            IMutableContext::createContext();
+        // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
+        return *IMutableContext::currentContext;
+    }
+
+    inline IContext& getCurrentContext()
+    {
+        return getCurrentMutableContext();
+    }
+
+    void cleanUpContext();
+
+    class SimplePcg32;
+    SimplePcg32& sharedRng();
+}
+
+#endif // CATCH_CONTEXT_HPP_INCLUDED
+
+
+#ifndef CATCH_INTERFACES_REPORTER_HPP_INCLUDED
+#define CATCH_INTERFACES_REPORTER_HPP_INCLUDED
+
+
+
+#ifndef CATCH_SECTION_INFO_HPP_INCLUDED
+#define CATCH_SECTION_INFO_HPP_INCLUDED
+
+
+
+#ifndef CATCH_MOVE_AND_FORWARD_HPP_INCLUDED
+#define CATCH_MOVE_AND_FORWARD_HPP_INCLUDED
+
+#include <type_traits>
+
+//! Replacement for std::move with better compile time performance
+#define CATCH_MOVE(...) static_cast<std::remove_reference_t<decltype(__VA_ARGS__)>&&>(__VA_ARGS__)
+
+//! Replacement for std::forward with better compile time performance
+#define CATCH_FORWARD(...) static_cast<decltype(__VA_ARGS__)&&>(__VA_ARGS__)
+
+#endif // CATCH_MOVE_AND_FORWARD_HPP_INCLUDED
+
+
+#ifndef CATCH_SOURCE_LINE_INFO_HPP_INCLUDED
+#define CATCH_SOURCE_LINE_INFO_HPP_INCLUDED
+
+#include <cstddef>
+#include <iosfwd>
+
+namespace Catch {
+
+    struct SourceLineInfo {
+
+        SourceLineInfo() = delete;
+        constexpr SourceLineInfo( char const* _file, std::size_t _line ) noexcept:
+            file( _file ),
+            line( _line )
+        {}
+
+        bool operator == ( SourceLineInfo const& other ) const noexcept;
+        bool operator < ( SourceLineInfo const& other ) const noexcept;
+
+        char const* file;
+        std::size_t line;
+
+        friend std::ostream& operator << (std::ostream& os, SourceLineInfo const& info);
+    };
+}
+
+#define CATCH_INTERNAL_LINEINFO \
+    ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )
+
+#endif // CATCH_SOURCE_LINE_INFO_HPP_INCLUDED
+
+
+#ifndef CATCH_TOTALS_HPP_INCLUDED
+#define CATCH_TOTALS_HPP_INCLUDED
+
+#include <cstdint>
+
+namespace Catch {
+
+    struct Counts {
+        Counts operator - ( Counts const& other ) const;
+        Counts& operator += ( Counts const& other );
+
+        std::uint64_t total() const;
+        bool allPassed() const;
+        bool allOk() const;
+
+        std::uint64_t passed = 0;
+        std::uint64_t failed = 0;
+        std::uint64_t failedButOk = 0;
+    };
+
+    struct Totals {
+
+        Totals operator - ( Totals const& other ) const;
+        Totals& operator += ( Totals const& other );
+
+        Totals delta( Totals const& prevTotals ) const;
+
+        Counts assertions;
+        Counts testCases;
+    };
+}
+
+#endif // CATCH_TOTALS_HPP_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    struct SectionInfo {
+        // The last argument is ignored, so that people can write
+        // SECTION("ShortName", "Proper description that is long") and
+        // still use the `-c` flag comfortably.
+        SectionInfo( SourceLineInfo const& _lineInfo, std::string _name,
+                    const char* const = nullptr ):
+            name(CATCH_MOVE(_name)),
+            lineInfo(_lineInfo)
+            {}
+
+        std::string name;
+        SourceLineInfo lineInfo;
+    };
+
+    struct SectionEndInfo {
+        SectionInfo sectionInfo;
+        Counts prevAssertions;
+        double durationInSeconds;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_SECTION_INFO_HPP_INCLUDED
+
+
+#ifndef CATCH_ASSERTION_RESULT_HPP_INCLUDED
+#define CATCH_ASSERTION_RESULT_HPP_INCLUDED
+
+
+
+#ifndef CATCH_ASSERTION_INFO_HPP_INCLUDED
+#define CATCH_ASSERTION_INFO_HPP_INCLUDED
+
+
+
+#ifndef CATCH_RESULT_TYPE_HPP_INCLUDED
+#define CATCH_RESULT_TYPE_HPP_INCLUDED
+
+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
+
+#endif // CATCH_RESULT_TYPE_HPP_INCLUDED
+
+namespace Catch {
+
+    struct AssertionInfo {
+        // AssertionInfo() = delete;
+
+        StringRef macroName;
+        SourceLineInfo lineInfo;
+        StringRef capturedExpression;
+        ResultDisposition::Flags resultDisposition;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_ASSERTION_INFO_HPP_INCLUDED
+
+
+#ifndef CATCH_LAZY_EXPR_HPP_INCLUDED
+#define CATCH_LAZY_EXPR_HPP_INCLUDED
+
+#include <iosfwd>
+
+namespace Catch {
+
+    class ITransientExpression;
+
+    class LazyExpression {
+        friend class AssertionHandler;
+        friend struct AssertionStats;
+        friend class RunContext;
+
+        ITransientExpression const* m_transientExpression = nullptr;
+        bool m_isNegated;
+    public:
+        LazyExpression( bool isNegated ):
+            m_isNegated(isNegated)
+        {}
+        LazyExpression(LazyExpression const& other) = default;
+        LazyExpression& operator = ( LazyExpression const& ) = delete;
+
+        explicit operator bool() const {
+            return m_transientExpression != nullptr;
+        }
+
+        friend auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream&;
+    };
+
+} // namespace Catch
+
+#endif // CATCH_LAZY_EXPR_HPP_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    struct AssertionResultData
+    {
+        AssertionResultData() = delete;
+
+        AssertionResultData( ResultWas::OfType _resultType, LazyExpression const& _lazyExpression );
+
+        std::string message;
+        mutable std::string reconstructedExpression;
+        LazyExpression lazyExpression;
+        ResultWas::OfType resultType;
+
+        std::string reconstructExpression() const;
+    };
+
+    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;
+        StringRef getMessage() const;
+        SourceLineInfo getSourceInfo() const;
+        StringRef getTestMacroName() const;
+
+    //protected:
+        AssertionInfo m_info;
+        AssertionResultData m_resultData;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_ASSERTION_RESULT_HPP_INCLUDED
+
+
+#ifndef CATCH_MESSAGE_INFO_HPP_INCLUDED
+#define CATCH_MESSAGE_INFO_HPP_INCLUDED
+
+
+
+#ifndef CATCH_INTERFACES_CAPTURE_HPP_INCLUDED
+#define CATCH_INTERFACES_CAPTURE_HPP_INCLUDED
+
+#include <string>
+#include <chrono>
+
+
+namespace Catch {
+
+    class AssertionResult;
+    struct AssertionInfo;
+    struct SectionInfo;
+    struct SectionEndInfo;
+    struct MessageInfo;
+    struct MessageBuilder;
+    struct Counts;
+    struct AssertionReaction;
+    struct SourceLineInfo;
+
+    class ITransientExpression;
+    class IGeneratorTracker;
+
+    struct BenchmarkInfo;
+    template <typename Duration = std::chrono::duration<double, std::nano>>
+    struct BenchmarkStats;
+
+    class IResultCapture {
+    public:
+        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( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker& = 0;
+
+        virtual void benchmarkPreparing( StringRef name ) = 0;
+        virtual void benchmarkStarting( BenchmarkInfo const& info ) = 0;
+        virtual void benchmarkEnded( BenchmarkStats<> const& stats ) = 0;
+        virtual void benchmarkFailed( StringRef error ) = 0;
+
+        virtual void pushScopedMessage( MessageInfo const& message ) = 0;
+        virtual void popScopedMessage( MessageInfo const& message ) = 0;
+
+        virtual void emplaceUnscopedMessage( MessageBuilder const& builder ) = 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 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();
+}
+
+#endif // CATCH_INTERFACES_CAPTURE_HPP_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    struct MessageInfo {
+        MessageInfo(    StringRef _macroName,
+                        SourceLineInfo const& _lineInfo,
+                        ResultWas::OfType _type );
+
+        StringRef macroName;
+        std::string message;
+        SourceLineInfo lineInfo;
+        ResultWas::OfType type;
+        unsigned int sequence;
+
+        bool operator == (MessageInfo const& other) const {
+            return sequence == other.sequence;
+        }
+        bool operator < (MessageInfo const& other) const {
+            return sequence < other.sequence;
+        }
+    private:
+        static unsigned int globalCount;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_MESSAGE_INFO_HPP_INCLUDED
+
+
+#ifndef CATCH_UNIQUE_PTR_HPP_INCLUDED
+#define CATCH_UNIQUE_PTR_HPP_INCLUDED
+
+#include <cassert>
+#include <type_traits>
+
+
+namespace Catch {
+namespace Detail {
+    /**
+     * A reimplementation of `std::unique_ptr` for improved compilation performance
+     *
+     * Does not support arrays nor custom deleters.
+     */
+    template <typename T>
+    class unique_ptr {
+        T* m_ptr;
+    public:
+        constexpr unique_ptr(std::nullptr_t = nullptr):
+            m_ptr{}
+        {}
+        explicit constexpr unique_ptr(T* ptr):
+            m_ptr(ptr)
+        {}
+
+        template <typename U, typename = std::enable_if_t<std::is_base_of<T, U>::value>>
+        unique_ptr(unique_ptr<U>&& from):
+            m_ptr(from.release())
+        {}
+
+        template <typename U, typename = std::enable_if_t<std::is_base_of<T, U>::value>>
+        unique_ptr& operator=(unique_ptr<U>&& from) {
+            reset(from.release());
+
+            return *this;
+        }
+
+        unique_ptr(unique_ptr const&) = delete;
+        unique_ptr& operator=(unique_ptr const&) = delete;
+
+        unique_ptr(unique_ptr&& rhs) noexcept:
+            m_ptr(rhs.m_ptr) {
+            rhs.m_ptr = nullptr;
+        }
+        unique_ptr& operator=(unique_ptr&& rhs) noexcept {
+            reset(rhs.release());
+
+            return *this;
+        }
+
+        ~unique_ptr() {
+            delete m_ptr;
+        }
+
+        T& operator*() {
+            assert(m_ptr);
+            return *m_ptr;
+        }
+        T const& operator*() const {
+            assert(m_ptr);
+            return *m_ptr;
+        }
+        T* operator->() noexcept {
+            assert(m_ptr);
+            return m_ptr;
+        }
+        T const* operator->() const noexcept {
+            assert(m_ptr);
+            return m_ptr;
+        }
+
+        T* get() { return m_ptr; }
+        T const* get() const { return m_ptr; }
+
+        void reset(T* ptr = nullptr) {
+            delete m_ptr;
+            m_ptr = ptr;
+        }
+
+        T* release() {
+            auto temp = m_ptr;
+            m_ptr = nullptr;
+            return temp;
+        }
+
+        explicit operator bool() const {
+            return m_ptr;
+        }
+
+        friend void swap(unique_ptr& lhs, unique_ptr& rhs) {
+            auto temp = lhs.m_ptr;
+            lhs.m_ptr = rhs.m_ptr;
+            rhs.m_ptr = temp;
+        }
+    };
+
+    //! Specialization to cause compile-time error for arrays
+    template <typename T>
+    class unique_ptr<T[]>;
+
+    template <typename T, typename... Args>
+    unique_ptr<T> make_unique(Args&&... args) {
+        return unique_ptr<T>(new T(CATCH_FORWARD(args)...));
+    }
+
+
+} // end namespace Detail
+} // end namespace Catch
+
+#endif // CATCH_UNIQUE_PTR_HPP_INCLUDED
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_ESTIMATE_HPP_INCLUDED
+#define CATCH_ESTIMATE_HPP_INCLUDED
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration>
+        struct Estimate {
+            Duration point;
+            Duration lower_bound;
+            Duration upper_bound;
+            double confidence_interval;
+
+            template <typename Duration2>
+            operator Estimate<Duration2>() const {
+                return { point, lower_bound, upper_bound, confidence_interval };
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_ESTIMATE_HPP_INCLUDED
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_OUTLIER_CLASSIFICATION_HPP_INCLUDED
+#define CATCH_OUTLIER_CLASSIFICATION_HPP_INCLUDED
+
+namespace Catch {
+    namespace Benchmark {
+        struct OutlierClassification {
+            int samples_seen = 0;
+            int low_severe = 0;     // more than 3 times IQR below Q1
+            int low_mild = 0;       // 1.5 to 3 times IQR below Q1
+            int high_mild = 0;      // 1.5 to 3 times IQR above Q3
+            int high_severe = 0;    // more than 3 times IQR above Q3
+
+            int total() const {
+                return low_severe + low_mild + high_mild + high_severe;
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_OUTLIERS_CLASSIFICATION_HPP_INCLUDED
+
+
+#include <map>
+#include <string>
+#include <vector>
+#include <iosfwd>
+
+namespace Catch {
+
+    struct ReporterDescription;
+    struct ListenerDescription;
+    struct TagInfo;
+    struct TestCaseInfo;
+    class TestCaseHandle;
+    class IConfig;
+    class IStream;
+    enum class ColourMode : std::uint8_t;
+
+    struct ReporterConfig {
+        ReporterConfig( IConfig const* _fullConfig,
+                        Detail::unique_ptr<IStream> _stream,
+                        ColourMode colourMode,
+                        std::map<std::string, std::string> customOptions );
+
+        ReporterConfig( ReporterConfig&& ) = default;
+        ReporterConfig& operator=( ReporterConfig&& ) = default;
+        ~ReporterConfig(); // = default
+
+        Detail::unique_ptr<IStream> takeStream() &&;
+        IConfig const* fullConfig() const;
+        ColourMode colourMode() const;
+        std::map<std::string, std::string> const& customOptions() const;
+
+    private:
+        Detail::unique_ptr<IStream> m_stream;
+        IConfig const* m_fullConfig;
+        ColourMode m_colourMode;
+        std::map<std::string, std::string> m_customOptions;
+    };
+
+    struct TestRunInfo {
+        constexpr TestRunInfo(StringRef _name) : name(_name) {}
+        StringRef name;
+    };
+
+    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& ) = delete;
+        AssertionStats& operator = ( AssertionStats && )     = delete;
+
+        AssertionResult assertionResult;
+        std::vector<MessageInfo> infoMessages;
+        Totals totals;
+    };
+
+    struct SectionStats {
+        SectionStats(   SectionInfo const& _sectionInfo,
+                        Counts const& _assertions,
+                        double _durationInSeconds,
+                        bool _missingAssertions );
+
+        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 );
+
+        TestCaseInfo const * testInfo;
+        Totals totals;
+        std::string stdOut;
+        std::string stdErr;
+        bool aborting;
+    };
+
+    struct TestRunStats {
+        TestRunStats(   TestRunInfo const& _runInfo,
+                        Totals const& _totals,
+                        bool _aborting );
+
+        TestRunInfo runInfo;
+        Totals totals;
+        bool aborting;
+    };
+
+
+    struct BenchmarkInfo {
+        std::string name;
+        double estimatedDuration;
+        int iterations;
+        unsigned int samples;
+        unsigned int resamples;
+        double clockResolution;
+        double clockCost;
+    };
+
+    template <class Duration>
+    struct BenchmarkStats {
+        BenchmarkInfo info;
+
+        std::vector<Duration> samples;
+        Benchmark::Estimate<Duration> mean;
+        Benchmark::Estimate<Duration> standardDeviation;
+        Benchmark::OutlierClassification outliers;
+        double outlierVariance;
+
+        template <typename Duration2>
+        operator BenchmarkStats<Duration2>() const {
+            std::vector<Duration2> samples2;
+            samples2.reserve(samples.size());
+            for (auto const& sample : samples) {
+                samples2.push_back(Duration2(sample));
+            }
+            return {
+                info,
+                CATCH_MOVE(samples2),
+                mean,
+                standardDeviation,
+                outliers,
+                outlierVariance,
+            };
+        }
+    };
+
+    //! By setting up its preferences, a reporter can modify Catch2's behaviour
+    //! in some regards, e.g. it can request Catch2 to capture writes to
+    //! stdout/stderr during test execution, and pass them to the reporter.
+    struct ReporterPreferences {
+        //! Catch2 should redirect writes to stdout and pass them to the
+        //! reporter
+        bool shouldRedirectStdOut = false;
+        //! Catch2 should call `Reporter::assertionEnded` even for passing
+        //! assertions
+        bool shouldReportAllAssertions = false;
+    };
+
+    /**
+     * The common base for all reporters and event listeners
+     *
+     * Implementing classes must also implement:
+     *
+     *     //! User-friendly description of the reporter/listener type
+     *     static std::string getDescription()
+     *
+     * Generally shouldn't be derived from by users of Catch2 directly,
+     * instead they should derive from one of the utility bases that
+     * derive from this class.
+     */
+    class IEventListener {
+    protected:
+        //! Derived classes can set up their preferences here
+        ReporterPreferences m_preferences;
+        //! The test run's config as filled in from CLI and defaults
+        IConfig const* m_config;
+
+    public:
+        IEventListener( IConfig const* config ): m_config( config ) {}
+
+        virtual ~IEventListener(); // = default;
+
+        // Implementing class must also provide the following static methods:
+        // static std::string getDescription();
+
+        ReporterPreferences const& getPreferences() const {
+            return m_preferences;
+        }
+
+        //! Called when no test cases match provided test spec
+        virtual void noMatchingTestCases( StringRef unmatchedSpec ) = 0;
+        //! Called for all invalid test specs from the cli
+        virtual void reportInvalidTestSpec( StringRef invalidArgument ) = 0;
+
+        /**
+         * Called once in a testing run before tests are started
+         *
+         * Not called if tests won't be run (e.g. only listing will happen)
+         */
+        virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
+
+        //! Called _once_ for each TEST_CASE, no matter how many times it is entered
+        virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
+        //! Called _every time_ a TEST_CASE is entered, including repeats (due to sections)
+        virtual void testCasePartialStarting( TestCaseInfo const& testInfo, uint64_t partNumber ) = 0;
+        //! Called when a `SECTION` is being entered. Not called for skipped sections
+        virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;
+
+        //! Called when user-code is being probed before the actual benchmark runs
+        virtual void benchmarkPreparing( StringRef benchmarkName ) = 0;
+        //! Called after probe but before the user-code is being benchmarked
+        virtual void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) = 0;
+        //! Called with the benchmark results if benchmark successfully finishes
+        virtual void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) = 0;
+        //! Called if running the benchmarks fails for any reason
+        virtual void benchmarkFailed( StringRef benchmarkName ) = 0;
+
+        //! Called before assertion success/failure is evaluated
+        virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
+
+        //! Called after assertion was fully evaluated
+        virtual void assertionEnded( AssertionStats const& assertionStats ) = 0;
+
+        //! Called after a `SECTION` has finished running
+        virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
+        //! Called _every time_ a TEST_CASE is entered, including repeats (due to sections)
+        virtual void testCasePartialEnded(TestCaseStats const& testCaseStats, uint64_t partNumber ) = 0;
+        //! Called _once_ for each TEST_CASE, no matter how many times it is entered
+        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
+        /**
+         * Called once after all tests in a testing run are finished
+         *
+         * Not called if tests weren't run (e.g. only listings happened)
+         */
+        virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
+
+        //! Called with test cases that are skipped due to the test run aborting
+        virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
+
+        //! Called if a fatal error (signal/structured exception) occured
+        virtual void fatalErrorEncountered( StringRef error ) = 0;
+
+        //! Writes out information about provided reporters using reporter-specific format
+        virtual void listReporters(std::vector<ReporterDescription> const& descriptions) = 0;
+        //! Writes out the provided listeners descriptions using reporter-specific format
+        virtual void listListeners(std::vector<ListenerDescription> const& descriptions) = 0;
+        //! Writes out information about provided tests using reporter-specific format
+        virtual void listTests(std::vector<TestCaseHandle> const& tests) = 0;
+        //! Writes out information about the provided tags using reporter-specific format
+        virtual void listTags(std::vector<TagInfo> const& tags) = 0;
+    };
+    using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
+
+} // end namespace Catch
+
+#endif // CATCH_INTERFACES_REPORTER_HPP_INCLUDED
+
+
+#ifndef CATCH_UNIQUE_NAME_HPP_INCLUDED
+#define CATCH_UNIQUE_NAME_HPP_INCLUDED
+
+
+
+
+/** \file
+ * Wrapper for the CONFIG configuration option
+ *
+ * When generating internal unique names, there are two options. Either
+ * we mix in the current line number, or mix in an incrementing number.
+ * We prefer the latter, using `__COUNTER__`, but users might want to
+ * use the former.
+ */
+
+#ifndef CATCH_CONFIG_COUNTER_HPP_INCLUDED
+#define CATCH_CONFIG_COUNTER_HPP_INCLUDED
+
+#if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L )
+    #define CATCH_INTERNAL_CONFIG_COUNTER
+#endif
+
+#if defined( CATCH_INTERNAL_CONFIG_COUNTER ) && \
+    !defined( CATCH_CONFIG_NO_COUNTER ) && \
+    !defined( CATCH_CONFIG_COUNTER )
+#    define CATCH_CONFIG_COUNTER
+#endif
+
+
+#endif // CATCH_CONFIG_COUNTER_HPP_INCLUDED
+#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line
+#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )
+#ifdef CATCH_CONFIG_COUNTER
+#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ )
+#else
+#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )
+#endif
+
+#endif // CATCH_UNIQUE_NAME_HPP_INCLUDED
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_CHRONOMETER_HPP_INCLUDED
+#define CATCH_CHRONOMETER_HPP_INCLUDED
+
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_CLOCK_HPP_INCLUDED
+#define CATCH_CLOCK_HPP_INCLUDED
+
+#include <chrono>
+#include <ratio>
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Clock>
+        using ClockDuration = typename Clock::duration;
+        template <typename Clock>
+        using FloatDuration = std::chrono::duration<double, typename Clock::period>;
+
+        template <typename Clock>
+        using TimePoint = typename Clock::time_point;
+
+        using default_clock = std::chrono::steady_clock;
+
+        template <typename Clock>
+        struct now {
+            TimePoint<Clock> operator()() const {
+                return Clock::now();
+            }
+        };
+
+        using fp_seconds = std::chrono::duration<double, std::ratio<1>>;
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_CLOCK_HPP_INCLUDED
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_OPTIMIZER_HPP_INCLUDED
+#define CATCH_OPTIMIZER_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+#   include <atomic> // atomic_thread_fence
+#endif
+
+
+#include <type_traits>
+
+namespace Catch {
+    namespace Benchmark {
+#if defined(__GNUC__) || defined(__clang__)
+        template <typename T>
+        inline void keep_memory(T* p) {
+            asm volatile("" : : "g"(p) : "memory");
+        }
+        inline void keep_memory() {
+            asm volatile("" : : : "memory");
+        }
+
+        namespace Detail {
+            inline void optimizer_barrier() { keep_memory(); }
+        } // namespace Detail
+#elif defined(_MSC_VER)
+
+#pragma optimize("", off)
+        template <typename T>
+        inline void keep_memory(T* p) {
+            // thanks @milleniumbug
+            *reinterpret_cast<char volatile*>(p) = *reinterpret_cast<char const volatile*>(p);
+        }
+        // TODO equivalent keep_memory()
+#pragma optimize("", on)
+
+        namespace Detail {
+            inline void optimizer_barrier() {
+                std::atomic_thread_fence(std::memory_order_seq_cst);
+            }
+        } // namespace Detail
+
+#endif
+
+        template <typename T>
+        inline void deoptimize_value(T&& x) {
+            keep_memory(&x);
+        }
+
+        template <typename Fn, typename... Args>
+        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> std::enable_if_t<!std::is_same<void, decltype(fn(args...))>::value> {
+            deoptimize_value(CATCH_FORWARD(fn) (CATCH_FORWARD(args)...));
+        }
+
+        template <typename Fn, typename... Args>
+        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> std::enable_if_t<std::is_same<void, decltype(fn(args...))>::value> {
+            CATCH_FORWARD(fn) (CATCH_FORWARD(args)...);
+        }
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_OPTIMIZER_HPP_INCLUDED
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_COMPLETE_INVOKE_HPP_INCLUDED
+#define CATCH_COMPLETE_INVOKE_HPP_INCLUDED
+
+
+
+#ifndef CATCH_TEST_FAILURE_EXCEPTION_HPP_INCLUDED
+#define CATCH_TEST_FAILURE_EXCEPTION_HPP_INCLUDED
+
+namespace Catch {
+
+    //! Used to signal that an assertion macro failed
+    struct TestFailureException{};
+
+} // namespace Catch
+
+#endif // CATCH_TEST_FAILURE_EXCEPTION_HPP_INCLUDED
+
+
+#ifndef CATCH_META_HPP_INCLUDED
+#define CATCH_META_HPP_INCLUDED
+
+#include <type_traits>
+
+namespace Catch {
+    template<typename T>
+    struct always_false : std::false_type {};
+
+    template <typename> struct true_given : std::true_type {};
+    struct is_callable_tester {
+        template <typename Fun, typename... Args>
+        static true_given<decltype(std::declval<Fun>()(std::declval<Args>()...))> test(int);
+        template <typename...>
+        static std::false_type test(...);
+    };
+
+    template <typename T>
+    struct is_callable;
+
+    template <typename Fun, typename... Args>
+    struct is_callable<Fun(Args...)> : decltype(is_callable_tester::test<Fun, Args...>(0)) {};
+
+
+#if defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703
+    // std::result_of is deprecated in C++17 and removed in C++20. Hence, it is
+    // replaced with std::invoke_result here.
+    template <typename Func, typename... U>
+    using FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::invoke_result_t<Func, U...>>>;
+#else
+    template <typename Func, typename... U>
+    using FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::result_of_t<Func(U...)>>>;
+#endif
+
+} // namespace Catch
+
+namespace mpl_{
+    struct na;
+}
+
+#endif // CATCH_META_HPP_INCLUDED
+
+
+#ifndef CATCH_INTERFACES_REGISTRY_HUB_HPP_INCLUDED
+#define CATCH_INTERFACES_REGISTRY_HUB_HPP_INCLUDED
+
+
+#include <string>
+
+namespace Catch {
+
+    class TestCaseHandle;
+    struct TestCaseInfo;
+    class ITestCaseRegistry;
+    class IExceptionTranslatorRegistry;
+    class IExceptionTranslator;
+    class IReporterRegistry;
+    class IReporterFactory;
+    class ITagAliasRegistry;
+    class ITestInvoker;
+    class IMutableEnumValuesRegistry;
+    struct SourceLineInfo;
+
+    class StartupExceptionRegistry;
+    class EventListenerFactory;
+
+    using IReporterFactoryPtr = Detail::unique_ptr<IReporterFactory>;
+
+    class IRegistryHub {
+    public:
+        virtual ~IRegistryHub(); // = default
+
+        virtual IReporterRegistry const& getReporterRegistry() const = 0;
+        virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
+        virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0;
+        virtual IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const = 0;
+
+
+        virtual StartupExceptionRegistry const& getStartupExceptionRegistry() const = 0;
+    };
+
+    class IMutableRegistryHub {
+    public:
+        virtual ~IMutableRegistryHub(); // = default
+        virtual void registerReporter( std::string const& name, IReporterFactoryPtr factory ) = 0;
+        virtual void registerListener( Detail::unique_ptr<EventListenerFactory> factory ) = 0;
+        virtual void registerTest(Detail::unique_ptr<TestCaseInfo>&& testInfo, Detail::unique_ptr<ITestInvoker>&& invoker) = 0;
+        virtual void registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator ) = 0;
+        virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) = 0;
+        virtual void registerStartupException() noexcept = 0;
+        virtual IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() = 0;
+    };
+
+    IRegistryHub const& getRegistryHub();
+    IMutableRegistryHub& getMutableRegistryHub();
+    void cleanUp();
+    std::string translateActiveException();
+
+}
+
+#endif // CATCH_INTERFACES_REGISTRY_HUB_HPP_INCLUDED
+
+#include <type_traits>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename T>
+            struct CompleteType { using type = T; };
+            template <>
+            struct CompleteType<void> { struct type {}; };
+
+            template <typename T>
+            using CompleteType_t = typename CompleteType<T>::type;
+
+            template <typename Result>
+            struct CompleteInvoker {
+                template <typename Fun, typename... Args>
+                static Result invoke(Fun&& fun, Args&&... args) {
+                    return CATCH_FORWARD(fun)(CATCH_FORWARD(args)...);
+                }
+            };
+            template <>
+            struct CompleteInvoker<void> {
+                template <typename Fun, typename... Args>
+                static CompleteType_t<void> invoke(Fun&& fun, Args&&... args) {
+                    CATCH_FORWARD(fun)(CATCH_FORWARD(args)...);
+                    return {};
+                }
+            };
+
+            // invoke and not return void :(
+            template <typename Fun, typename... Args>
+            CompleteType_t<FunctionReturnType<Fun, Args...>> complete_invoke(Fun&& fun, Args&&... args) {
+                return CompleteInvoker<FunctionReturnType<Fun, Args...>>::invoke(CATCH_FORWARD(fun), CATCH_FORWARD(args)...);
+            }
+
+        } // namespace Detail
+
+        template <typename Fun>
+        Detail::CompleteType_t<FunctionReturnType<Fun>> user_code(Fun&& fun) {
+            return Detail::complete_invoke(CATCH_FORWARD(fun));
+        }
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_COMPLETE_INVOKE_HPP_INCLUDED
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            struct ChronometerConcept {
+                virtual void start() = 0;
+                virtual void finish() = 0;
+                virtual ~ChronometerConcept(); // = default;
+
+                ChronometerConcept() = default;
+                ChronometerConcept(ChronometerConcept const&) = default;
+                ChronometerConcept& operator=(ChronometerConcept const&) = default;
+            };
+            template <typename Clock>
+            struct ChronometerModel final : public ChronometerConcept {
+                void start() override { started = Clock::now(); }
+                void finish() override { finished = Clock::now(); }
+
+                ClockDuration<Clock> elapsed() const { return finished - started; }
+
+                TimePoint<Clock> started;
+                TimePoint<Clock> finished;
+            };
+        } // namespace Detail
+
+        struct Chronometer {
+        public:
+            template <typename Fun>
+            void measure(Fun&& fun) { measure(CATCH_FORWARD(fun), is_callable<Fun(int)>()); }
+
+            int runs() const { return repeats; }
+
+            Chronometer(Detail::ChronometerConcept& meter, int repeats_)
+                : impl(&meter)
+                , repeats(repeats_) {}
+
+        private:
+            template <typename Fun>
+            void measure(Fun&& fun, std::false_type) {
+                measure([&fun](int) { return fun(); }, std::true_type());
+            }
+
+            template <typename Fun>
+            void measure(Fun&& fun, std::true_type) {
+                Detail::optimizer_barrier();
+                impl->start();
+                for (int i = 0; i < repeats; ++i) invoke_deoptimized(fun, i);
+                impl->finish();
+                Detail::optimizer_barrier();
+            }
+
+            Detail::ChronometerConcept* impl;
+            int repeats;
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_CHRONOMETER_HPP_INCLUDED
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_ENVIRONMENT_HPP_INCLUDED
+#define CATCH_ENVIRONMENT_HPP_INCLUDED
+
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration>
+        struct EnvironmentEstimate {
+            Duration mean;
+            OutlierClassification outliers;
+
+            template <typename Duration2>
+            operator EnvironmentEstimate<Duration2>() const {
+                return { mean, outliers };
+            }
+        };
+        template <typename Clock>
+        struct Environment {
+            using clock_type = Clock;
+            EnvironmentEstimate<FloatDuration<Clock>> clock_resolution;
+            EnvironmentEstimate<FloatDuration<Clock>> clock_cost;
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_ENVIRONMENT_HPP_INCLUDED
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_EXECUTION_PLAN_HPP_INCLUDED
+#define CATCH_EXECUTION_PLAN_HPP_INCLUDED
+
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED
+#define CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED
+
+
+#include <type_traits>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename T, typename U>
+            struct is_related
+                : std::is_same<std::decay_t<T>, std::decay_t<U>> {};
+
+            /// We need to reinvent std::function because every piece of code that might add overhead
+            /// in a measurement context needs to have consistent performance characteristics so that we
+            /// can account for it in the measurement.
+            /// Implementations of std::function with optimizations that aren't always applicable, like
+            /// small buffer optimizations, are not uncommon.
+            /// This is effectively an implementation of std::function without any such optimizations;
+            /// it may be slow, but it is consistently slow.
+            struct BenchmarkFunction {
+            private:
+                struct callable {
+                    virtual void call(Chronometer meter) const = 0;
+                    virtual Catch::Detail::unique_ptr<callable> clone() const = 0;
+                    virtual ~callable(); // = default;
+
+                    callable() = default;
+                    callable(callable const&) = default;
+                    callable& operator=(callable const&) = default;
+                };
+                template <typename Fun>
+                struct model : public callable {
+                    model(Fun&& fun_) : fun(CATCH_MOVE(fun_)) {}
+                    model(Fun const& fun_) : fun(fun_) {}
+
+                    Catch::Detail::unique_ptr<callable> clone() const override {
+                        return Catch::Detail::make_unique<model<Fun>>( *this );
+                    }
+
+                    void call(Chronometer meter) const override {
+                        call(meter, is_callable<Fun(Chronometer)>());
+                    }
+                    void call(Chronometer meter, std::true_type) const {
+                        fun(meter);
+                    }
+                    void call(Chronometer meter, std::false_type) const {
+                        meter.measure(fun);
+                    }
+
+                    Fun fun;
+                };
+
+                struct do_nothing { void operator()() const {} };
+
+                template <typename T>
+                BenchmarkFunction(model<T>* c) : f(c) {}
+
+            public:
+                BenchmarkFunction()
+                    : f(new model<do_nothing>{ {} }) {}
+
+                template <typename Fun,
+                    std::enable_if_t<!is_related<Fun, BenchmarkFunction>::value, int> = 0>
+                    BenchmarkFunction(Fun&& fun)
+                    : f(new model<std::decay_t<Fun>>(CATCH_FORWARD(fun))) {}
+
+                BenchmarkFunction( BenchmarkFunction&& that ) noexcept:
+                    f( CATCH_MOVE( that.f ) ) {}
+
+                BenchmarkFunction(BenchmarkFunction const& that)
+                    : f(that.f->clone()) {}
+
+                BenchmarkFunction&
+                operator=( BenchmarkFunction&& that ) noexcept {
+                    f = CATCH_MOVE( that.f );
+                    return *this;
+                }
+
+                BenchmarkFunction& operator=(BenchmarkFunction const& that) {
+                    f = that.f->clone();
+                    return *this;
+                }
+
+                void operator()(Chronometer meter) const { f->call(meter); }
+
+            private:
+                Catch::Detail::unique_ptr<callable> f;
+            };
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_REPEAT_HPP_INCLUDED
+#define CATCH_REPEAT_HPP_INCLUDED
+
+#include <type_traits>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Fun>
+            struct repeater {
+                void operator()(int k) const {
+                    for (int i = 0; i < k; ++i) {
+                        fun();
+                    }
+                }
+                Fun fun;
+            };
+            template <typename Fun>
+            repeater<std::decay_t<Fun>> repeat(Fun&& fun) {
+                return { CATCH_FORWARD(fun) };
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_REPEAT_HPP_INCLUDED
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED
+#define CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED
+
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_MEASURE_HPP_INCLUDED
+#define CATCH_MEASURE_HPP_INCLUDED
+
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_TIMING_HPP_INCLUDED
+#define CATCH_TIMING_HPP_INCLUDED
+
+
+#include <type_traits>
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration, typename Result>
+        struct Timing {
+            Duration elapsed;
+            Result result;
+            int iterations;
+        };
+        template <typename Clock, typename Func, typename... Args>
+        using TimingOf = Timing<ClockDuration<Clock>, Detail::CompleteType_t<FunctionReturnType<Func, Args...>>>;
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_TIMING_HPP_INCLUDED
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Clock, typename Fun, typename... Args>
+            TimingOf<Clock, Fun, Args...> measure(Fun&& fun, Args&&... args) {
+                auto start = Clock::now();
+                auto&& r = Detail::complete_invoke(fun, CATCH_FORWARD(args)...);
+                auto end = Clock::now();
+                auto delta = end - start;
+                return { delta, CATCH_FORWARD(r), 1 };
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_MEASURE_HPP_INCLUDED
+
+#include <type_traits>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Clock, typename Fun>
+            TimingOf<Clock, Fun, int> measure_one(Fun&& fun, int iters, std::false_type) {
+                return Detail::measure<Clock>(fun, iters);
+            }
+            template <typename Clock, typename Fun>
+            TimingOf<Clock, Fun, Chronometer> measure_one(Fun&& fun, int iters, std::true_type) {
+                Detail::ChronometerModel<Clock> meter;
+                auto&& result = Detail::complete_invoke(fun, Chronometer(meter, iters));
+
+                return { meter.elapsed(), CATCH_MOVE(result), iters };
+            }
+
+            template <typename Clock, typename Fun>
+            using run_for_at_least_argument_t = std::conditional_t<is_callable<Fun(Chronometer)>::value, Chronometer, int>;
+
+
+            [[noreturn]]
+            void throw_optimized_away_error();
+
+            template <typename Clock, typename Fun>
+            TimingOf<Clock, Fun, run_for_at_least_argument_t<Clock, Fun>>
+                run_for_at_least(ClockDuration<Clock> how_long,
+                                 const int initial_iterations,
+                                 Fun&& fun) {
+                auto iters = initial_iterations;
+                while (iters < (1 << 30)) {
+                    auto&& Timing = measure_one<Clock>(fun, iters, is_callable<Fun(Chronometer)>());
+
+                    if (Timing.elapsed >= how_long) {
+                        return { Timing.elapsed, CATCH_MOVE(Timing.result), iters };
+                    }
+                    iters *= 2;
+                }
+                throw_optimized_away_error();
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED
+
+#include <algorithm>
+#include <iterator>
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration>
+        struct ExecutionPlan {
+            int iterations_per_sample;
+            Duration estimated_duration;
+            Detail::BenchmarkFunction benchmark;
+            Duration warmup_time;
+            int warmup_iterations;
+
+            template <typename Duration2>
+            operator ExecutionPlan<Duration2>() const {
+                return { iterations_per_sample, estimated_duration, benchmark, warmup_time, warmup_iterations };
+            }
+
+            template <typename Clock>
+            std::vector<FloatDuration<Clock>> run(const IConfig &cfg, Environment<FloatDuration<Clock>> env) const {
+                // warmup a bit
+                Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_iterations, Detail::repeat(now<Clock>{}));
+
+                std::vector<FloatDuration<Clock>> times;
+                times.reserve(cfg.benchmarkSamples());
+                std::generate_n(std::back_inserter(times), cfg.benchmarkSamples(), [this, env] {
+                    Detail::ChronometerModel<Clock> model;
+                    this->benchmark(Chronometer(model, iterations_per_sample));
+                    auto sample_time = model.elapsed() - env.clock_cost.mean;
+                    if (sample_time < FloatDuration<Clock>::zero()) sample_time = FloatDuration<Clock>::zero();
+                    return sample_time / iterations_per_sample;
+                });
+                return times;
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_EXECUTION_PLAN_HPP_INCLUDED
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_ESTIMATE_CLOCK_HPP_INCLUDED
+#define CATCH_ESTIMATE_CLOCK_HPP_INCLUDED
+
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_STATS_HPP_INCLUDED
+#define CATCH_STATS_HPP_INCLUDED
+
+
+#include <algorithm>
+#include <vector>
+#include <numeric>
+#include <tuple>
+#include <cmath>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            using sample = std::vector<double>;
+
+            // Used when we know we want == comparison of two doubles
+            // to centralize warning suppression
+            bool directCompare( double lhs, double rhs );
+
+            double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last);
+
+            template <typename Iterator>
+            OutlierClassification classify_outliers(Iterator first, Iterator last) {
+                std::vector<double> copy(first, last);
+
+                auto q1 = weighted_average_quantile(1, 4, copy.begin(), copy.end());
+                auto q3 = weighted_average_quantile(3, 4, copy.begin(), copy.end());
+                auto iqr = q3 - q1;
+                auto los = q1 - (iqr * 3.);
+                auto lom = q1 - (iqr * 1.5);
+                auto him = q3 + (iqr * 1.5);
+                auto his = q3 + (iqr * 3.);
+
+                OutlierClassification o;
+                for (; first != last; ++first) {
+                    auto&& t = *first;
+                    if (t < los) ++o.low_severe;
+                    else if (t < lom) ++o.low_mild;
+                    else if (t > his) ++o.high_severe;
+                    else if (t > him) ++o.high_mild;
+                    ++o.samples_seen;
+                }
+                return o;
+            }
+
+            template <typename Iterator>
+            double mean(Iterator first, Iterator last) {
+                auto count = last - first;
+                double sum = std::accumulate(first, last, 0.);
+                return sum / static_cast<double>(count);
+            }
+
+            template <typename Estimator, typename Iterator>
+            sample jackknife(Estimator&& estimator, Iterator first, Iterator last) {
+                auto n = static_cast<size_t>(last - first);
+                auto second = first;
+                ++second;
+                sample results;
+                results.reserve(n);
+
+                for (auto it = first; it != last; ++it) {
+                    std::iter_swap(it, first);
+                    results.push_back(estimator(second, last));
+                }
+
+                return results;
+            }
+
+            inline double normal_cdf(double x) {
+                return std::erfc(-x / std::sqrt(2.0)) / 2.0;
+            }
+
+            double erfc_inv(double x);
+
+            double normal_quantile(double p);
+
+            template <typename Iterator, typename Estimator>
+            Estimate<double> bootstrap(double confidence_level, Iterator first, Iterator last, sample const& resample, Estimator&& estimator) {
+                auto n_samples = last - first;
+
+                double point = estimator(first, last);
+                // Degenerate case with a single sample
+                if (n_samples == 1) return { point, point, point, confidence_level };
+
+                sample jack = jackknife(estimator, first, last);
+                double jack_mean = mean(jack.begin(), jack.end());
+                double sum_squares, sum_cubes;
+                std::tie(sum_squares, sum_cubes) = std::accumulate(jack.begin(), jack.end(), std::make_pair(0., 0.), [jack_mean](std::pair<double, double> sqcb, double x) -> std::pair<double, double> {
+                    auto d = jack_mean - x;
+                    auto d2 = d * d;
+                    auto d3 = d2 * d;
+                    return { sqcb.first + d2, sqcb.second + d3 };
+                });
+
+                double accel = sum_cubes / (6 * std::pow(sum_squares, 1.5));
+                long n = static_cast<long>(resample.size());
+                double prob_n = std::count_if(resample.begin(), resample.end(), [point](double x) { return x < point; }) / static_cast<double>(n);
+                // degenerate case with uniform samples
+                if ( directCompare( prob_n, 0. ) ) {
+                    return { point, point, point, confidence_level };
+                }
+
+                double bias = normal_quantile(prob_n);
+                double z1 = normal_quantile((1. - confidence_level) / 2.);
+
+                auto cumn = [n]( double x ) -> long {
+                    return std::lround( normal_cdf( x ) * static_cast<double>(n) );
+                };
+                auto a = [bias, accel](double b) { return bias + b / (1. - accel * b); };
+                double b1 = bias + z1;
+                double b2 = bias - z1;
+                double a1 = a(b1);
+                double a2 = a(b2);
+                auto lo = static_cast<size_t>((std::max)(cumn(a1), 0l));
+                auto hi = static_cast<size_t>((std::min)(cumn(a2), n - 1));
+
+                return { point, resample[lo], resample[hi], confidence_level };
+            }
+
+            double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n);
+
+            struct bootstrap_analysis {
+                Estimate<double> mean;
+                Estimate<double> standard_deviation;
+                double outlier_variance;
+            };
+
+            bootstrap_analysis analyse_samples(double confidence_level, unsigned int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last);
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_STATS_HPP_INCLUDED
+
+#include <algorithm>
+#include <iterator>
+#include <vector>
+#include <cmath>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Clock>
+            std::vector<double> resolution(int k) {
+                std::vector<TimePoint<Clock>> times;
+                times.reserve(static_cast<size_t>(k + 1));
+                std::generate_n(std::back_inserter(times), k + 1, now<Clock>{});
+
+                std::vector<double> deltas;
+                deltas.reserve(static_cast<size_t>(k));
+                std::transform(std::next(times.begin()), times.end(), times.begin(),
+                    std::back_inserter(deltas),
+                    [](TimePoint<Clock> a, TimePoint<Clock> b) { return static_cast<double>((a - b).count()); });
+
+                return deltas;
+            }
+
+            const auto warmup_iterations = 10000;
+            const auto warmup_time = std::chrono::milliseconds(100);
+            const auto minimum_ticks = 1000;
+            const auto warmup_seed = 10000;
+            const auto clock_resolution_estimation_time = std::chrono::milliseconds(500);
+            const auto clock_cost_estimation_time_limit = std::chrono::seconds(1);
+            const auto clock_cost_estimation_tick_limit = 100000;
+            const auto clock_cost_estimation_time = std::chrono::milliseconds(10);
+            const auto clock_cost_estimation_iterations = 10000;
+
+            template <typename Clock>
+            int warmup() {
+                return run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_seed, &resolution<Clock>)
+                    .iterations;
+            }
+            template <typename Clock>
+            EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_resolution(int iterations) {
+                auto r = run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(clock_resolution_estimation_time), iterations, &resolution<Clock>)
+                    .result;
+                return {
+                    FloatDuration<Clock>(mean(r.begin(), r.end())),
+                    classify_outliers(r.begin(), r.end()),
+                };
+            }
+            template <typename Clock>
+            EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_cost(FloatDuration<Clock> resolution) {
+                auto time_limit = (std::min)(
+                    resolution * clock_cost_estimation_tick_limit,
+                    FloatDuration<Clock>(clock_cost_estimation_time_limit));
+                auto time_clock = [](int k) {
+                    return Detail::measure<Clock>([k] {
+                        for (int i = 0; i < k; ++i) {
+                            volatile auto ignored = Clock::now();
+                            (void)ignored;
+                        }
+                    }).elapsed;
+                };
+                time_clock(1);
+                int iters = clock_cost_estimation_iterations;
+                auto&& r = run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(clock_cost_estimation_time), iters, time_clock);
+                std::vector<double> times;
+                int nsamples = static_cast<int>(std::ceil(time_limit / r.elapsed));
+                times.reserve(static_cast<size_t>(nsamples));
+                std::generate_n(std::back_inserter(times), nsamples, [time_clock, &r] {
+                    return static_cast<double>((time_clock(r.iterations) / r.iterations).count());
+                });
+                return {
+                    FloatDuration<Clock>(mean(times.begin(), times.end())),
+                    classify_outliers(times.begin(), times.end()),
+                };
+            }
+
+            template <typename Clock>
+            Environment<FloatDuration<Clock>> measure_environment() {
+#if defined(__clang__)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wexit-time-destructors"
+#endif
+                static Catch::Detail::unique_ptr<Environment<FloatDuration<Clock>>> env;
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#endif
+                if (env) {
+                    return *env;
+                }
+
+                auto iters = Detail::warmup<Clock>();
+                auto resolution = Detail::estimate_clock_resolution<Clock>(iters);
+                auto cost = Detail::estimate_clock_cost<Clock>(resolution.mean);
+
+                env = Catch::Detail::make_unique<Environment<FloatDuration<Clock>>>( Environment<FloatDuration<Clock>>{resolution, cost} );
+                return *env;
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_ESTIMATE_CLOCK_HPP_INCLUDED
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_ANALYSE_HPP_INCLUDED
+#define CATCH_ANALYSE_HPP_INCLUDED
+
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED
+#define CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED
+
+
+#include <algorithm>
+#include <vector>
+#include <iterator>
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration>
+        struct SampleAnalysis {
+            std::vector<Duration> samples;
+            Estimate<Duration> mean;
+            Estimate<Duration> standard_deviation;
+            OutlierClassification outliers;
+            double outlier_variance;
+
+            template <typename Duration2>
+            operator SampleAnalysis<Duration2>() const {
+                std::vector<Duration2> samples2;
+                samples2.reserve(samples.size());
+                std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](Duration d) { return Duration2(d); });
+                return {
+                    CATCH_MOVE(samples2),
+                    mean,
+                    standard_deviation,
+                    outliers,
+                    outlier_variance,
+                };
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED
+
+#include <algorithm>
+#include <iterator>
+#include <vector>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Duration, typename Iterator>
+            SampleAnalysis<Duration> analyse(const IConfig &cfg, Environment<Duration>, Iterator first, Iterator last) {
+                if (!cfg.benchmarkNoAnalysis()) {
+                    std::vector<double> samples;
+                    samples.reserve(static_cast<size_t>(last - first));
+                    std::transform(first, last, std::back_inserter(samples), [](Duration d) { return d.count(); });
+
+                    auto analysis = Catch::Benchmark::Detail::analyse_samples(cfg.benchmarkConfidenceInterval(), cfg.benchmarkResamples(), samples.begin(), samples.end());
+                    auto outliers = Catch::Benchmark::Detail::classify_outliers(samples.begin(), samples.end());
+
+                    auto wrap_estimate = [](Estimate<double> e) {
+                        return Estimate<Duration> {
+                            Duration(e.point),
+                                Duration(e.lower_bound),
+                                Duration(e.upper_bound),
+                                e.confidence_interval,
+                        };
+                    };
+                    std::vector<Duration> samples2;
+                    samples2.reserve(samples.size());
+                    std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](double d) { return Duration(d); });
+                    return {
+                        CATCH_MOVE(samples2),
+                        wrap_estimate(analysis.mean),
+                        wrap_estimate(analysis.standard_deviation),
+                        outliers,
+                        analysis.outlier_variance,
+                    };
+                } else {
+                    std::vector<Duration> samples;
+                    samples.reserve(static_cast<size_t>(last - first));
+
+                    Duration mean = Duration(0);
+                    int i = 0;
+                    for (auto it = first; it < last; ++it, ++i) {
+                        samples.push_back(Duration(*it));
+                        mean += Duration(*it);
+                    }
+                    mean /= i;
+
+                    return {
+                        CATCH_MOVE(samples),
+                        Estimate<Duration>{mean, mean, mean, 0.0},
+                        Estimate<Duration>{Duration(0), Duration(0), Duration(0), 0.0},
+                        OutlierClassification{},
+                        0.0
+                    };
+                }
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_ANALYSE_HPP_INCLUDED
+
+#include <algorithm>
+#include <functional>
+#include <string>
+#include <vector>
+#include <cmath>
+
+namespace Catch {
+    namespace Benchmark {
+        struct Benchmark {
+            Benchmark(std::string&& benchmarkName)
+                : name(CATCH_MOVE(benchmarkName)) {}
+
+            template <class FUN>
+            Benchmark(std::string&& benchmarkName , FUN &&func)
+                : fun(CATCH_MOVE(func)), name(CATCH_MOVE(benchmarkName)) {}
+
+            template <typename Clock>
+            ExecutionPlan<FloatDuration<Clock>> prepare(const IConfig &cfg, Environment<FloatDuration<Clock>> env) const {
+                auto min_time = env.clock_resolution.mean * Detail::minimum_ticks;
+                auto run_time = std::max(min_time, std::chrono::duration_cast<decltype(min_time)>(cfg.benchmarkWarmupTime()));
+                auto&& test = Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(run_time), 1, fun);
+                int new_iters = static_cast<int>(std::ceil(min_time * test.iterations / test.elapsed));
+                return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), fun, std::chrono::duration_cast<FloatDuration<Clock>>(cfg.benchmarkWarmupTime()), Detail::warmup_iterations };
+            }
+
+            template <typename Clock = default_clock>
+            void run() {
+                auto const* cfg = getCurrentContext().getConfig();
+
+                auto env = Detail::measure_environment<Clock>();
+
+                getResultCapture().benchmarkPreparing(name);
+                CATCH_TRY{
+                    auto plan = user_code([&] {
+                        return prepare<Clock>(*cfg, env);
+                    });
+
+                    BenchmarkInfo info {
+                        name,
+                        plan.estimated_duration.count(),
+                        plan.iterations_per_sample,
+                        cfg->benchmarkSamples(),
+                        cfg->benchmarkResamples(),
+                        env.clock_resolution.mean.count(),
+                        env.clock_cost.mean.count()
+                    };
+
+                    getResultCapture().benchmarkStarting(info);
+
+                    auto samples = user_code([&] {
+                        return plan.template run<Clock>(*cfg, env);
+                    });
+
+                    auto analysis = Detail::analyse(*cfg, env, samples.begin(), samples.end());
+                    BenchmarkStats<FloatDuration<Clock>> stats{ info, analysis.samples, analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
+                    getResultCapture().benchmarkEnded(stats);
+                } CATCH_CATCH_ANON (TestFailureException) {
+                    getResultCapture().benchmarkFailed("Benchmark failed due to failed assertion"_sr);
+                } CATCH_CATCH_ALL{
+                    getResultCapture().benchmarkFailed(translateActiveException());
+                    // We let the exception go further up so that the
+                    // test case is marked as failed.
+                    std::rethrow_exception(std::current_exception());
+                }
+            }
+
+            // sets lambda to be used in fun *and* executes benchmark!
+            template <typename Fun, std::enable_if_t<!Detail::is_related<Fun, Benchmark>::value, int> = 0>
+                Benchmark & operator=(Fun func) {
+                auto const* cfg = getCurrentContext().getConfig();
+                if (!cfg->skipBenchmarks()) {
+                    fun = Detail::BenchmarkFunction(func);
+                    run();
+                }
+                return *this;
+            }
+
+            explicit operator bool() {
+                return true;
+            }
+
+        private:
+            Detail::BenchmarkFunction fun;
+            std::string name;
+        };
+    }
+} // namespace Catch
+
+#define INTERNAL_CATCH_GET_1_ARG(arg1, arg2, ...) arg1
+#define INTERNAL_CATCH_GET_2_ARG(arg1, arg2, ...) arg2
+
+#define INTERNAL_CATCH_BENCHMARK(BenchmarkName, name, benchmarkIndex)\
+    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
+        BenchmarkName = [&](int benchmarkIndex)
+
+#define INTERNAL_CATCH_BENCHMARK_ADVANCED(BenchmarkName, name)\
+    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
+        BenchmarkName = [&]
+
+#if defined(CATCH_CONFIG_PREFIX_ALL)
+
+#define CATCH_BENCHMARK(...) \
+    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
+#define CATCH_BENCHMARK_ADVANCED(name) \
+    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), name)
+
+#else
+
+#define BENCHMARK(...) \
+    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
+#define BENCHMARK_ADVANCED(name) \
+    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), name)
+
+#endif
+
+#endif // CATCH_BENCHMARK_HPP_INCLUDED
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_CONSTRUCTOR_HPP_INCLUDED
+#define CATCH_CONSTRUCTOR_HPP_INCLUDED
+
+
+#include <type_traits>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename T, bool Destruct>
+            struct ObjectStorage
+            {
+                ObjectStorage() = default;
+
+                ObjectStorage(const ObjectStorage& other)
+                {
+                    new(&data) T(other.stored_object());
+                }
+
+                ObjectStorage(ObjectStorage&& other)
+                {
+                    new(data) T(CATCH_MOVE(other.stored_object()));
+                }
+
+                ~ObjectStorage() { destruct_on_exit<T>(); }
+
+                template <typename... Args>
+                void construct(Args&&... args)
+                {
+                    new (data) T(CATCH_FORWARD(args)...);
+                }
+
+                template <bool AllowManualDestruction = !Destruct>
+                std::enable_if_t<AllowManualDestruction> destruct()
+                {
+                    stored_object().~T();
+                }
+
+            private:
+                // If this is a constructor benchmark, destruct the underlying object
+                template <typename U>
+                void destruct_on_exit(std::enable_if_t<Destruct, U>* = nullptr) { destruct<true>(); }
+                // Otherwise, don't
+                template <typename U>
+                void destruct_on_exit(std::enable_if_t<!Destruct, U>* = nullptr) { }
+
+#if defined( __GNUC__ ) && __GNUC__ <= 6
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif
+                T& stored_object() { return *reinterpret_cast<T*>( data ); }
+
+                T const& stored_object() const {
+                    return *reinterpret_cast<T const*>( data );
+                }
+#if defined( __GNUC__ ) && __GNUC__ <= 6
+#    pragma GCC diagnostic pop
+#endif
+
+                alignas( T ) unsigned char data[sizeof( T )]{};
+            };
+        } // namespace Detail
+
+        template <typename T>
+        using storage_for = Detail::ObjectStorage<T, true>;
+
+        template <typename T>
+        using destructable_object = Detail::ObjectStorage<T, false>;
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_CONSTRUCTOR_HPP_INCLUDED
+
+#endif // CATCH_BENCHMARK_ALL_HPP_INCLUDED
+
+
+#ifndef CATCH_APPROX_HPP_INCLUDED
+#define CATCH_APPROX_HPP_INCLUDED
+
+
+
+#ifndef CATCH_TOSTRING_HPP_INCLUDED
+#define CATCH_TOSTRING_HPP_INCLUDED
+
+
+#include <vector>
+#include <cstddef>
+#include <type_traits>
+#include <string>
+
+
+
+
+/** \file
+ * Wrapper for the WCHAR configuration option
+ *
+ * We want to support platforms that do not provide `wchar_t`, so we
+ * sometimes have to disable providing wchar_t overloads through Catch2,
+ * e.g. the StringMaker specialization for `std::wstring`.
+ */
+
+#ifndef CATCH_CONFIG_WCHAR_HPP_INCLUDED
+#define CATCH_CONFIG_WCHAR_HPP_INCLUDED
+
+// We assume that WCHAR should be enabled by default, and only disabled
+// for a shortlist (so far only DJGPP) of compilers.
+
+#if defined(__DJGPP__)
+#  define CATCH_INTERNAL_CONFIG_NO_WCHAR
+#endif // __DJGPP__
+
+#if !defined( CATCH_INTERNAL_CONFIG_NO_WCHAR ) && \
+    !defined( CATCH_CONFIG_NO_WCHAR ) && \
+    !defined( CATCH_CONFIG_WCHAR )
+#    define CATCH_CONFIG_WCHAR
+#endif
+
+#endif // CATCH_CONFIG_WCHAR_HPP_INCLUDED
+
+
+#ifndef CATCH_REUSABLE_STRING_STREAM_HPP_INCLUDED
+#define CATCH_REUSABLE_STRING_STREAM_HPP_INCLUDED
+
+
+#include <iosfwd>
+#include <cstddef>
+#include <ostream>
+#include <string>
+
+namespace Catch {
+
+    class ReusableStringStream : Detail::NonCopyable {
+        std::size_t m_index;
+        std::ostream* m_oss;
+    public:
+        ReusableStringStream();
+        ~ReusableStringStream();
+
+        //! Returns the serialized state
+        std::string str() const;
+        //! Sets internal state to `str`
+        void str(std::string const& str);
+
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic push
+// Old versions of GCC do not understand -Wnonnull-compare
+#pragma GCC diagnostic ignored "-Wpragmas"
+// Streaming a function pointer triggers Waddress and Wnonnull-compare
+// on GCC, because it implicitly converts it to bool and then decides
+// that the check it uses (a? true : false) is tautological and cannot
+// be null...
+#pragma GCC diagnostic ignored "-Waddress"
+#pragma GCC diagnostic ignored "-Wnonnull-compare"
+#endif
+
+        template<typename T>
+        auto operator << ( T const& value ) -> ReusableStringStream& {
+            *m_oss << value;
+            return *this;
+        }
+
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+        auto get() -> std::ostream& { return *m_oss; }
+    };
+}
+
+#endif // CATCH_REUSABLE_STRING_STREAM_HPP_INCLUDED
+
+
+#ifndef CATCH_VOID_TYPE_HPP_INCLUDED
+#define CATCH_VOID_TYPE_HPP_INCLUDED
+
+
+namespace Catch {
+    namespace Detail {
+
+        template <typename...>
+        struct make_void { using type = void; };
+
+        template <typename... Ts>
+        using void_t = typename make_void<Ts...>::type;
+
+    } // namespace Detail
+} // namespace Catch
+
+
+#endif // CATCH_VOID_TYPE_HPP_INCLUDED
+
+
+#ifndef CATCH_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED
+#define CATCH_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED
+
+
+#include <vector>
+
+namespace Catch {
+
+    namespace Detail {
+        struct EnumInfo {
+            StringRef m_name;
+            std::vector<std::pair<int, StringRef>> m_values;
+
+            ~EnumInfo();
+
+            StringRef lookup( int value ) const;
+        };
+    } // namespace Detail
+
+    class IMutableEnumValuesRegistry {
+    public:
+        virtual ~IMutableEnumValuesRegistry(); // = default;
+
+        virtual Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values ) = 0;
+
+        template<typename E>
+        Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::initializer_list<E> values ) {
+            static_assert(sizeof(int) >= sizeof(E), "Cannot serialize enum to int");
+            std::vector<int> intValues;
+            intValues.reserve( values.size() );
+            for( auto enumValue : values )
+                intValues.push_back( static_cast<int>( enumValue ) );
+            return registerEnum( enumName, allEnums, intValues );
+        }
+    };
+
+} // Catch
+
+#endif // CATCH_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED
+
+#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+#include <string_view>
+#endif
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#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 global namespace operator<< for ADL lookup in
+    // `IsStreamInsertable` below.
+    using ::operator<<;
+
+    namespace Detail {
+
+        inline std::size_t catch_strnlen(const char *str, std::size_t n) {
+            auto ret = std::char_traits<char>::find(str, n, '\0');
+            if (ret != nullptr) {
+                return static_cast<std::size_t>(ret - str);
+            }
+            return n;
+        }
+
+        constexpr StringRef unprintableString = "{?}"_sr;
+
+        //! Encases `string in quotes, and optionally escapes invisibles
+        std::string convertIntoString( StringRef string, bool escapeInvisibles );
+
+        //! Encases `string` in quotes, and escapes invisibles if user requested
+        //! it via CLI
+        std::string convertIntoString( StringRef string );
+
+        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 Stream, typename U>
+            static auto test(int)
+                -> decltype(std::declval<Stream&>() << std::declval<U>(), 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>
+        std::enable_if_t<
+            !std::is_enum<T>::value && !std::is_base_of<std::exception, T>::value,
+        std::string> convertUnstreamable( T const& ) {
+            return std::string(Detail::unprintableString);
+        }
+        template<typename T>
+        std::enable_if_t<
+            !std::is_enum<T>::value && std::is_base_of<std::exception, T>::value,
+         std::string> convertUnstreamable(T const& ex) {
+            return ex.what();
+        }
+
+
+        template<typename T>
+        std::enable_if_t<
+            std::is_enum<T>::value,
+        std::string> 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
+        std::enable_if_t<::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>
+            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
+        std::enable_if_t<!::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>
+            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<std::remove_cv_t<std::remove_reference_t<T>>>::convert(e);
+        }
+
+        template<typename E>
+        std::string convertUnknownEnumToString( E e ) {
+            return ::Catch::Detail::stringify(static_cast<std::underlying_type_t<E>>(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);
+    };
+
+#if defined(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 // CATCH_CONFIG_WCHAR
+
+    template<size_t SZ>
+    struct StringMaker<char[SZ]> {
+        static std::string convert(char const* str) {
+            return Detail::convertIntoString(
+                StringRef( str, Detail::catch_strnlen( str, SZ ) ) );
+        }
+    };
+    template<size_t SZ>
+    struct StringMaker<signed char[SZ]> {
+        static std::string convert(signed char const* str) {
+            auto reinterpreted = reinterpret_cast<char const*>(str);
+            return Detail::convertIntoString(
+                StringRef(reinterpreted, Detail::catch_strnlen(reinterpreted, SZ)));
+        }
+    };
+    template<size_t SZ>
+    struct StringMaker<unsigned char[SZ]> {
+        static std::string convert(unsigned char const* str) {
+            auto reinterpreted = reinterpret_cast<char const*>(str);
+            return Detail::convertIntoString(
+                StringRef(reinterpreted, Detail::catch_strnlen(reinterpreted, SZ)));
+        }
+    };
+
+#if defined(CATCH_CONFIG_CPP17_BYTE)
+    template<>
+    struct StringMaker<std::byte> {
+        static std::string convert(std::byte value);
+    };
+#endif // defined(CATCH_CONFIG_CPP17_BYTE)
+    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) {
+            using namespace std::string_literals;
+            return b ? "true"s : "false"s;
+        }
+    };
+
+    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) {
+            using namespace std::string_literals;
+            return "nullptr"s;
+        }
+    };
+
+    template<>
+    struct StringMaker<float> {
+        static std::string convert(float value);
+        CATCH_EXPORT static int precision;
+    };
+
+    template<>
+    struct StringMaker<double> {
+        static std::string convert(double value);
+        CATCH_EXPORT static int precision;
+    };
+
+    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, typename Sentinel = InputIterator>
+        std::string rangeToString(InputIterator first, Sentinel 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();
+        }
+    }
+
+} // namespace Catch
+
+//////////////////////////////////////////////////////
+// Separate std-lib types stringification, so it can be selectively enabled
+// This means that we do not bring in their headers
+
+#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_OPTIONAL_STRINGMAKER
+#endif
+
+// 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) {
+            ReusableStringStream rss;
+            rss << "{ "
+                << ::Catch::Detail::stringify(pair.first)
+                << ", "
+                << ::Catch::Detail::stringify(pair.second)
+                << " }";
+            return rss.str();
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
+
+#if defined(CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_OPTIONAL)
+#include <optional>
+namespace Catch {
+    template<typename T>
+    struct StringMaker<std::optional<T> > {
+        static std::string convert(const std::optional<T>& optional) {
+            if (optional.has_value()) {
+                return ::Catch::Detail::stringify(*optional);
+            } else {
+                return "{ }";
+            }
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
+
+// Separate std::tuple specialization
+#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) {
+            ReusableStringStream rss;
+            rss << '{';
+            Detail::TupleElementPrinter<std::tuple<Types...>>::print(tuple, rss.get());
+            rss << " }";
+            return rss.str();
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
+
+#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 {
+    // Import begin/ end from std here
+    using std::begin;
+    using std::end;
+
+    namespace Detail {
+        template <typename T, typename = void>
+        struct is_range_impl : std::false_type {};
+
+        template <typename T>
+        struct is_range_impl<T, void_t<decltype(begin(std::declval<T>()))>> : std::true_type {};
+    } // namespace Detail
+
+    template <typename T>
+    struct is_range : Detail::is_range_impl<T> {};
+
+#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, std::enable_if_t<is_range<R>::value && !::Catch::Detail::IsStreamInsertable<R>::value>> {
+        static std::string convert( R const& range ) {
+            return rangeToString( range );
+        }
+    };
+
+    template <typename T, size_t SZ>
+    struct StringMaker<T[SZ]> {
+        static std::string convert(T const(&arr)[SZ]) {
+            return rangeToString(arr);
+        }
+    };
+
+
+} // namespace Catch
+
+// Separate std::chrono::duration specialization
+#include <ctime>
+#include <ratio>
+#include <chrono>
+
+
+namespace Catch {
+
+template <class Ratio>
+struct ratio_string {
+    static std::string symbol() {
+        Catch::ReusableStringStream rss;
+        rss << '[' << Ratio::num << '/'
+            << Ratio::den << ']';
+        return rss.str();
+    }
+};
+
+template <>
+struct ratio_string<std::atto> {
+    static char symbol() { return 'a'; }
+};
+template <>
+struct ratio_string<std::femto> {
+    static char symbol() { return 'f'; }
+};
+template <>
+struct ratio_string<std::pico> {
+    static char symbol() { return 'p'; }
+};
+template <>
+struct ratio_string<std::nano> {
+    static char symbol() { return 'n'; }
+};
+template <>
+struct ratio_string<std::micro> {
+    static char symbol() { return 'u'; }
+};
+template <>
+struct ratio_string<std::milli> {
+    static char symbol() { return 'm'; }
+};
+
+    ////////////
+    // 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);
+#else
+            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";
+
+#ifdef _MSC_VER
+            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
+#else
+            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
+#endif
+            return std::string(timeStamp, timeStampSize - 1);
+        }
+    };
+}
+
+
+#define INTERNAL_CATCH_REGISTER_ENUM( enumName, ... ) \
+namespace Catch { \
+    template<> struct StringMaker<enumName> { \
+        static std::string convert( enumName value ) { \
+            static const auto& enumInfo = ::Catch::getMutableRegistryHub().getMutableEnumValuesRegistry().registerEnum( #enumName, #__VA_ARGS__, { __VA_ARGS__ } ); \
+            return static_cast<std::string>(enumInfo.lookup( static_cast<int>( value ) )); \
+        } \
+    }; \
+}
+
+#define CATCH_REGISTER_ENUM( enumName, ... ) INTERNAL_CATCH_REGISTER_ENUM( enumName, __VA_ARGS__ )
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+#endif // CATCH_TOSTRING_HPP_INCLUDED
+
+#include <type_traits>
+
+namespace Catch {
+
+    class Approx {
+    private:
+        bool equalityComparisonImpl(double other) const;
+        // Sets and validates the new margin (margin >= 0)
+        void setMargin(double margin);
+        // Sets and validates the new epsilon (0 < epsilon < 1)
+        void setEpsilon(double epsilon);
+
+    public:
+        explicit Approx ( double value );
+
+        static Approx custom();
+
+        Approx operator-() const;
+
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+        Approx operator()( T const& value ) const {
+            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 = std::enable_if_t<std::is_constructible<double, T>::value>>
+        explicit Approx( T const& value ): Approx(static_cast<double>(value))
+        {}
+
+
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+        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 = std::enable_if_t<std::is_constructible<double, T>::value>>
+        friend bool operator == ( Approx const& lhs, const T& rhs ) {
+            return operator==( rhs, lhs );
+        }
+
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+        friend bool operator != ( T const& lhs, Approx const& rhs ) {
+            return !operator==( lhs, rhs );
+        }
+
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+        friend bool operator != ( Approx const& lhs, T const& rhs ) {
+            return !operator==( rhs, lhs );
+        }
+
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+        friend bool operator <= ( T const& lhs, Approx const& rhs ) {
+            return static_cast<double>(lhs) < rhs.m_value || lhs == rhs;
+        }
+
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+        friend bool operator <= ( Approx const& lhs, T const& rhs ) {
+            return lhs.m_value < static_cast<double>(rhs) || lhs == rhs;
+        }
+
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+        friend bool operator >= ( T const& lhs, Approx const& rhs ) {
+            return static_cast<double>(lhs) > rhs.m_value || lhs == rhs;
+        }
+
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+        friend bool operator >= ( Approx const& lhs, T const& rhs ) {
+            return lhs.m_value > static_cast<double>(rhs) || lhs == rhs;
+        }
+
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+        Approx& epsilon( T const& newEpsilon ) {
+            const auto epsilonAsDouble = static_cast<double>(newEpsilon);
+            setEpsilon(epsilonAsDouble);
+            return *this;
+        }
+
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+        Approx& margin( T const& newMargin ) {
+            const auto marginAsDouble = static_cast<double>(newMargin);
+            setMargin(marginAsDouble);
+            return *this;
+        }
+
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+        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;
+    };
+
+namespace literals {
+    Approx operator ""_a(long double val);
+    Approx operator ""_a(unsigned long long val);
+} // end namespace literals
+
+template<>
+struct StringMaker<Catch::Approx> {
+    static std::string convert(Catch::Approx const& value);
+};
+
+} // end namespace Catch
+
+#endif // CATCH_APPROX_HPP_INCLUDED
+
+
+#ifndef CATCH_CONFIG_HPP_INCLUDED
+#define CATCH_CONFIG_HPP_INCLUDED
+
+
+
+#ifndef CATCH_TEST_SPEC_HPP_INCLUDED
+#define CATCH_TEST_SPEC_HPP_INCLUDED
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+
+
+#ifndef CATCH_WILDCARD_PATTERN_HPP_INCLUDED
+#define CATCH_WILDCARD_PATTERN_HPP_INCLUDED
+
+
+
+#ifndef CATCH_CASE_SENSITIVE_HPP_INCLUDED
+#define CATCH_CASE_SENSITIVE_HPP_INCLUDED
+
+namespace Catch {
+
+    enum class CaseSensitive { Yes, No };
+
+} // namespace Catch
+
+#endif // CATCH_CASE_SENSITIVE_HPP_INCLUDED
+
+#include <string>
+
+namespace Catch
+{
+    class WildcardPattern {
+        enum WildcardPosition {
+            NoWildcard = 0,
+            WildcardAtStart = 1,
+            WildcardAtEnd = 2,
+            WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
+        };
+
+    public:
+
+        WildcardPattern( std::string const& pattern, CaseSensitive caseSensitivity );
+        bool matches( std::string const& str ) const;
+
+    private:
+        std::string normaliseString( std::string const& str ) const;
+        CaseSensitive m_caseSensitivity;
+        WildcardPosition m_wildcard = NoWildcard;
+        std::string m_pattern;
+    };
+}
+
+#endif // CATCH_WILDCARD_PATTERN_HPP_INCLUDED
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+    class IConfig;
+    struct TestCaseInfo;
+    class TestCaseHandle;
+
+    class TestSpec {
+
+        class Pattern {
+        public:
+            explicit Pattern( std::string const& name );
+            virtual ~Pattern();
+            virtual bool matches( TestCaseInfo const& testCase ) const = 0;
+            std::string const& name() const;
+        private:
+            std::string const m_name;
+        };
+
+        class NamePattern : public Pattern {
+        public:
+            explicit NamePattern( std::string const& name, std::string const& filterString );
+            bool matches( TestCaseInfo const& testCase ) const override;
+        private:
+            WildcardPattern m_wildcardPattern;
+        };
+
+        class TagPattern : public Pattern {
+        public:
+            explicit TagPattern( std::string const& tag, std::string const& filterString );
+            bool matches( TestCaseInfo const& testCase ) const override;
+        private:
+            std::string m_tag;
+        };
+
+        struct Filter {
+            std::vector<Detail::unique_ptr<Pattern>> m_required;
+            std::vector<Detail::unique_ptr<Pattern>> m_forbidden;
+
+            bool matches( TestCaseInfo const& testCase ) const;
+            std::string name() const;
+        };
+
+    public:
+        struct FilterMatch {
+            std::string name;
+            std::vector<TestCaseHandle const*> tests;
+        };
+        using Matches = std::vector<FilterMatch>;
+        using vectorStrings = std::vector<std::string>;
+
+        bool hasFilters() const;
+        bool matches( TestCaseInfo const& testCase ) const;
+        Matches matchesByFilter( std::vector<TestCaseHandle> const& testCases, IConfig const& config ) const;
+        const vectorStrings & getInvalidSpecs() const;
+
+    private:
+        std::vector<Filter> m_filters;
+        std::vector<std::string> m_invalidSpecs;
+        friend class TestSpecParser;
+    };
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#endif // CATCH_TEST_SPEC_HPP_INCLUDED
+
+
+#ifndef CATCH_OPTIONAL_HPP_INCLUDED
+#define CATCH_OPTIONAL_HPP_INCLUDED
+
+#include <cassert>
+
+namespace Catch {
+
+    // An optional type
+    template<typename T>
+    class Optional {
+    public:
+        Optional() : nullableValue( nullptr ) {}
+        Optional( T const& _value )
+        : nullableValue( new( storage ) T( _value ) )
+        {}
+        Optional( Optional const& _other )
+        : nullableValue( _other ? new( storage ) T( *_other ) : nullptr )
+        {}
+
+        ~Optional() {
+            reset();
+        }
+
+        Optional& operator= ( Optional const& _other ) {
+            if( &_other != this ) {
+                reset();
+                if( _other )
+                    nullableValue = new( storage ) T( *_other );
+            }
+            return *this;
+        }
+        Optional& operator = ( T const& _value ) {
+            reset();
+            nullableValue = new( storage ) T( _value );
+            return *this;
+        }
+
+        void reset() {
+            if( nullableValue )
+                nullableValue->~T();
+            nullableValue = nullptr;
+        }
+
+        T& operator*() {
+            assert(nullableValue);
+            return *nullableValue;
+        }
+        T const& operator*() const {
+            assert(nullableValue);
+            return *nullableValue;
+        }
+        T* operator->() {
+            assert(nullableValue);
+            return nullableValue;
+        }
+        const T* operator->() const {
+            assert(nullableValue);
+            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();
+        }
+
+        friend bool operator==(Optional const& a, Optional const& b) {
+            if (a.none() && b.none()) {
+                return true;
+            } else if (a.some() && b.some()) {
+                return *a == *b;
+            } else {
+                return false;
+            }
+        }
+        friend bool operator!=(Optional const& a, Optional const& b) {
+            return !( a == b );
+        }
+
+    private:
+        T *nullableValue;
+        alignas(alignof(T)) char storage[sizeof(T)];
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_OPTIONAL_HPP_INCLUDED
+
+
+#ifndef CATCH_RANDOM_SEED_GENERATION_HPP_INCLUDED
+#define CATCH_RANDOM_SEED_GENERATION_HPP_INCLUDED
+
+#include <cstdint>
+
+namespace Catch {
+
+    enum class GenerateFrom {
+        Time,
+        RandomDevice,
+        //! Currently equivalent to RandomDevice, but can change at any point
+        Default
+    };
+
+    std::uint32_t generateRandomSeed(GenerateFrom from);
+
+} // end namespace Catch
+
+#endif // CATCH_RANDOM_SEED_GENERATION_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_SPEC_PARSER_HPP_INCLUDED
+#define CATCH_REPORTER_SPEC_PARSER_HPP_INCLUDED
+
+
+
+#ifndef CATCH_CONSOLE_COLOUR_HPP_INCLUDED
+#define CATCH_CONSOLE_COLOUR_HPP_INCLUDED
+
+
+#include <iosfwd>
+#include <cstdint>
+
+namespace Catch {
+
+    enum class ColourMode : std::uint8_t;
+    class IStream;
+
+    struct Colour {
+        enum Code {
+            None = 0,
+
+            White,
+            Red,
+            Green,
+            Blue,
+            Cyan,
+            Yellow,
+            Grey,
+
+            Bright = 0x10,
+
+            BrightRed = Bright | Red,
+            BrightGreen = Bright | Green,
+            LightGrey = Bright | Grey,
+            BrightWhite = Bright | White,
+            BrightYellow = Bright | Yellow,
+
+            // By intention
+            FileName = LightGrey,
+            Warning = BrightYellow,
+            ResultError = BrightRed,
+            ResultSuccess = BrightGreen,
+            ResultExpectedFailure = Warning,
+
+            Error = BrightRed,
+            Success = Green,
+
+            OriginalExpression = Cyan,
+            ReconstructedExpression = BrightYellow,
+
+            SecondaryText = LightGrey,
+            Headers = White
+        };
+    };
+
+    class ColourImpl {
+    protected:
+        //! The associated stream of this ColourImpl instance
+        IStream* m_stream;
+    public:
+        ColourImpl( IStream* stream ): m_stream( stream ) {}
+
+        //! RAII wrapper around writing specific colour of text using specific
+        //! colour impl into a stream.
+        class ColourGuard {
+            ColourImpl const* m_colourImpl;
+            Colour::Code m_code;
+            bool m_engaged = false;
+
+        public:
+            //! Does **not** engage the guard/start the colour
+            ColourGuard( Colour::Code code,
+                         ColourImpl const* colour );
+
+            ColourGuard( ColourGuard const& rhs ) = delete;
+            ColourGuard& operator=( ColourGuard const& rhs ) = delete;
+
+            ColourGuard( ColourGuard&& rhs ) noexcept;
+            ColourGuard& operator=( ColourGuard&& rhs ) noexcept;
+
+            //! Removes colour _if_ the guard was engaged
+            ~ColourGuard();
+
+            /**
+             * Explicitly engages colour for given stream.
+             *
+             * The API based on operator<< should be preferred.
+             */
+            ColourGuard& engage( std::ostream& stream ) &;
+            /**
+             * Explicitly engages colour for given stream.
+             *
+             * The API based on operator<< should be preferred.
+             */
+            ColourGuard&& engage( std::ostream& stream ) &&;
+
+        private:
+            //! Engages the guard and starts using colour
+            friend std::ostream& operator<<( std::ostream& lhs,
+                                             ColourGuard& guard ) {
+                guard.engageImpl( lhs );
+                return lhs;
+            }
+            //! Engages the guard and starts using colour
+            friend std::ostream& operator<<( std::ostream& lhs,
+                                            ColourGuard&& guard) {
+                guard.engageImpl( lhs );
+                return lhs;
+            }
+
+            void engageImpl( std::ostream& stream );
+
+        };
+
+        virtual ~ColourImpl(); // = default
+        /**
+         * Creates a guard object for given colour and this colour impl
+         *
+         * **Important:**
+         * the guard starts disengaged, and has to be engaged explicitly.
+         */
+        ColourGuard guardColour( Colour::Code colourCode );
+
+    private:
+        virtual void use( Colour::Code colourCode ) const = 0;
+    };
+
+    //! Provides ColourImpl based on global config and target compilation platform
+    Detail::unique_ptr<ColourImpl> makeColourImpl( ColourMode colourSelection,
+                                                   IStream* stream );
+
+    //! Checks if specific colour impl has been compiled into the binary
+    bool isColourImplAvailable( ColourMode colourSelection );
+
+} // end namespace Catch
+
+#endif // CATCH_CONSOLE_COLOUR_HPP_INCLUDED
+
+#include <map>
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+    enum class ColourMode : std::uint8_t;
+
+    namespace Detail {
+        //! Splits the reporter spec into reporter name and kv-pair options
+        std::vector<std::string> splitReporterSpec( StringRef reporterSpec );
+
+        Optional<ColourMode> stringToColourMode( StringRef colourMode );
+    }
+
+    /**
+     * Structured reporter spec that a reporter can be created from
+     *
+     * Parsing has been validated, but semantics have not. This means e.g.
+     * that the colour mode is known to Catch2, but it might not be
+     * compiled into the binary, and the output filename might not be
+     * openable.
+     */
+    class ReporterSpec {
+        std::string m_name;
+        Optional<std::string> m_outputFileName;
+        Optional<ColourMode> m_colourMode;
+        std::map<std::string, std::string> m_customOptions;
+
+        friend bool operator==( ReporterSpec const& lhs,
+                                ReporterSpec const& rhs );
+        friend bool operator!=( ReporterSpec const& lhs,
+                                ReporterSpec const& rhs ) {
+            return !( lhs == rhs );
+        }
+
+    public:
+        ReporterSpec(
+            std::string name,
+            Optional<std::string> outputFileName,
+            Optional<ColourMode> colourMode,
+            std::map<std::string, std::string> customOptions );
+
+        std::string const& name() const { return m_name; }
+
+        Optional<std::string> const& outputFile() const {
+            return m_outputFileName;
+        }
+
+        Optional<ColourMode> const& colourMode() const { return m_colourMode; }
+
+        std::map<std::string, std::string> const& customOptions() const {
+            return m_customOptions;
+        }
+    };
+
+    /**
+     * Parses provided reporter spec string into
+     *
+     * Returns empty optional on errors, e.g.
+     *  * field that is not first and not a key+value pair
+     *  * duplicated keys in kv pair
+     *  * unknown catch reporter option
+     *  * empty key/value in an custom kv pair
+     *  * ...
+     */
+    Optional<ReporterSpec> parseReporterSpec( StringRef reporterSpec );
+
+}
+
+#endif // CATCH_REPORTER_SPEC_PARSER_HPP_INCLUDED
+
+#include <chrono>
+#include <map>
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+    class IStream;
+
+    /**
+     * `ReporterSpec` but with the defaults filled in.
+     *
+     * Like `ReporterSpec`, the semantics are unchecked.
+     */
+    struct ProcessedReporterSpec {
+        std::string name;
+        std::string outputFilename;
+        ColourMode colourMode;
+        std::map<std::string, std::string> customOptions;
+        friend bool operator==( ProcessedReporterSpec const& lhs,
+                                ProcessedReporterSpec const& rhs );
+        friend bool operator!=( ProcessedReporterSpec const& lhs,
+                                ProcessedReporterSpec const& rhs ) {
+            return !( lhs == rhs );
+        }
+    };
+
+    struct ConfigData {
+
+        bool listTests = false;
+        bool listTags = false;
+        bool listReporters = false;
+        bool listListeners = false;
+
+        bool showSuccessfulTests = false;
+        bool shouldDebugBreak = false;
+        bool noThrow = false;
+        bool showHelp = false;
+        bool showInvisibles = false;
+        bool filenamesAsTags = false;
+        bool libIdentify = false;
+        bool allowZeroTests = false;
+
+        int abortAfter = -1;
+        uint32_t rngSeed = generateRandomSeed(GenerateFrom::Default);
+
+        unsigned int shardCount = 1;
+        unsigned int shardIndex = 0;
+
+        bool skipBenchmarks = false;
+        bool benchmarkNoAnalysis = false;
+        unsigned int benchmarkSamples = 100;
+        double benchmarkConfidenceInterval = 0.95;
+        unsigned int benchmarkResamples = 100000;
+        std::chrono::milliseconds::rep benchmarkWarmupTime = 100;
+
+        Verbosity verbosity = Verbosity::Normal;
+        WarnAbout::What warnings = WarnAbout::Nothing;
+        ShowDurations showDurations = ShowDurations::DefaultForReporter;
+        double minDuration = -1;
+        TestRunOrder runOrder = TestRunOrder::Declared;
+        ColourMode defaultColourMode = ColourMode::PlatformDefault;
+        WaitForKeypress::When waitForKeypress = WaitForKeypress::Never;
+
+        std::string defaultOutputFilename;
+        std::string name;
+        std::string processName;
+        std::vector<ReporterSpec> reporterSpecifications;
+
+        std::vector<std::string> testsOrTags;
+        std::vector<std::string> sectionsToRun;
+    };
+
+
+    class Config : public IConfig {
+    public:
+
+        Config() = default;
+        Config( ConfigData const& data );
+        ~Config() override; // = default in the cpp file
+
+        bool listTests() const;
+        bool listTags() const;
+        bool listReporters() const;
+        bool listListeners() const;
+
+        std::vector<ReporterSpec> const& getReporterSpecs() const;
+        std::vector<ProcessedReporterSpec> const&
+        getProcessedReporterSpecs() const;
+
+        std::vector<std::string> const& getTestsOrTags() const override;
+        std::vector<std::string> const& getSectionsToRun() const override;
+
+        TestSpec const& testSpec() const override;
+        bool hasTestFilters() const override;
+
+        bool showHelp() const;
+
+        // IConfig interface
+        bool allowThrows() const override;
+        StringRef name() const override;
+        bool includeSuccessfulResults() const override;
+        bool warnAboutMissingAssertions() const override;
+        bool warnAboutUnmatchedTestSpecs() const override;
+        bool zeroTestsCountAsSuccess() const override;
+        ShowDurations showDurations() const override;
+        double minDuration() const override;
+        TestRunOrder runOrder() const override;
+        uint32_t rngSeed() const override;
+        unsigned int shardCount() const override;
+        unsigned int shardIndex() const override;
+        ColourMode defaultColourMode() const override;
+        bool shouldDebugBreak() const override;
+        int abortAfter() const override;
+        bool showInvisibles() const override;
+        Verbosity verbosity() const override;
+        bool skipBenchmarks() const override;
+        bool benchmarkNoAnalysis() const override;
+        unsigned int benchmarkSamples() const override;
+        double benchmarkConfidenceInterval() const override;
+        unsigned int benchmarkResamples() const override;
+        std::chrono::milliseconds benchmarkWarmupTime() const override;
+
+    private:
+        ConfigData m_data;
+        std::vector<ProcessedReporterSpec> m_processedReporterSpecs;
+        TestSpec m_testSpec;
+        bool m_hasTestFilters = false;
+    };
+} // end namespace Catch
+
+#endif // CATCH_CONFIG_HPP_INCLUDED
+
+
+#ifndef CATCH_GET_RANDOM_SEED_HPP_INCLUDED
+#define CATCH_GET_RANDOM_SEED_HPP_INCLUDED
+
+#include <cstdint>
+
+namespace Catch {
+    //! Returns Catch2's current RNG seed.
+    std::uint32_t getSeed();
+}
+
+#endif // CATCH_GET_RANDOM_SEED_HPP_INCLUDED
+
+
+#ifndef CATCH_MESSAGE_HPP_INCLUDED
+#define CATCH_MESSAGE_HPP_INCLUDED
+
+
+
+#ifndef CATCH_STREAM_END_STOP_HPP_INCLUDED
+#define CATCH_STREAM_END_STOP_HPP_INCLUDED
+
+
+namespace Catch {
+
+    // Use this in variadic streaming macros to allow
+    //    << +StreamEndStop
+    // as well as
+    //    << stuff +StreamEndStop
+    struct StreamEndStop {
+        StringRef operator+() const { return StringRef(); }
+
+        template <typename T>
+        friend T const& operator+( T const& value, StreamEndStop ) {
+            return value;
+        }
+    };
+
+} // namespace Catch
+
+#endif // CATCH_STREAM_END_STOP_HPP_INCLUDED
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+    struct SourceLineInfo;
+
+    struct MessageStream {
+
+        template<typename T>
+        MessageStream& operator << ( T const& value ) {
+            m_stream << value;
+            return *this;
+        }
+
+        ReusableStringStream m_stream;
+    };
+
+    struct MessageBuilder : MessageStream {
+        MessageBuilder( StringRef macroName,
+                        SourceLineInfo const& lineInfo,
+                        ResultWas::OfType type ):
+            m_info(macroName, lineInfo, type) {}
+
+
+        template<typename T>
+        MessageBuilder& operator << ( T const& value ) {
+            m_stream << value;
+            return *this;
+        }
+
+        MessageInfo m_info;
+    };
+
+    class ScopedMessage {
+    public:
+        explicit ScopedMessage( MessageBuilder const& builder );
+        ScopedMessage( ScopedMessage& duplicate ) = delete;
+        ScopedMessage( ScopedMessage&& old ) noexcept;
+        ~ScopedMessage();
+
+        MessageInfo m_info;
+        bool m_moved = false;
+    };
+
+    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(Capturer const&) = delete;
+        Capturer& operator=(Capturer const&) = delete;
+
+        ~Capturer();
+
+        void captureValue( size_t index, std::string const& value );
+
+        template<typename T>
+        void captureValues( size_t index, T const& value ) {
+            captureValue( index, Catch::Detail::stringify( value ) );
+        }
+
+        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
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \
+    do { \
+        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( false )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_CAPTURE( varName, macroName, ... ) \
+    Catch::Capturer varName( 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_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_UNSCOPED_INFO( macroName, log ) \
+    Catch::getResultCapture().emplaceUnscopedMessage( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
+
+
+#if defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
+
+  #define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
+  #define CATCH_UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "CATCH_UNSCOPED_INFO", msg )
+  #define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( "CATCH_WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
+  #define CATCH_CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CATCH_CAPTURE", __VA_ARGS__ )
+
+#elif defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)
+
+  #define CATCH_INFO( msg )          (void)(0)
+  #define CATCH_UNSCOPED_INFO( msg ) (void)(0)
+  #define CATCH_WARN( msg )          (void)(0)
+  #define CATCH_CAPTURE( ... )       (void)(0)
+
+#elif !defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
+
+  #define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
+  #define UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "UNSCOPED_INFO", msg )
+  #define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
+  #define CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CAPTURE", __VA_ARGS__ )
+
+#elif !defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)
+
+  #define INFO( msg )          (void)(0)
+  #define UNSCOPED_INFO( msg ) (void)(0)
+  #define WARN( msg )          (void)(0)
+  #define CAPTURE( ... )       (void)(0)
+
+#endif // end of user facing macro declarations
+
+
+
+
+#endif // CATCH_MESSAGE_HPP_INCLUDED
+
+
+#ifndef CATCH_SESSION_HPP_INCLUDED
+#define CATCH_SESSION_HPP_INCLUDED
+
+
+
+#ifndef CATCH_COMMANDLINE_HPP_INCLUDED
+#define CATCH_COMMANDLINE_HPP_INCLUDED
+
+
+
+#ifndef CATCH_CLARA_HPP_INCLUDED
+#define CATCH_CLARA_HPP_INCLUDED
+
+#if defined( __clang__ )
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wweak-vtables"
+#    pragma clang diagnostic ignored "-Wshadow"
+#    pragma clang diagnostic ignored "-Wdeprecated"
+#endif
+
+#if defined( __GNUC__ )
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
+
+#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
+
+
+#include <cassert>
+#include <memory>
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+namespace Catch {
+    namespace Clara {
+
+        class Args;
+        class Parser;
+
+        // enum of result types from a parse
+        enum class ParseResultType {
+            Matched,
+            NoMatch,
+            ShortCircuitAll,
+            ShortCircuitSame
+        };
+
+        struct accept_many_t {};
+        constexpr accept_many_t accept_many {};
+
+        namespace Detail {
+            struct fake_arg {
+                template <typename T>
+                operator T();
+            };
+
+            template <typename F, typename = void>
+            struct is_unary_function : std::false_type {};
+
+            template <typename F>
+            struct is_unary_function<
+                F,
+                Catch::Detail::void_t<decltype(
+                    std::declval<F>()( fake_arg() ) )
+                >
+            > : std::true_type {};
+
+            // 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 = std::remove_const_t<std::remove_reference_t<ArgT>>;
+                using ReturnType = ReturnT;
+            };
+
+            class TokenStream;
+
+            // 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;
+            };
+
+            // 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();
+
+            public:
+                explicit TokenStream( Args const& args );
+                TokenStream( Iterator it, Iterator itEnd );
+
+                explicit operator bool() const {
+                    return !m_tokenBuffer.empty() || it != itEnd;
+                }
+
+                size_t count() const {
+                    return m_tokenBuffer.size() + ( itEnd - it );
+                }
+
+                Token operator*() const {
+                    assert( !m_tokenBuffer.empty() );
+                    return m_tokenBuffer.front();
+                }
+
+                Token const* operator->() const {
+                    assert( !m_tokenBuffer.empty() );
+                    return &m_tokenBuffer.front();
+                }
+
+                TokenStream& operator++();
+            };
+
+            //! Denotes type of a parsing result
+            enum class ResultType {
+                Ok,          ///< No errors
+                LogicError,  ///< Error in user-specified arguments for
+                             ///< construction
+                RuntimeError ///< Error in parsing inputs
+            };
+
+            class ResultBase {
+            protected:
+                ResultBase( ResultType type ): m_type( type ) {}
+                virtual ~ResultBase(); // = default;
+
+
+                ResultBase(ResultBase const&) = default;
+                ResultBase& operator=(ResultBase const&) = default;
+                ResultBase(ResultBase&&) = default;
+                ResultBase& operator=(ResultBase&&) = default;
+
+                virtual void enforceOk() const = 0;
+
+                ResultType m_type;
+            };
+
+            template <typename T> class ResultValueBase : public ResultBase {
+            public:
+                auto value() const -> T const& {
+                    enforceOk();
+                    return m_value;
+                }
+
+            protected:
+                ResultValueBase( ResultType type ): ResultBase( type ) {}
+
+                ResultValueBase( ResultValueBase const& other ):
+                    ResultBase( other ) {
+                    if ( m_type == ResultType::Ok )
+                        new ( &m_value ) T( other.m_value );
+                }
+
+                ResultValueBase( ResultType, T const& value ): ResultBase( ResultType::Ok ) {
+                    new ( &m_value ) T( value );
+                }
+
+                auto operator=( ResultValueBase const& other )
+                    -> ResultValueBase& {
+                    if ( m_type == ResultType::Ok )
+                        m_value.~T();
+                    ResultBase::operator=( other );
+                    if ( m_type == ResultType::Ok )
+                        new ( &m_value ) T( other.m_value );
+                    return *this;
+                }
+
+                ~ResultValueBase() override {
+                    if ( m_type == ResultType::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() != ResultType::Ok );
+                }
+
+                template <typename U>
+                static auto ok( U const& value ) -> BasicResult {
+                    return { ResultType::Ok, value };
+                }
+                static auto ok() -> BasicResult { return { ResultType::Ok }; }
+                static auto logicError( std::string&& message )
+                    -> BasicResult {
+                    return { ResultType::LogicError, CATCH_MOVE(message) };
+                }
+                static auto runtimeError( std::string&& message )
+                    -> BasicResult {
+                    return { ResultType::RuntimeError, CATCH_MOVE(message) };
+                }
+
+                explicit operator bool() const {
+                    return m_type == ResultType::Ok;
+                }
+                auto type() const -> ResultType { return m_type; }
+                auto errorMessage() const -> std::string const& {
+                    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 != ResultType::LogicError );
+                    assert( m_type != ResultType::RuntimeError );
+                    if ( m_type != ResultType::Ok )
+                        std::abort();
+                }
+
+                std::string
+                    m_errorMessage; // Only populated if resultType is an error
+
+                BasicResult( ResultType type,
+                             std::string&& message ):
+                    ResultValueBase<T>( type ), m_errorMessage( CATCH_MOVE(message) ) {
+                    assert( m_type != ResultType::Ok );
+                }
+
+                using ResultValueBase<T>::ResultValueBase;
+                using ResultBase::m_type;
+            };
+
+            class ParseState {
+            public:
+                ParseState( ParseResultType type,
+                            TokenStream const& remainingTokens );
+
+                ParseResultType type() const { return m_type; }
+                TokenStream const& remainingTokens() const {
+                    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>
+            ParserResult convertInto( std::string const& source, T& target ) {
+                std::stringstream ss( source );
+                ss >> target;
+                if ( ss.fail() ) {
+                    return ParserResult::runtimeError(
+                        "Unable to convert '" + source +
+                        "' to destination type" );
+                } else {
+                    return ParserResult::ok( ParseResultType::Matched );
+                }
+            }
+            ParserResult convertInto( std::string const& source,
+                                      std::string& target );
+            ParserResult convertInto( std::string const& source, bool& target );
+
+#ifdef CLARA_CONFIG_OPTIONAL_TYPE
+            template <typename T>
+            auto convertInto( std::string const& source,
+                              CLARA_CONFIG_OPTIONAL_TYPE<T>& target )
+                -> ParserResult {
+                T temp;
+                auto result = convertInto( source, temp );
+                if ( result )
+                    target = CATCH_MOVE( temp );
+                return result;
+            }
+#endif // CLARA_CONFIG_OPTIONAL_TYPE
+
+            struct BoundRef : Catch::Detail::NonCopyable {
+                virtual ~BoundRef() = default;
+                virtual bool isContainer() const;
+                virtual bool isFlag() const;
+            };
+            struct BoundValueRefBase : BoundRef {
+                virtual auto setValue( std::string const& arg )
+                    -> ParserResult = 0;
+            };
+            struct BoundFlagRefBase : BoundRef {
+                virtual auto setFlag( bool flag ) -> ParserResult = 0;
+                bool isFlag() const override;
+            };
+
+            template <typename T> struct BoundValueRef : BoundValueRefBase {
+                T& m_ref;
+
+                explicit BoundValueRef( T& ref ): m_ref( ref ) {}
+
+                ParserResult setValue( std::string const& arg ) 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 ) {}
+
+                ParserResult setFlag( bool flag ) override;
+            };
+
+            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>
+            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 BoundManyLambda : BoundLambda<L> {
+                explicit BoundManyLambda( L const& lambda ): BoundLambda<L>( lambda ) {}
+                bool isContainer() const override { return true; }
+            };
+
+            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 };
+
+            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 size_t cardinality() const;
+
+                InternalParseResult parse( Args const& args ) const;
+            };
+
+            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<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 LambdaT>
+                ParserRefImpl( accept_many_t,
+                               LambdaT const& ref,
+                               std::string const& hint ):
+                    m_ref( std::make_shared<BoundManyLambda<LambdaT>>( ref ) ),
+                    m_hint( hint ) {}
+
+                template <typename T,
+                          typename = typename std::enable_if_t<
+                              !Detail::is_unary_function<T>::value>>
+                ParserRefImpl( T& ref, std::string const& hint ):
+                    m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
+                    m_hint( hint ) {}
+
+                template <typename LambdaT,
+                          typename = typename std::enable_if_t<
+                              Detail::is_unary_function<LambdaT>::value>>
+                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;
+                }
+
+                std::string const& hint() const { return m_hint; }
+            };
+
+        } // namespace detail
+
+
+        // A parser for arguments
+        class Arg : public Detail::ParserRefImpl<Arg> {
+        public:
+            using ParserRefImpl::ParserRefImpl;
+            using ParserBase::parse;
+
+            Detail::InternalParseResult
+                parse(std::string const&,
+                      Detail::TokenStream const& tokens) const override;
+        };
+
+        // A parser for options
+        class Opt : public Detail::ParserRefImpl<Opt> {
+        protected:
+            std::vector<std::string> m_optNames;
+
+        public:
+            template <typename LambdaT>
+            explicit Opt(LambdaT const& ref) :
+                ParserRefImpl(
+                    std::make_shared<Detail::BoundFlagLambda<LambdaT>>(ref)) {}
+
+            explicit Opt(bool& ref);
+
+            template <typename LambdaT,
+                      typename = typename std::enable_if_t<
+                          Detail::is_unary_function<LambdaT>::value>>
+            Opt( LambdaT const& ref, std::string const& hint ):
+                ParserRefImpl( ref, hint ) {}
+
+            template <typename LambdaT>
+            Opt( accept_many_t, LambdaT const& ref, std::string const& hint ):
+                ParserRefImpl( accept_many, ref, hint ) {}
+
+            template <typename T,
+                      typename = typename std::enable_if_t<
+                          !Detail::is_unary_function<T>::value>>
+            Opt( T& ref, std::string const& hint ):
+                ParserRefImpl( ref, hint ) {}
+
+            auto operator[](std::string const& optName) -> Opt& {
+                m_optNames.push_back(optName);
+                return *this;
+            }
+
+            std::vector<Detail::HelpColumns> getHelpColumns() const;
+
+            bool isMatch(std::string const& optToken) const;
+
+            using ParserBase::parse;
+
+            Detail::InternalParseResult
+                parse(std::string const&,
+                      Detail::TokenStream const& tokens) const override;
+
+            Detail::Result validate() const override;
+        };
+
+        // Specifies the name of the executable
+        class ExeName : public Detail::ComposableParserImpl<ExeName> {
+            std::shared_ptr<std::string> m_name;
+            std::shared_ptr<Detail::BoundValueRefBase> m_ref;
+
+        public:
+            ExeName();
+            explicit ExeName(std::string& ref);
+
+            template <typename LambdaT>
+            explicit ExeName(LambdaT const& lambda) : ExeName() {
+                m_ref = std::make_shared<Detail::BoundLambda<LambdaT>>(lambda);
+            }
+
+            // The exe name is not parsed out of the normal tokens, but is
+            // handled specially
+            Detail::InternalParseResult
+                parse(std::string const&,
+                      Detail::TokenStream const& tokens) const override;
+
+            std::string const& name() const { return *m_name; }
+            Detail::ParserResult set(std::string const& newName);
+        };
+
+
+        // A Combined parser
+        class Parser : Detail::ParserBase {
+            mutable ExeName m_exeName;
+            std::vector<Opt> m_options;
+            std::vector<Arg> m_args;
+
+        public:
+
+            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;
+            }
+
+            Parser& operator|=(Parser const& other);
+
+            template <typename T>
+            auto operator|(T const& other) const -> Parser {
+                return Parser(*this) |= other;
+            }
+
+            std::vector<Detail::HelpColumns> getHelpColumns() const;
+
+            void writeToStream(std::ostream& os) const;
+
+            friend auto operator<<(std::ostream& os, Parser const& parser)
+                -> std::ostream& {
+                parser.writeToStream(os);
+                return os;
+            }
+
+            Detail::Result validate() const override;
+
+            using ParserBase::parse;
+            Detail::InternalParseResult
+                parse(std::string const& exeName,
+                      Detail::TokenStream const& tokens) const override;
+        };
+
+        // Transport for raw args (copied from main args, or supplied via
+        // init list for testing)
+        class Args {
+            friend Detail::TokenStream;
+            std::string m_exeName;
+            std::vector<std::string> m_args;
+
+        public:
+            Args(int argc, char const* const* argv);
+            Args(std::initializer_list<std::string> args);
+
+            std::string const& exeName() const { return m_exeName; }
+        };
+
+
+        // Convenience wrapper for option parser that specifies the help option
+        struct Help : Opt {
+            Help(bool& showHelpFlag);
+        };
+
+        // Result type for parser operation
+        using Detail::ParserResult;
+
+        namespace Detail {
+            template <typename DerivedT>
+            template <typename T>
+            Parser
+                ComposableParserImpl<DerivedT>::operator|(T const& other) const {
+                return Parser() | static_cast<DerivedT const&>(*this) | other;
+            }
+        }
+
+    } // namespace Clara
+} // namespace Catch
+
+#if defined( __clang__ )
+#    pragma clang diagnostic pop
+#endif
+
+#if defined( __GNUC__ )
+#    pragma GCC diagnostic pop
+#endif
+
+#endif // CATCH_CLARA_HPP_INCLUDED
+
+namespace Catch {
+
+    struct ConfigData;
+
+    Clara::Parser makeCommandLineParser( ConfigData& config );
+
+} // end namespace Catch
+
+#endif // CATCH_COMMANDLINE_HPP_INCLUDED
+
+namespace Catch {
+
+    class Session : Detail::NonCopyable {
+    public:
+
+        Session();
+        ~Session();
+
+        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;
+        Detail::unique_ptr<Config> m_config;
+        bool m_startupExceptions = false;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_SESSION_HPP_INCLUDED
+
+
+#ifndef CATCH_TAG_ALIAS_HPP_INCLUDED
+#define CATCH_TAG_ALIAS_HPP_INCLUDED
+
+
+#include <string>
+
+namespace Catch {
+
+    struct TagAlias {
+        TagAlias(std::string const& _tag, SourceLineInfo _lineInfo):
+            tag(_tag),
+            lineInfo(_lineInfo)
+        {}
+
+        std::string tag;
+        SourceLineInfo lineInfo;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_TAG_ALIAS_HPP_INCLUDED
+
+
+#ifndef CATCH_TAG_ALIAS_AUTOREGISTRAR_HPP_INCLUDED
+#define CATCH_TAG_ALIAS_AUTOREGISTRAR_HPP_INCLUDED
+
+
+namespace Catch {
+
+    struct RegistrarForTagAliases {
+        RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
+    };
+
+} // end namespace Catch
+
+#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+    namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+#endif // CATCH_TAG_ALIAS_AUTOREGISTRAR_HPP_INCLUDED
+
+
+#ifndef CATCH_TEMPLATE_TEST_MACROS_HPP_INCLUDED
+#define CATCH_TEMPLATE_TEST_MACROS_HPP_INCLUDED
+
+// We need this suppression to leak, because it took until GCC 10
+// for the front end to handle local suppression via _Pragma properly
+// inside templates (so `TEMPLATE_TEST_CASE` and co).
+// **THIS IS DIFFERENT FOR STANDARD TESTS, WHERE GCC 9 IS SUFFICIENT**
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && __GNUC__ < 10
+#pragma GCC diagnostic ignored "-Wparentheses"
+#endif
+
+
+
+
+#ifndef CATCH_TEST_MACROS_HPP_INCLUDED
+#define CATCH_TEST_MACROS_HPP_INCLUDED
+
+
+
+#ifndef CATCH_TEST_MACRO_IMPL_HPP_INCLUDED
+#define CATCH_TEST_MACRO_IMPL_HPP_INCLUDED
+
+
+
+#ifndef CATCH_ASSERTION_HANDLER_HPP_INCLUDED
+#define CATCH_ASSERTION_HANDLER_HPP_INCLUDED
+
+
+
+#ifndef CATCH_DECOMPOSER_HPP_INCLUDED
+#define CATCH_DECOMPOSER_HPP_INCLUDED
+
+
+#include <iosfwd>
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
+#pragma warning(disable:4018) // more "signed/unsigned mismatch"
+#pragma warning(disable:4312) // Converting int to T* using reinterpret_cast (issue on x64 platform)
+#pragma warning(disable:4180) // qualifier applied to function type has no meaning
+#pragma warning(disable:4800) // Forcing result to true or false
+#endif
+
+#ifdef __clang__
+#  pragma clang diagnostic push
+#  pragma clang diagnostic ignored "-Wsign-compare"
+#elif defined __GNUC__
+#  pragma GCC diagnostic push
+#  pragma GCC diagnostic ignored "-Wsign-compare"
+#endif
+
+namespace Catch {
+
+    class ITransientExpression {
+        bool m_isBinaryExpression;
+        bool m_result;
+
+    public:
+        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 )
+        {}
+
+        ITransientExpression() = default;
+        ITransientExpression(ITransientExpression const&) = default;
+        ITransientExpression& operator=(ITransientExpression const&) = default;
+
+        // We don't actually need a virtual destructor, but many static analysers
+        // complain if it's not here :-(
+        virtual ~ITransientExpression(); // = default;
+
+        friend std::ostream& operator<<(std::ostream& out, ITransientExpression const& expr) {
+            expr.streamReconstructedExpression(out);
+            return out;
+        }
+    };
+
+    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 T>
+        auto operator && ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator || ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator == ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator != ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator > ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator < ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator >= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator <= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+    };
+
+    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, static_cast<bool>(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 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, std::enable_if_t<!std::is_arithmetic<std::remove_reference_t<RhsT>>::value, int> = 0>
+        friend auto operator == ( ExprLhs && lhs, RhsT && rhs ) -> BinaryExpr<LhsT, RhsT const&> {
+            return { compareEqual( lhs.m_lhs, rhs ), lhs.m_lhs, "=="_sr, rhs };
+        }
+        template<typename RhsT, std::enable_if_t<std::is_arithmetic<RhsT>::value, int> = 0>
+        friend auto operator == ( ExprLhs && lhs, RhsT rhs ) -> BinaryExpr<LhsT, RhsT> {
+            return { compareEqual( lhs.m_lhs, rhs ), lhs.m_lhs, "=="_sr, rhs };
+        }
+
+        template<typename RhsT, std::enable_if_t<!std::is_arithmetic<std::remove_reference_t<RhsT>>::value, int> = 0>
+        friend auto operator != ( ExprLhs && lhs, RhsT && rhs ) -> BinaryExpr<LhsT, RhsT const&> {
+            return { compareNotEqual( lhs.m_lhs, rhs ), lhs.m_lhs, "!="_sr, rhs };
+        }
+        template<typename RhsT, std::enable_if_t<std::is_arithmetic<RhsT>::value, int> = 0>
+        friend auto operator != ( ExprLhs && lhs, RhsT rhs ) -> BinaryExpr<LhsT, RhsT> {
+            return { compareNotEqual( lhs.m_lhs, rhs ), lhs.m_lhs, "!="_sr, rhs };
+        }
+
+    #define CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(op) \
+        template<typename RhsT, std::enable_if_t<!std::is_arithmetic<std::remove_reference_t<RhsT>>::value, int> = 0> \
+        friend auto operator op ( ExprLhs && lhs, RhsT && rhs ) -> BinaryExpr<LhsT, RhsT const&> { \
+            return { static_cast<bool>(lhs.m_lhs op rhs), lhs.m_lhs, #op##_sr, rhs }; \
+        } \
+        template<typename RhsT, std::enable_if_t<std::is_arithmetic<RhsT>::value, int> = 0> \
+        friend auto operator op ( ExprLhs && lhs, RhsT rhs ) -> BinaryExpr<LhsT, RhsT> { \
+            return { static_cast<bool>(lhs.m_lhs op rhs), lhs.m_lhs, #op##_sr, rhs }; \
+        }
+
+        CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(<)
+        CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(>)
+        CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(<=)
+        CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(>=)
+        CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(|)
+        CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(&)
+        CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(^)
+
+    #undef CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR
+
+        template<typename RhsT>
+        friend auto operator && ( ExprLhs &&, RhsT && ) -> BinaryExpr<LhsT, RhsT const&> {
+            static_assert(always_false<RhsT>::value,
+            "operator&& is not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename RhsT>
+        friend auto operator || ( ExprLhs &&, RhsT && ) -> BinaryExpr<LhsT, RhsT const&> {
+            static_assert(always_false<RhsT>::value,
+            "operator|| is not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        auto makeUnaryExpr() const -> UnaryExpr<LhsT> {
+            return UnaryExpr<LhsT>{ m_lhs };
+        }
+    };
+
+    struct Decomposer {
+        template<typename T, std::enable_if_t<!std::is_arithmetic<std::remove_reference_t<T>>::value, int> = 0>
+        friend auto operator <= ( Decomposer &&, T && lhs ) -> ExprLhs<T const&> {
+            return ExprLhs<const T&>{ lhs };
+        }
+
+        template<typename T, std::enable_if_t<std::is_arithmetic<T>::value, int> = 0>
+        friend auto operator <= ( Decomposer &&, T value ) -> ExprLhs<T> {
+            return ExprLhs<T>{ value };
+        }
+    };
+
+} // end namespace Catch
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+#ifdef __clang__
+#  pragma clang diagnostic pop
+#elif defined __GNUC__
+#  pragma GCC diagnostic pop
+#endif
+
+#endif // CATCH_DECOMPOSER_HPP_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    class IResultCapture;
+
+    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 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 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 matcherString );
+
+} // namespace Catch
+
+#endif // CATCH_ASSERTION_HANDLER_HPP_INCLUDED
+
+// We need this suppression to leak, because it took until GCC 10
+// for the front end to handle local suppression via _Pragma properly
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && __GNUC__ <= 9
+  #pragma GCC diagnostic ignored "-Wparentheses"
+#endif
+
+#if !defined(CATCH_CONFIG_DISABLE)
+
+#if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION)
+  #define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__
+#else
+  #define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"
+#endif
+
+#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.
+#define INTERNAL_CATCH_TRY
+#define INTERNAL_CATCH_CATCH( capturer )
+
+#else // CATCH_CONFIG_FAST_COMPILE
+
+#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 { /* NOLINT(bugprone-infinite-loop) */ \
+        /* The expression should not be evaluated, but warnings should hopefully be checked */ \
+        CATCH_INTERNAL_IGNORE_BUT_WARN(__VA_ARGS__); \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
+        INTERNAL_CATCH_TRY { \
+            CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+            CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+            catchAssertionHandler.handleExpr( Catch::Decomposer() <= __VA_ARGS__ ); \
+            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( (void)0, (false) && static_cast<const 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_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
+        try { \
+            CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+            CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
+            static_cast<void>(__VA_ARGS__); \
+            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+            catchAssertionHandler.handleExceptionNotThrownAsExpected(); \
+        } \
+        catch( ... ) { \
+            catchAssertionHandler.handleUnexpectedInflightException(); \
+        } \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS( macroName, resultDisposition, ... ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition); \
+        if( catchAssertionHandler.allowThrows() ) \
+            try { \
+                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+                CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
+                static_cast<void>(__VA_ARGS__); \
+                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+            } \
+            catch( ... ) { \
+                catchAssertionHandler.handleExceptionThrownAsExpected(); \
+            } \
+        else \
+            catchAssertionHandler.handleThrowingCallSkipped(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
+        if( catchAssertionHandler.allowThrows() ) \
+            try { \
+                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+                CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
+                static_cast<void>(expr); \
+                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+            } \
+            catch( exceptionType const& ) { \
+                catchAssertionHandler.handleExceptionThrownAsExpected(); \
+            } \
+            catch( ... ) { \
+                catchAssertionHandler.handleUnexpectedInflightException(); \
+            } \
+        else \
+            catchAssertionHandler.handleThrowingCallSkipped(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+// 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_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+        if( catchAssertionHandler.allowThrows() ) \
+            try { \
+                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+                CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
+                static_cast<void>(__VA_ARGS__); \
+                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+            } \
+            catch( ... ) { \
+                Catch::handleExceptionMatchExpr( catchAssertionHandler, matcher, #matcher##_catch_sr ); \
+            } \
+        else \
+            catchAssertionHandler.handleThrowingCallSkipped(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+#endif // CATCH_CONFIG_DISABLE
+
+#endif // CATCH_TEST_MACRO_IMPL_HPP_INCLUDED
+
+
+#ifndef CATCH_SECTION_HPP_INCLUDED
+#define CATCH_SECTION_HPP_INCLUDED
+
+
+
+#ifndef CATCH_TIMER_HPP_INCLUDED
+#define CATCH_TIMER_HPP_INCLUDED
+
+#include <cstdint>
+
+namespace Catch {
+
+    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
+
+#endif // CATCH_TIMER_HPP_INCLUDED
+
+namespace Catch {
+
+    class Section : Detail::NonCopyable {
+    public:
+        Section( SectionInfo&& info );
+        ~Section();
+
+        // This indicates whether the section should be executed or not
+        explicit operator bool() const;
+
+    private:
+        SectionInfo m_info;
+
+        Counts m_assertions;
+        bool m_sectionIncluded;
+        Timer m_timer;
+    };
+
+} // end namespace Catch
+
+#define INTERNAL_CATCH_SECTION( ... ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+    CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+#define INTERNAL_CATCH_DYNAMIC_SECTION( ... ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+    CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, (Catch::ReusableStringStream() << __VA_ARGS__).str() ) ) \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+#endif // CATCH_SECTION_HPP_INCLUDED
+
+
+#ifndef CATCH_TEST_REGISTRY_HPP_INCLUDED
+#define CATCH_TEST_REGISTRY_HPP_INCLUDED
+
+
+
+#ifndef CATCH_INTERFACES_TESTCASE_HPP_INCLUDED
+#define CATCH_INTERFACES_TESTCASE_HPP_INCLUDED
+
+#include <vector>
+
+namespace Catch {
+
+    class TestSpec;
+    struct TestCaseInfo;
+
+    class ITestInvoker {
+    public:
+        virtual void invoke () const = 0;
+        virtual ~ITestInvoker(); // = default
+    };
+
+    class TestCaseHandle;
+    class IConfig;
+
+    class ITestCaseRegistry {
+    public:
+        virtual ~ITestCaseRegistry(); // = default
+        // TODO: this exists only for adding filenames to test cases -- let's expose this in a saner way later
+        virtual std::vector<TestCaseInfo* > const& getAllInfos() const = 0;
+        virtual std::vector<TestCaseHandle> const& getAllTests() const = 0;
+        virtual std::vector<TestCaseHandle> const& getAllTestsSorted( IConfig const& config ) const = 0;
+    };
+
+    bool isThrowSafe( TestCaseHandle const& testCase, IConfig const& config );
+    bool matchTest( TestCaseHandle const& testCase, TestSpec const& testSpec, IConfig const& config );
+    std::vector<TestCaseHandle> filterTests( std::vector<TestCaseHandle> const& testCases, TestSpec const& testSpec, IConfig const& config );
+    std::vector<TestCaseHandle> const& getAllTestCasesSorted( IConfig const& config );
+
+}
+
+#endif // CATCH_INTERFACES_TESTCASE_HPP_INCLUDED
+
+
+#ifndef CATCH_PREPROCESSOR_REMOVE_PARENS_HPP_INCLUDED
+#define CATCH_PREPROCESSOR_REMOVE_PARENS_HPP_INCLUDED
+
+#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__ )
+
+#endif // CATCH_PREPROCESSOR_REMOVE_PARENS_HPP_INCLUDED
+
+// GCC 5 and older do not properly handle disabling unused-variable warning
+// with a _Pragma. This means that we have to leak the suppression to the
+// user code as well :-(
+#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ <= 5
+#pragma GCC diagnostic ignored "-Wunused-variable"
+#endif
+
+
+
+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)();
+    }
+};
+
+Detail::unique_ptr<ITestInvoker> makeTestInvoker( void(*testAsFunction)() );
+
+template<typename C>
+Detail::unique_ptr<ITestInvoker> makeTestInvoker( void (C::*testAsMethod)() ) {
+    return Detail::make_unique<TestInvokerAsMethod<C>>( testAsMethod );
+}
+
+struct NameAndTags {
+    constexpr NameAndTags( StringRef name_ = StringRef(),
+                           StringRef tags_ = StringRef() ) noexcept:
+        name( name_ ), tags( tags_ ) {}
+    StringRef name;
+    StringRef tags;
+};
+
+struct AutoReg : Detail::NonCopyable {
+    AutoReg( Detail::unique_ptr<ITestInvoker> invoker, SourceLineInfo const& lineInfo, StringRef classOrMethod, NameAndTags const& nameAndTags ) noexcept;
+};
+
+} // end namespace Catch
+
+#if defined(CATCH_CONFIG_DISABLE)
+    #define INTERNAL_CATCH_TESTCASE_NO_REGISTRATION( TestName, ... ) \
+        static inline void TestName()
+    #define INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION( TestName, ClassName, ... ) \
+        namespace{                        \
+            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
+                void test();              \
+            };                            \
+        }                                 \
+        void TestName::test()
+#endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \
+        static void TestName(); \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        static void TestName()
+    #define INTERNAL_CATCH_TESTCASE( ... ) \
+        INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), __VA_ARGS__ )
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &QualifiedMethod ), CATCH_INTERNAL_LINEINFO, "&" #QualifiedMethod, Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+        namespace{ \
+            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_STOP_WARNINGS_SUPPRESSION \
+        void TestName::test()
+    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \
+        INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), ClassName, __VA_ARGS__ )
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \
+        do { \
+            CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+            CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+            CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( Function ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
+            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        } while(false)
+
+
+#endif // CATCH_TEST_REGISTRY_HPP_INCLUDED
+
+
+// All of our user-facing macros support configuration toggle, that
+// forces them to be defined prefixed with CATCH_. We also like to
+// support another toggle that can minimize (disable) their implementation.
+// Given this, we have 4 different configuration options below
+
+#if defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
+
+  #define CATCH_REQUIRE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+  #define CATCH_REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+
+  #define CATCH_REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+  #define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
+  #define CATCH_REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+
+  #define CATCH_CHECK( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+  #define CATCH_CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+  #define CATCH_CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CATCH_CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+  #define CATCH_CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+  #define CATCH_CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+
+  #define CATCH_CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+  #define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
+  #define CATCH_CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __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__ )
+
+
+  #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__ )
+    #define CATCH_STATIC_CHECK( ... )       static_assert(   __VA_ARGS__ ,      #__VA_ARGS__ );     CATCH_SUCCEED( #__VA_ARGS__ )
+    #define CATCH_STATIC_CHECK_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__ )
+    #define CATCH_STATIC_CHECK( ... )       CATCH_CHECK( __VA_ARGS__ )
+    #define CATCH_STATIC_CHECK_FALSE( ... ) CATCH_CHECK_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 )     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 )
+
+#elif defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE) // ^^ prefixed, implemented | vv prefixed, disabled
+
+  #define CATCH_REQUIRE( ... )        (void)(0)
+  #define CATCH_REQUIRE_FALSE( ... )  (void)(0)
+
+  #define CATCH_REQUIRE_THROWS( ... ) (void)(0)
+  #define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
+  #define CATCH_REQUIRE_NOTHROW( ... ) (void)(0)
+
+  #define CATCH_CHECK( ... )         (void)(0)
+  #define CATCH_CHECK_FALSE( ... )   (void)(0)
+  #define CATCH_CHECKED_IF( ... )    if (__VA_ARGS__)
+  #define CATCH_CHECKED_ELSE( ... )  if (!(__VA_ARGS__))
+  #define CATCH_CHECK_NOFAIL( ... )  (void)(0)
+
+  #define CATCH_CHECK_THROWS( ... )  (void)(0)
+  #define CATCH_CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
+  #define CATCH_CHECK_NOTHROW( ... ) (void)(0)
+
+  #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
+  #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
+  #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_STATIC_REQUIRE( ... )       (void)(0)
+  #define CATCH_STATIC_REQUIRE_FALSE( ... ) (void)(0)
+  #define CATCH_STATIC_CHECK( ... )       (void)(0)
+  #define CATCH_STATIC_CHECK_FALSE( ... ) (void)(0)
+
+  // "BDD-style" convenience wrappers
+  #define CATCH_SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
+  #define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), 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 )
+
+#elif !defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE) // ^^ prefixed, disabled | vv unprefixed, implemented
+
+  #define REQUIRE( ... ) INTERNAL_CATCH_TEST( "REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__  )
+  #define REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+
+  #define REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+  #define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
+  #define REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+
+  #define CHECK( ... ) INTERNAL_CATCH_TEST( "CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+  #define CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+  #define CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+  #define CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+  #define CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+
+  #define CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+  #define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
+  #define CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __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__ )
+
+
+  #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__ ")" )
+    #define STATIC_CHECK( ... )       static_assert(   __VA_ARGS__,  #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )
+    #define STATIC_CHECK_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__ )
+    #define STATIC_CHECK( ... )       CHECK( __VA_ARGS__ )
+    #define STATIC_CHECK_FALSE( ... ) CHECK_FALSE( __VA_ARGS__ )
+  #endif
+
+  // "BDD-style" convenience wrappers
+  #define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
+  #define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
+  #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 )
+
+#elif !defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE) // ^^ unprefixed, implemented | vv unprefixed, disabled
+
+  #define REQUIRE( ... )       (void)(0)
+  #define REQUIRE_FALSE( ... ) (void)(0)
+
+  #define REQUIRE_THROWS( ... ) (void)(0)
+  #define REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
+  #define REQUIRE_NOTHROW( ... ) (void)(0)
+
+  #define CHECK( ... ) (void)(0)
+  #define CHECK_FALSE( ... ) (void)(0)
+  #define CHECKED_IF( ... ) if (__VA_ARGS__)
+  #define CHECKED_ELSE( ... ) if (!(__VA_ARGS__))
+  #define CHECK_NOFAIL( ... ) (void)(0)
+
+  #define CHECK_THROWS( ... )  (void)(0)
+  #define CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
+  #define CHECK_NOTHROW( ... ) (void)(0)
+
+  #define TEST_CASE( ... )  INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), __VA_ARGS__)
+  #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
+  #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 STATIC_REQUIRE( ... )       (void)(0)
+  #define STATIC_REQUIRE_FALSE( ... ) (void)(0)
+  #define STATIC_CHECK( ... )       (void)(0)
+  #define STATIC_CHECK_FALSE( ... ) (void)(0)
+
+  // "BDD-style" convenience wrappers
+  #define SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ) )
+  #define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), className )
+
+  #define GIVEN( desc )
+  #define AND_GIVEN( desc )
+  #define WHEN( desc )
+  #define AND_WHEN( desc )
+  #define THEN( desc )
+  #define AND_THEN( desc )
+
+#endif // ^^ unprefixed, disabled
+
+// end of user facing macros
+
+#endif // CATCH_TEST_MACROS_HPP_INCLUDED
+
+
+#ifndef CATCH_TEMPLATE_TEST_REGISTRY_HPP_INCLUDED
+#define CATCH_TEMPLATE_TEST_REGISTRY_HPP_INCLUDED
+
+
+
+#ifndef CATCH_PREPROCESSOR_HPP_INCLUDED
+#define CATCH_PREPROCESSOR_HPP_INCLUDED
+
+
+#if defined(__GNUC__)
+// We need to silence "empty __VA_ARGS__ warning", and using just _Pragma does not work
+#pragma GCC system_header
+#endif
+
+
+#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_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__)
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__
+#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param))
+#else
+// MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
+#define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__)
+#define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__
+#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1)
+#endif
+
+#define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__
+#define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE2(name)
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>())
+#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))
+#else
+#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>()))
+#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)))
+#endif
+
+#define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\
+    CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__)
+
+#define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0)
+#define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1)
+#define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2)
+#define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3)
+#define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4)
+#define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5)
+#define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _3, _4, _5, _6)
+#define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7)
+#define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8)
+#define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9)
+#define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10)
+
+#define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
+
+#define INTERNAL_CATCH_TYPE_GEN\
+    template<typename...> struct TypeList {};\
+    template<typename...Ts>\
+    constexpr auto get_wrapper() noexcept -> TypeList<Ts...> { return {}; }\
+    template<template<typename...> class...> struct TemplateTypeList{};\
+    template<template<typename...> class...Cs>\
+    constexpr auto get_wrapper() noexcept -> TemplateTypeList<Cs...> { return {}; }\
+    template<typename...>\
+    struct append;\
+    template<typename...>\
+    struct rewrap;\
+    template<template<typename...> class, typename...>\
+    struct create;\
+    template<template<typename...> class, typename>\
+    struct convert;\
+    \
+    template<typename T> \
+    struct append<T> { using type = T; };\
+    template< template<typename...> class L1, typename...E1, template<typename...> class L2, typename...E2, typename...Rest>\
+    struct append<L1<E1...>, L2<E2...>, Rest...> { using type = typename append<L1<E1...,E2...>, Rest...>::type; };\
+    template< template<typename...> class L1, typename...E1, typename...Rest>\
+    struct append<L1<E1...>, TypeList<mpl_::na>, Rest...> { using type = L1<E1...>; };\
+    \
+    template< template<typename...> class Container, template<typename...> class List, typename...elems>\
+    struct rewrap<TemplateTypeList<Container>, List<elems...>> { using type = TypeList<Container<elems...>>; };\
+    template< template<typename...> class Container, template<typename...> class List, class...Elems, typename...Elements>\
+    struct rewrap<TemplateTypeList<Container>, List<Elems...>, Elements...> { using type = typename append<TypeList<Container<Elems...>>, typename rewrap<TemplateTypeList<Container>, Elements...>::type>::type; };\
+    \
+    template<template <typename...> class Final, template< typename...> class...Containers, typename...Types>\
+    struct create<Final, TemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<TemplateTypeList<Containers>, Types...>::type...>::type; };\
+    template<template <typename...> class Final, template <typename...> class List, typename...Ts>\
+    struct convert<Final, List<Ts...>> { using type = typename append<Final<>,TypeList<Ts>...>::type; };
+
+#define INTERNAL_CATCH_NTTP_1(signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> struct Nttp{};\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    constexpr auto get_wrapper() noexcept -> Nttp<__VA_ARGS__> { return {}; } \
+    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...> struct NttpTemplateTypeList{};\
+    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Cs>\
+    constexpr auto get_wrapper() noexcept -> NttpTemplateTypeList<Cs...> { return {}; } \
+    \
+    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>> { using type = TypeList<Container<__VA_ARGS__>>; };\
+    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature), typename...Elements>\
+    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>, Elements...> { using type = typename append<TypeList<Container<__VA_ARGS__>>, typename rewrap<NttpTemplateTypeList<Container>, Elements...>::type>::type; };\
+    template<template <typename...> class Final, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Containers, typename...Types>\
+    struct create<Final, NttpTemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<NttpTemplateTypeList<Containers>, Types...>::type...>::type; };
+
+#define INTERNAL_CATCH_DECLARE_SIG_TEST0(TestName)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST1(TestName, signature)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_X(TestName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+
+#define INTERNAL_CATCH_DEFINE_SIG_TEST0(TestName)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST1(TestName, signature)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_X(TestName, signature,...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+
+#define INTERNAL_CATCH_NTTP_REGISTER0(TestFunc, signature)\
+    template<typename Type>\
+    void reg_test(TypeList<Type>, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<Type>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_NTTP_REGISTER(TestFunc, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    void reg_test(Nttp<__VA_ARGS__>, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<__VA_ARGS__>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_NTTP_REGISTER_METHOD0(TestName, signature, ...)\
+    template<typename Type>\
+    void reg_test(TypeList<Type>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestName<Type>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_NTTP_REGISTER_METHOD(TestName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    void reg_test(Nttp<__VA_ARGS__>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestName<__VA_ARGS__>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0(TestName, ClassName)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1(TestName, ClassName, signature)\
+    template<typename TestType> \
+    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<TestType> { \
+        void test();\
+    }
+
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X(TestName, ClassName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
+    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<__VA_ARGS__> { \
+        void test();\
+    }
+
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0(TestName)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1(TestName, signature)\
+    template<typename TestType> \
+    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<TestType>::test()
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X(TestName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
+    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<__VA_ARGS__>::test()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_NTTP_0
+#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__),INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_0)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__)
+#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__)
+#else
+#define INTERNAL_CATCH_NTTP_0(signature)
+#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1,INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_0)( __VA_ARGS__))
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__))
+#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__))
+#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__))
+#endif
+
+#endif // CATCH_PREPROCESSOR_HPP_INCLUDED
+
+
+// GCC 5 and older do not properly handle disabling unused-variable warning
+// with a _Pragma. This means that we have to leak the suppression to the
+// user code as well :-(
+#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ <= 5
+#pragma GCC diagnostic ignored "-Wunused-variable"
+#endif
+
+#if defined(CATCH_CONFIG_DISABLE)
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( TestName, TestFunc, Name, Tags, Signature, ... )  \
+        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... )    \
+        namespace{                                                                                  \
+            namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                      \
+            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
+        }                                                                                           \
+        }                                                                                           \
+        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename TestType, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
+    #endif
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ ) )
+    #endif
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
+    #endif
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
+    #endif
+#endif
+
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_2(TestName, TestFunc, Name, Tags, Signature, ... )\
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+        INTERNAL_CATCH_DECLARE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
+            INTERNAL_CATCH_TYPE_GEN\
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            INTERNAL_CATCH_NTTP_REG_GEN(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            template<typename...Types> \
+            struct TestName{\
+                TestName(){\
+                    size_t index = 0;                                    \
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)}; /* NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays,hicpp-avoid-c-arrays) */\
+                    using expander = size_t[]; /* NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays,hicpp-avoid-c-arrays) */\
+                    (void)expander{(reg_test(Types{}, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++)... };/* NOLINT */ \
+                }\
+            };\
+            static const int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+            TestName<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
+            return 0;\
+        }();\
+        }\
+        }\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename TestType, __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( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(TestName, TestFuncName, Name, Tags, Signature, TmplTypes, TypesList) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                      \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                      \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS                \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS       \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+        template<typename TestType> static void TestFuncName();       \
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                     \
+            INTERNAL_CATCH_TYPE_GEN                                                  \
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))         \
+            template<typename... Types>                               \
+            struct TestName {                                         \
+                void reg_tests() {                                          \
+                    size_t index = 0;                                    \
+                    using expander = size_t[];                           \
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
+                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
+                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFuncName<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + '<' + std::string(types_list[index % num_types]) + '>', Tags } ), index++)... };/* NOLINT */\
+                }                                                     \
+            };                                                        \
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
+                using TestInit = typename create<TestName, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type; \
+                TestInit t;                                           \
+                t.reg_tests();                                        \
+                return 0;                                             \
+            }();                                                      \
+        }                                                             \
+        }                                                             \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                       \
+        template<typename TestType>                                   \
+        static void TestFuncName()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename T,__VA_ARGS__)
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename T, __VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__)
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2(TestName, TestFunc, Name, Tags, TmplList)\
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+        template<typename TestType> static void TestFunc();       \
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
+        INTERNAL_CATCH_TYPE_GEN\
+        template<typename... Types>                               \
+        struct TestName {                                         \
+            void reg_tests() {                                          \
+                size_t index = 0;                                    \
+                using expander = size_t[];                           \
+                (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */\
+            }                                                     \
+        };\
+        static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
+                using TestInit = typename convert<TestName, TmplList>::type; \
+                TestInit t;                                           \
+                t.reg_tests();                                        \
+                return 0;                                             \
+            }();                                                      \
+        }}\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                       \
+        template<typename TestType>                                   \
+        static void TestFunc()
+
+    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(Name, Tags, TmplList) \
+        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, TmplList )
+
+
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... ) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
+            INTERNAL_CATCH_TYPE_GEN\
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
+            INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            template<typename...Types> \
+            struct TestNameClass{\
+                TestNameClass(){\
+                    size_t index = 0;                                    \
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
+                    using expander = size_t[];\
+                    (void)expander{(reg_test(Types{}, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+                TestNameClass<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
+                return 0;\
+        }();\
+        }\
+        }\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+
+#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( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, typename T, __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( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2(TestNameClass, TestName, ClassName, Name, Tags, Signature, TmplTypes, TypesList)\
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+        template<typename TestType> \
+            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
+                void test();\
+            };\
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestNameClass) {\
+            INTERNAL_CATCH_TYPE_GEN                  \
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            template<typename...Types>\
+            struct TestNameClass{\
+                void reg_tests(){\
+                    std::size_t index = 0;\
+                    using expander = std::size_t[];\
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
+                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
+                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + '<' + std::string(types_list[index % num_types]) + '>', Tags } ), index++)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+                using TestInit = typename create<TestNameClass, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type;\
+                TestInit t;\
+                t.reg_tests();\
+                return 0;\
+            }(); \
+        }\
+        }\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        template<typename TestType> \
+        void TestName<TestType>::test()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, typename T, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, typename T,__VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, Signature, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, Signature,__VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, TmplList) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+        template<typename TestType> \
+        struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
+            void test();\
+        };\
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
+            INTERNAL_CATCH_TYPE_GEN\
+            template<typename...Types>\
+            struct TestNameClass{\
+                void reg_tests(){\
+                    size_t index = 0;\
+                    using expander = size_t[];\
+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+                using TestInit = typename convert<TestNameClass, TmplList>::type;\
+                TestInit t;\
+                t.reg_tests();\
+                return 0;\
+            }(); \
+        }}\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        template<typename TestType> \
+        void TestName<TestType>::test()
+
+#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD(ClassName, Name, Tags, TmplList) \
+        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, TmplList )
+
+
+#endif // CATCH_TEMPLATE_TEST_REGISTRY_HPP_INCLUDED
+
+
+#if defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
+
+  #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+    #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
+    #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+    #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
+    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
+    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
+    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+    #define CATCH_TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)
+    #define CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_LIST_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_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
+    #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+    #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
+    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
+    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+    #define CATCH_TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE( __VA_ARGS__ ) )
+    #define CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+  #endif
+
+#elif defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)
+
+  #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
+    #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
+    #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
+    #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
+  #else
+    #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
+    #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
+    #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
+    #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
+  #endif
+
+  // When disabled, these can be shared between proper preprocessor and MSVC preprocessor
+  #define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+  #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+  #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+  #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+  #define CATCH_TEMPLATE_LIST_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE(__VA_ARGS__)
+  #define CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+
+#elif !defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
+
+  #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+    #define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
+    #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+    #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+    #define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
+    #define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
+    #define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
+    #define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+    #define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)
+    #define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_LIST_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_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
+    #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+    #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+    #define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
+    #define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
+    #define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+    #define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+    #define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE( __VA_ARGS__ ) )
+    #define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+  #endif
+
+#elif !defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)
+
+  #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
+    #define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
+    #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
+    #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
+  #else
+    #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
+    #define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
+    #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
+    #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
+  #endif
+
+  // When disabled, these can be shared between proper preprocessor and MSVC preprocessor
+  #define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+  #define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+  #define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+  #define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+  #define TEMPLATE_LIST_TEST_CASE( ... ) TEMPLATE_TEST_CASE(__VA_ARGS__)
+  #define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+
+#endif // end of user facing macro declarations
+
+
+#endif // CATCH_TEMPLATE_TEST_MACROS_HPP_INCLUDED
+
+
+#ifndef CATCH_TEST_CASE_INFO_HPP_INCLUDED
+#define CATCH_TEST_CASE_INFO_HPP_INCLUDED
+
+
+
+#include <string>
+#include <vector>
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+namespace Catch {
+
+    /**
+     * A **view** of a tag string that provides case insensitive comparisons
+     *
+     * Note that in Catch2 internals, the square brackets around tags are
+     * not a part of tag's representation, so e.g. "[cool-tag]" is represented
+     * as "cool-tag" internally.
+     */
+    struct Tag {
+        constexpr Tag(StringRef original_):
+            original(original_)
+        {}
+        StringRef original;
+
+        friend bool operator< ( Tag const& lhs, Tag const& rhs );
+        friend bool operator==( Tag const& lhs, Tag const& rhs );
+    };
+
+    class ITestInvoker;
+
+    enum class TestCaseProperties : uint8_t {
+        None = 0,
+        IsHidden = 1 << 1,
+        ShouldFail = 1 << 2,
+        MayFail = 1 << 3,
+        Throws = 1 << 4,
+        NonPortable = 1 << 5,
+        Benchmark = 1 << 6
+    };
+
+    /**
+     * Various metadata about the test case.
+     *
+     * A test case is uniquely identified by its (class)name and tags
+     * combination, with source location being ignored, and other properties
+     * being determined from tags.
+     *
+     * Tags are kept sorted.
+     */
+    struct TestCaseInfo : Detail::NonCopyable {
+
+        TestCaseInfo(StringRef _className,
+                     NameAndTags const& _tags,
+                     SourceLineInfo const& _lineInfo);
+
+        bool isHidden() const;
+        bool throws() const;
+        bool okToFail() const;
+        bool expectedToFail() const;
+
+        // Adds the tag(s) with test's filename (for the -# flag)
+        void addFilenameTag();
+
+        //! Orders by name, classname and tags
+        friend bool operator<( TestCaseInfo const& lhs,
+                               TestCaseInfo const& rhs );
+
+
+        std::string tagsAsString() const;
+
+        std::string name;
+        StringRef className;
+    private:
+        std::string backingTags;
+        // Internally we copy tags to the backing storage and then add
+        // refs to this storage to the tags vector.
+        void internalAppendTag(StringRef tagString);
+    public:
+        std::vector<Tag> tags;
+        SourceLineInfo lineInfo;
+        TestCaseProperties properties = TestCaseProperties::None;
+    };
+
+    /**
+     * Wrapper over the test case information and the test case invoker
+     *
+     * Does not own either, and is specifically made to be cheap
+     * to copy around.
+     */
+    class TestCaseHandle {
+        TestCaseInfo* m_info;
+        ITestInvoker* m_invoker;
+    public:
+        TestCaseHandle(TestCaseInfo* info, ITestInvoker* invoker) :
+            m_info(info), m_invoker(invoker) {}
+
+        void invoke() const {
+            m_invoker->invoke();
+        }
+
+        TestCaseInfo const& getTestCaseInfo() const;
+    };
+
+    Detail::unique_ptr<TestCaseInfo>
+    makeTestCaseInfo( StringRef className,
+                      NameAndTags const& nameAndTags,
+                      SourceLineInfo const& lineInfo );
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#endif // CATCH_TEST_CASE_INFO_HPP_INCLUDED
+
+
+#ifndef CATCH_TRANSLATE_EXCEPTION_HPP_INCLUDED
+#define CATCH_TRANSLATE_EXCEPTION_HPP_INCLUDED
+
+
+
+#ifndef CATCH_INTERFACES_EXCEPTION_HPP_INCLUDED
+#define CATCH_INTERFACES_EXCEPTION_HPP_INCLUDED
+
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+    using exceptionTranslateFunction = std::string(*)();
+
+    class IExceptionTranslator;
+    using ExceptionTranslators = std::vector<Detail::unique_ptr<IExceptionTranslator const>>;
+
+    class IExceptionTranslator {
+    public:
+        virtual ~IExceptionTranslator(); // = default
+        virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const = 0;
+    };
+
+    class IExceptionTranslatorRegistry {
+    public:
+        virtual ~IExceptionTranslatorRegistry(); // = default
+        virtual std::string translateActiveException() const = 0;
+    };
+
+} // namespace Catch
+
+#endif // CATCH_INTERFACES_EXCEPTION_HPP_INCLUDED
+
+#include <exception>
+
+namespace Catch {
+
+    class ExceptionTranslatorRegistrar {
+        template<typename T>
+        class ExceptionTranslator : public IExceptionTranslator {
+        public:
+
+            ExceptionTranslator( std::string(*translateFunction)( T const& ) )
+            : m_translateFunction( translateFunction )
+            {}
+
+            std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const override {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+                try {
+                    if( it == itEnd )
+                        std::rethrow_exception(std::current_exception());
+                    else
+                        return (*it)->translate( it+1, itEnd );
+                }
+                catch( T const& ex ) {
+                    return m_translateFunction( ex );
+                }
+#else
+                return "You should never get here!";
+#endif
+            }
+
+        protected:
+            std::string(*m_translateFunction)( T const& );
+        };
+
+    public:
+        template<typename T>
+        ExceptionTranslatorRegistrar( std::string(*translateFunction)( T const& ) ) {
+            getMutableRegistryHub().registerTranslator(
+                Detail::make_unique<ExceptionTranslator<T>>(translateFunction)
+            );
+        }
+    };
+
+} // namespace Catch
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TRANSLATE_EXCEPTION2( translatorName, signature ) \
+    static std::string translatorName( signature ); \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+    namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &translatorName ); } \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+    static std::string translatorName( signature )
+
+#define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION2( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
+
+#if defined(CATCH_CONFIG_DISABLE)
+    #define INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( translatorName, signature) \
+            static std::string translatorName( signature )
+#endif
+
+
+// This macro is always prefixed
+#if !defined(CATCH_CONFIG_DISABLE)
+#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
+#else
+#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
+#endif
+
+
+#endif // CATCH_TRANSLATE_EXCEPTION_HPP_INCLUDED
+
+
+#ifndef CATCH_VERSION_HPP_INCLUDED
+#define CATCH_VERSION_HPP_INCLUDED
+
+#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();
+}
+
+#endif // CATCH_VERSION_HPP_INCLUDED
+
+
+#ifndef CATCH_VERSION_MACROS_HPP_INCLUDED
+#define CATCH_VERSION_MACROS_HPP_INCLUDED
+
+#define CATCH_VERSION_MAJOR 3
+#define CATCH_VERSION_MINOR 1
+#define CATCH_VERSION_PATCH 1
+
+#endif // CATCH_VERSION_MACROS_HPP_INCLUDED
+
+
+/** \file
+ * This is a convenience header for Catch2's Generator support. It includes
+ * **all** of Catch2 headers related to generators.
+ *
+ * Generally the Catch2 users should use specific includes they need,
+ * but this header can be used instead for ease-of-experimentation, or
+ * just plain convenience, at the cost of (significantly) increased
+ * compilation times.
+ *
+ * When a new header is added to either the `generators` folder,
+ * or to the corresponding internal subfolder, it should be added here.
+ */
+
+#ifndef CATCH_GENERATORS_ALL_HPP_INCLUDED
+#define CATCH_GENERATORS_ALL_HPP_INCLUDED
+
+
+
+#ifndef CATCH_GENERATOR_EXCEPTION_HPP_INCLUDED
+#define CATCH_GENERATOR_EXCEPTION_HPP_INCLUDED
+
+#include <exception>
+
+namespace Catch {
+
+    // Exception type to be thrown when a Generator runs into an error,
+    // e.g. it cannot initialize the first return value based on
+    // runtime information
+    class GeneratorException : public std::exception {
+        const char* const m_msg = "";
+
+    public:
+        GeneratorException(const char* msg):
+            m_msg(msg)
+        {}
+
+        const char* what() const noexcept override final;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_GENERATOR_EXCEPTION_HPP_INCLUDED
+
+
+#ifndef CATCH_GENERATORS_HPP_INCLUDED
+#define CATCH_GENERATORS_HPP_INCLUDED
+
+
+
+#ifndef CATCH_INTERFACES_GENERATORTRACKER_HPP_INCLUDED
+#define CATCH_INTERFACES_GENERATORTRACKER_HPP_INCLUDED
+
+
+#include <string>
+
+namespace Catch {
+
+    namespace Generators {
+        class GeneratorUntypedBase {
+            // Caches result from `toStringImpl`, assume that when it is an
+            // empty string, the cache is invalidated.
+            mutable std::string m_stringReprCache;
+
+            // Counts based on `next` returning true
+            std::size_t m_currentElementIndex = 0;
+
+            /**
+             * Attempts to move the generator to the next element
+             *
+             * Returns true iff the move succeeded (and a valid element
+             * can be retrieved).
+             */
+            virtual bool next() = 0;
+
+            //! Customization point for `currentElementAsString`
+            virtual std::string stringifyImpl() const = 0;
+
+        public:
+            GeneratorUntypedBase() = default;
+            // Generation of copy ops is deprecated (and Clang will complain)
+            // if there is a user destructor defined
+            GeneratorUntypedBase(GeneratorUntypedBase const&) = default;
+            GeneratorUntypedBase& operator=(GeneratorUntypedBase const&) = default;
+
+            virtual ~GeneratorUntypedBase(); // = default;
+
+            /**
+             * Attempts to move the generator to the next element
+             *
+             * Serves as a non-virtual interface to `next`, so that the
+             * top level interface can provide sanity checking and shared
+             * features.
+             *
+             * As with `next`, returns true iff the move succeeded and
+             * the generator has new valid element to provide.
+             */
+            bool countedNext();
+
+            std::size_t currentElementIndex() const { return m_currentElementIndex; }
+
+            /**
+             * Returns generator's current element as user-friendly string.
+             *
+             * By default returns string equivalent to calling
+             * `Catch::Detail::stringify` on the current element, but generators
+             * can customize their implementation as needed.
+             *
+             * Not thread-safe due to internal caching.
+             *
+             * The returned ref is valid only until the generator instance
+             * is destructed, or it moves onto the next element, whichever
+             * comes first.
+             */
+            StringRef currentElementAsString() const;
+        };
+        using GeneratorBasePtr = Catch::Detail::unique_ptr<GeneratorUntypedBase>;
+
+    } // namespace Generators
+
+    class IGeneratorTracker {
+    public:
+        virtual ~IGeneratorTracker(); // = default;
+        virtual auto hasGenerator() const -> bool = 0;
+        virtual auto getGenerator() const -> Generators::GeneratorBasePtr const& = 0;
+        virtual void setGenerator( Generators::GeneratorBasePtr&& generator ) = 0;
+    };
+
+} // namespace Catch
+
+#endif // CATCH_INTERFACES_GENERATORTRACKER_HPP_INCLUDED
+
+#include <vector>
+#include <tuple>
+
+namespace Catch {
+
+namespace Generators {
+
+namespace Detail {
+
+    //! Throws GeneratorException with the provided message
+    [[noreturn]]
+    void throw_generator_exception(char const * msg);
+
+} // end namespace detail
+
+    template<typename T>
+    class IGenerator : public GeneratorUntypedBase {
+        std::string stringifyImpl() const override {
+            return ::Catch::Detail::stringify( get() );
+        }
+
+    public:
+        ~IGenerator() override = default;
+        IGenerator() = default;
+        IGenerator(IGenerator const&) = default;
+        IGenerator& operator=(IGenerator const&) = default;
+
+
+        // Returns the current element of the generator
+        //
+        // \Precondition The generator is either freshly constructed,
+        // or the last call to `next()` returned true
+        virtual T const& get() const = 0;
+        using type = T;
+    };
+
+    template <typename T>
+    using GeneratorPtr = Catch::Detail::unique_ptr<IGenerator<T>>;
+
+    template <typename T>
+    class GeneratorWrapper final {
+        GeneratorPtr<T> m_generator;
+    public:
+        //! Takes ownership of the passed pointer.
+        GeneratorWrapper(IGenerator<T>* generator):
+            m_generator(generator) {}
+        GeneratorWrapper(GeneratorPtr<T> generator):
+            m_generator(CATCH_MOVE(generator)) {}
+
+        T const& get() const {
+            return m_generator->get();
+        }
+        bool next() {
+            return m_generator->countedNext();
+        }
+    };
+
+
+    template<typename T>
+    class SingleValueGenerator final : public IGenerator<T> {
+        T m_value;
+    public:
+        SingleValueGenerator(T const& value) :
+            m_value(value)
+        {}
+        SingleValueGenerator(T&& value):
+            m_value(CATCH_MOVE(value))
+        {}
+
+        T const& get() const override {
+            return m_value;
+        }
+        bool next() override {
+            return false;
+        }
+    };
+
+    template<typename T>
+    class FixedValuesGenerator final : public IGenerator<T> {
+        static_assert(!std::is_same<T, bool>::value,
+            "FixedValuesGenerator does not support bools because of std::vector<bool>"
+            "specialization, use SingleValue Generator instead.");
+        std::vector<T> m_values;
+        size_t m_idx = 0;
+    public:
+        FixedValuesGenerator( std::initializer_list<T> values ) : m_values( values ) {}
+
+        T const& get() const override {
+            return m_values[m_idx];
+        }
+        bool next() override {
+            ++m_idx;
+            return m_idx < m_values.size();
+        }
+    };
+
+    template <typename T, typename DecayedT = std::decay_t<T>>
+    GeneratorWrapper<DecayedT> value( T&& value ) {
+        return GeneratorWrapper<DecayedT>(
+            Catch::Detail::make_unique<SingleValueGenerator<DecayedT>>(
+                CATCH_FORWARD( value ) ) );
+    }
+    template <typename T>
+    GeneratorWrapper<T> values(std::initializer_list<T> values) {
+        return GeneratorWrapper<T>(Catch::Detail::make_unique<FixedValuesGenerator<T>>(values));
+    }
+
+    template<typename T>
+    class Generators : public IGenerator<T> {
+        std::vector<GeneratorWrapper<T>> m_generators;
+        size_t m_current = 0;
+
+        void add_generator( GeneratorWrapper<T>&& generator ) {
+            m_generators.emplace_back( CATCH_MOVE( generator ) );
+        }
+        void add_generator( T const& val ) {
+            m_generators.emplace_back( value( val ) );
+        }
+        void add_generator( T&& val ) {
+            m_generators.emplace_back( value( CATCH_MOVE( val ) ) );
+        }
+        template <typename U>
+        std::enable_if_t<!std::is_same<std::decay_t<U>, T>::value>
+        add_generator( U&& val ) {
+            add_generator( T( CATCH_FORWARD( val ) ) );
+        }
+
+        template <typename U> void add_generators( U&& valueOrGenerator ) {
+            add_generator( CATCH_FORWARD( valueOrGenerator ) );
+        }
+
+        template <typename U, typename... Gs>
+        void add_generators( U&& valueOrGenerator, Gs&&... moreGenerators ) {
+            add_generator( CATCH_FORWARD( valueOrGenerator ) );
+            add_generators( CATCH_FORWARD( moreGenerators )... );
+        }
+
+    public:
+        template <typename... Gs>
+        Generators(Gs &&... moreGenerators) {
+            m_generators.reserve(sizeof...(Gs));
+            add_generators(CATCH_FORWARD(moreGenerators)...);
+        }
+
+        T const& get() const override {
+            return m_generators[m_current].get();
+        }
+
+        bool next() override {
+            if (m_current >= m_generators.size()) {
+                return false;
+            }
+            const bool current_status = m_generators[m_current].next();
+            if (!current_status) {
+                ++m_current;
+            }
+            return m_current < m_generators.size();
+        }
+    };
+
+
+    template <typename... Ts>
+    GeneratorWrapper<std::tuple<std::decay_t<Ts>...>>
+    table( std::initializer_list<std::tuple<std::decay_t<Ts>...>> tuples ) {
+        return values<std::tuple<Ts...>>( tuples );
+    }
+
+    // Tag type to signal that a generator sequence should convert arguments to a specific type
+    template <typename T>
+    struct as {};
+
+    template<typename T, typename... Gs>
+    auto makeGenerators( GeneratorWrapper<T>&& generator, Gs &&... moreGenerators ) -> Generators<T> {
+        return Generators<T>(CATCH_MOVE(generator), CATCH_FORWARD(moreGenerators)...);
+    }
+    template<typename T>
+    auto makeGenerators( GeneratorWrapper<T>&& generator ) -> Generators<T> {
+        return Generators<T>(CATCH_MOVE(generator));
+    }
+    template<typename T, typename... Gs>
+    auto makeGenerators( T&& val, Gs &&... moreGenerators ) -> Generators<std::decay_t<T>> {
+        return makeGenerators( value( CATCH_FORWARD( val ) ), CATCH_FORWARD( moreGenerators )... );
+    }
+    template<typename T, typename U, typename... Gs>
+    auto makeGenerators( as<T>, U&& val, Gs &&... moreGenerators ) -> Generators<T> {
+        return makeGenerators( value( T( CATCH_FORWARD( val ) ) ), CATCH_FORWARD( moreGenerators )... );
+    }
+
+    auto acquireGeneratorTracker( StringRef generatorName, 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. Yeah.
+    auto generate( StringRef generatorName, SourceLineInfo const& lineInfo, L const& generatorExpression ) -> decltype(std::declval<decltype(generatorExpression())>().get()) {
+        using UnderlyingType = typename decltype(generatorExpression())::type;
+
+        IGeneratorTracker& tracker = acquireGeneratorTracker( generatorName, lineInfo );
+        if (!tracker.hasGenerator()) {
+            tracker.setGenerator(Catch::Detail::make_unique<Generators<UnderlyingType>>(generatorExpression()));
+        }
+
+        auto const& generator = static_cast<IGenerator<UnderlyingType> const&>( *tracker.getGenerator() );
+        return generator.get();
+    }
+
+} // namespace Generators
+} // namespace Catch
+
+#define GENERATE( ... ) \
+    Catch::Generators::generate( INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
+                                 CATCH_INTERNAL_LINEINFO, \
+                                 [ ]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+#define GENERATE_COPY( ... ) \
+    Catch::Generators::generate( INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
+                                 CATCH_INTERNAL_LINEINFO, \
+                                 [=]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+#define GENERATE_REF( ... ) \
+    Catch::Generators::generate( INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
+                                 CATCH_INTERNAL_LINEINFO, \
+                                 [&]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+
+#endif // CATCH_GENERATORS_HPP_INCLUDED
+
+
+#ifndef CATCH_GENERATORS_ADAPTERS_HPP_INCLUDED
+#define CATCH_GENERATORS_ADAPTERS_HPP_INCLUDED
+
+
+#include <cassert>
+
+namespace Catch {
+namespace Generators {
+
+    template <typename T>
+    class TakeGenerator final : public IGenerator<T> {
+        GeneratorWrapper<T> m_generator;
+        size_t m_returned = 0;
+        size_t m_target;
+    public:
+        TakeGenerator(size_t target, GeneratorWrapper<T>&& generator):
+            m_generator(CATCH_MOVE(generator)),
+            m_target(target)
+        {
+            assert(target != 0 && "Empty generators are not allowed");
+        }
+        T const& get() const override {
+            return m_generator.get();
+        }
+        bool next() override {
+            ++m_returned;
+            if (m_returned >= m_target) {
+                return false;
+            }
+
+            const auto success = m_generator.next();
+            // If the underlying generator does not contain enough values
+            // then we cut short as well
+            if (!success) {
+                m_returned = m_target;
+            }
+            return success;
+        }
+    };
+
+    template <typename T>
+    GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<T>(Catch::Detail::make_unique<TakeGenerator<T>>(target, CATCH_MOVE(generator)));
+    }
+
+
+    template <typename T, typename Predicate>
+    class FilterGenerator final : public IGenerator<T> {
+        GeneratorWrapper<T> m_generator;
+        Predicate m_predicate;
+    public:
+        template <typename P = Predicate>
+        FilterGenerator(P&& pred, GeneratorWrapper<T>&& generator):
+            m_generator(CATCH_MOVE(generator)),
+            m_predicate(CATCH_FORWARD(pred))
+        {
+            if (!m_predicate(m_generator.get())) {
+                // It might happen that there are no values that pass the
+                // filter. In that case we throw an exception.
+                auto has_initial_value = next();
+                if (!has_initial_value) {
+                    Detail::throw_generator_exception("No valid value found in filtered generator");
+                }
+            }
+        }
+
+        T const& get() const override {
+            return m_generator.get();
+        }
+
+        bool next() override {
+            bool success = m_generator.next();
+            if (!success) {
+                return false;
+            }
+            while (!m_predicate(m_generator.get()) && (success = m_generator.next()) == true);
+            return success;
+        }
+    };
+
+
+    template <typename T, typename Predicate>
+    GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<T>(Catch::Detail::make_unique<FilterGenerator<T, Predicate>>(CATCH_FORWARD(pred), CATCH_MOVE(generator)));
+    }
+
+    template <typename T>
+    class RepeatGenerator final : public IGenerator<T> {
+        static_assert(!std::is_same<T, bool>::value,
+            "RepeatGenerator currently does not support bools"
+            "because of std::vector<bool> specialization");
+        GeneratorWrapper<T> m_generator;
+        mutable std::vector<T> m_returned;
+        size_t m_target_repeats;
+        size_t m_current_repeat = 0;
+        size_t m_repeat_index = 0;
+    public:
+        RepeatGenerator(size_t repeats, GeneratorWrapper<T>&& generator):
+            m_generator(CATCH_MOVE(generator)),
+            m_target_repeats(repeats)
+        {
+            assert(m_target_repeats > 0 && "Repeat generator must repeat at least once");
+        }
+
+        T const& get() const override {
+            if (m_current_repeat == 0) {
+                m_returned.push_back(m_generator.get());
+                return m_returned.back();
+            }
+            return m_returned[m_repeat_index];
+        }
+
+        bool next() override {
+            // There are 2 basic cases:
+            // 1) We are still reading the generator
+            // 2) We are reading our own cache
+
+            // In the first case, we need to poke the underlying generator.
+            // If it happily moves, we are left in that state, otherwise it is time to start reading from our cache
+            if (m_current_repeat == 0) {
+                const auto success = m_generator.next();
+                if (!success) {
+                    ++m_current_repeat;
+                }
+                return m_current_repeat < m_target_repeats;
+            }
+
+            // In the second case, we need to move indices forward and check that we haven't run up against the end
+            ++m_repeat_index;
+            if (m_repeat_index == m_returned.size()) {
+                m_repeat_index = 0;
+                ++m_current_repeat;
+            }
+            return m_current_repeat < m_target_repeats;
+        }
+    };
+
+    template <typename T>
+    GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<T>(Catch::Detail::make_unique<RepeatGenerator<T>>(repeats, CATCH_MOVE(generator)));
+    }
+
+    template <typename T, typename U, typename Func>
+    class MapGenerator final : public IGenerator<T> {
+        // TBD: provide static assert for mapping function, for friendly error message
+        GeneratorWrapper<U> m_generator;
+        Func m_function;
+        // To avoid returning dangling reference, we have to save the values
+        T m_cache;
+    public:
+        template <typename F2 = Func>
+        MapGenerator(F2&& function, GeneratorWrapper<U>&& generator) :
+            m_generator(CATCH_MOVE(generator)),
+            m_function(CATCH_FORWARD(function)),
+            m_cache(m_function(m_generator.get()))
+        {}
+
+        T const& get() const override {
+            return m_cache;
+        }
+        bool next() override {
+            const auto success = m_generator.next();
+            if (success) {
+                m_cache = m_function(m_generator.get());
+            }
+            return success;
+        }
+    };
+
+    template <typename Func, typename U, typename T = FunctionReturnType<Func, U>>
+    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
+        return GeneratorWrapper<T>(
+            Catch::Detail::make_unique<MapGenerator<T, U, Func>>(CATCH_FORWARD(function), CATCH_MOVE(generator))
+        );
+    }
+
+    template <typename T, typename U, typename Func>
+    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
+        return GeneratorWrapper<T>(
+            Catch::Detail::make_unique<MapGenerator<T, U, Func>>(CATCH_FORWARD(function), CATCH_MOVE(generator))
+        );
+    }
+
+    template <typename T>
+    class ChunkGenerator final : public IGenerator<std::vector<T>> {
+        std::vector<T> m_chunk;
+        size_t m_chunk_size;
+        GeneratorWrapper<T> m_generator;
+        bool m_used_up = false;
+    public:
+        ChunkGenerator(size_t size, GeneratorWrapper<T> generator) :
+            m_chunk_size(size), m_generator(CATCH_MOVE(generator))
+        {
+            m_chunk.reserve(m_chunk_size);
+            if (m_chunk_size != 0) {
+                m_chunk.push_back(m_generator.get());
+                for (size_t i = 1; i < m_chunk_size; ++i) {
+                    if (!m_generator.next()) {
+                        Detail::throw_generator_exception("Not enough values to initialize the first chunk");
+                    }
+                    m_chunk.push_back(m_generator.get());
+                }
+            }
+        }
+        std::vector<T> const& get() const override {
+            return m_chunk;
+        }
+        bool next() override {
+            m_chunk.clear();
+            for (size_t idx = 0; idx < m_chunk_size; ++idx) {
+                if (!m_generator.next()) {
+                    return false;
+                }
+                m_chunk.push_back(m_generator.get());
+            }
+            return true;
+        }
+    };
+
+    template <typename T>
+    GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<std::vector<T>>(
+            Catch::Detail::make_unique<ChunkGenerator<T>>(size, CATCH_MOVE(generator))
+        );
+    }
+
+} // namespace Generators
+} // namespace Catch
+
+
+#endif // CATCH_GENERATORS_ADAPTERS_HPP_INCLUDED
+
+
+#ifndef CATCH_GENERATORS_RANDOM_HPP_INCLUDED
+#define CATCH_GENERATORS_RANDOM_HPP_INCLUDED
+
+
+
+#ifndef CATCH_RANDOM_NUMBER_GENERATOR_HPP_INCLUDED
+#define CATCH_RANDOM_NUMBER_GENERATOR_HPP_INCLUDED
+
+#include <cstdint>
+
+namespace Catch {
+
+    // This is a simple implementation of C++11 Uniform Random Number
+    // Generator. It does not provide all operators, because Catch2
+    // does not use it, but it should behave as expected inside stdlib's
+    // distributions.
+    // The implementation is based on the PCG family (http://pcg-random.org)
+    class SimplePcg32 {
+        using state_type = std::uint64_t;
+    public:
+        using result_type = std::uint32_t;
+        static constexpr result_type (min)() {
+            return 0;
+        }
+        static constexpr result_type (max)() {
+            return static_cast<result_type>(-1);
+        }
+
+        // Provide some default initial state for the default constructor
+        SimplePcg32():SimplePcg32(0xed743cc4U) {}
+
+        explicit SimplePcg32(result_type seed_);
+
+        void seed(result_type seed_);
+        void discard(uint64_t skip);
+
+        result_type operator()();
+
+    private:
+        friend bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
+        friend bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
+
+        // In theory we also need operator<< and operator>>
+        // In practice we do not use them, so we will skip them for now
+
+
+        std::uint64_t m_state;
+        // This part of the state determines which "stream" of the numbers
+        // is chosen -- we take it as a constant for Catch2, so we only
+        // need to deal with seeding the main state.
+        // Picked by reading 8 bytes from `/dev/random` :-)
+        static const std::uint64_t s_inc = (0x13ed0cc53f939476ULL << 1ULL) | 1ULL;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_RANDOM_NUMBER_GENERATOR_HPP_INCLUDED
+
+#include <random>
+
+namespace Catch {
+namespace Generators {
+namespace Detail {
+    // Returns a suitable seed for a random floating generator based off
+    // the primary internal rng. It does so by taking current value from
+    // the rng and returning it as the seed.
+    std::uint32_t getSeed();
+}
+
+template <typename Float>
+class RandomFloatingGenerator final : public IGenerator<Float> {
+    Catch::SimplePcg32 m_rng;
+    std::uniform_real_distribution<Float> m_dist;
+    Float m_current_number;
+public:
+    RandomFloatingGenerator( Float a, Float b, std::uint32_t seed ):
+        m_rng(seed),
+        m_dist(a, b) {
+        static_cast<void>(next());
+    }
+
+    Float const& get() const override {
+        return m_current_number;
+    }
+    bool next() override {
+        m_current_number = m_dist(m_rng);
+        return true;
+    }
+};
+
+template <typename Integer>
+class RandomIntegerGenerator final : public IGenerator<Integer> {
+    Catch::SimplePcg32 m_rng;
+    std::uniform_int_distribution<Integer> m_dist;
+    Integer m_current_number;
+public:
+    RandomIntegerGenerator( Integer a, Integer b, std::uint32_t seed ):
+        m_rng(seed),
+        m_dist(a, b) {
+        static_cast<void>(next());
+    }
+
+    Integer const& get() const override {
+        return m_current_number;
+    }
+    bool next() override {
+        m_current_number = m_dist(m_rng);
+        return true;
+    }
+};
+
+template <typename T>
+std::enable_if_t<std::is_integral<T>::value, GeneratorWrapper<T>>
+random(T a, T b) {
+    static_assert(
+        !std::is_same<T, char>::value &&
+        !std::is_same<T, int8_t>::value &&
+        !std::is_same<T, uint8_t>::value &&
+        !std::is_same<T, signed char>::value &&
+        !std::is_same<T, unsigned char>::value &&
+        !std::is_same<T, bool>::value,
+        "The requested type is not supported by the underlying random distributions from std" );
+    return GeneratorWrapper<T>(
+        Catch::Detail::make_unique<RandomIntegerGenerator<T>>(a, b, Detail::getSeed())
+    );
+}
+
+template <typename T>
+std::enable_if_t<std::is_floating_point<T>::value,
+GeneratorWrapper<T>>
+random(T a, T b) {
+    return GeneratorWrapper<T>(
+        Catch::Detail::make_unique<RandomFloatingGenerator<T>>(a, b, Detail::getSeed())
+    );
+}
+
+
+} // namespace Generators
+} // namespace Catch
+
+
+#endif // CATCH_GENERATORS_RANDOM_HPP_INCLUDED
+
+
+#ifndef CATCH_GENERATORS_RANGE_HPP_INCLUDED
+#define CATCH_GENERATORS_RANGE_HPP_INCLUDED
+
+
+#include <iterator>
+#include <type_traits>
+
+namespace Catch {
+namespace Generators {
+
+
+template <typename T>
+class RangeGenerator final : public IGenerator<T> {
+    T m_current;
+    T m_end;
+    T m_step;
+    bool m_positive;
+
+public:
+    RangeGenerator(T const& start, T const& end, T const& step):
+        m_current(start),
+        m_end(end),
+        m_step(step),
+        m_positive(m_step > T(0))
+    {
+        assert(m_current != m_end && "Range start and end cannot be equal");
+        assert(m_step != T(0) && "Step size cannot be zero");
+        assert(((m_positive && m_current <= m_end) || (!m_positive && m_current >= m_end)) && "Step moves away from end");
+    }
+
+    RangeGenerator(T const& start, T const& end):
+        RangeGenerator(start, end, (start < end) ? T(1) : T(-1))
+    {}
+
+    T const& get() const override {
+        return m_current;
+    }
+
+    bool next() override {
+        m_current += m_step;
+        return (m_positive) ? (m_current < m_end) : (m_current > m_end);
+    }
+};
+
+template <typename T>
+GeneratorWrapper<T> range(T const& start, T const& end, T const& step) {
+    static_assert(std::is_arithmetic<T>::value && !std::is_same<T, bool>::value, "Type must be numeric");
+    return GeneratorWrapper<T>(Catch::Detail::make_unique<RangeGenerator<T>>(start, end, step));
+}
+
+template <typename T>
+GeneratorWrapper<T> range(T const& start, T const& end) {
+    static_assert(std::is_integral<T>::value && !std::is_same<T, bool>::value, "Type must be an integer");
+    return GeneratorWrapper<T>(Catch::Detail::make_unique<RangeGenerator<T>>(start, end));
+}
+
+
+template <typename T>
+class IteratorGenerator final : public IGenerator<T> {
+    static_assert(!std::is_same<T, bool>::value,
+        "IteratorGenerator currently does not support bools"
+        "because of std::vector<bool> specialization");
+
+    std::vector<T> m_elems;
+    size_t m_current = 0;
+public:
+    template <typename InputIterator, typename InputSentinel>
+    IteratorGenerator(InputIterator first, InputSentinel last):m_elems(first, last) {
+        if (m_elems.empty()) {
+            Detail::throw_generator_exception("IteratorGenerator received no valid values");
+        }
+    }
+
+    T const& get() const override {
+        return m_elems[m_current];
+    }
+
+    bool next() override {
+        ++m_current;
+        return m_current != m_elems.size();
+    }
+};
+
+template <typename InputIterator,
+          typename InputSentinel,
+          typename ResultType = typename std::iterator_traits<InputIterator>::value_type>
+GeneratorWrapper<ResultType> from_range(InputIterator from, InputSentinel to) {
+    return GeneratorWrapper<ResultType>(Catch::Detail::make_unique<IteratorGenerator<ResultType>>(from, to));
+}
+
+template <typename Container,
+          typename ResultType = typename Container::value_type>
+GeneratorWrapper<ResultType> from_range(Container const& cnt) {
+    return GeneratorWrapper<ResultType>(Catch::Detail::make_unique<IteratorGenerator<ResultType>>(cnt.begin(), cnt.end()));
+}
+
+
+} // namespace Generators
+} // namespace Catch
+
+
+#endif // CATCH_GENERATORS_RANGE_HPP_INCLUDED
+
+#endif // CATCH_GENERATORS_ALL_HPP_INCLUDED
+
+
+/** \file
+ * This is a convenience header for Catch2's interfaces. It includes
+ * **all** of Catch2 headers related to interfaces.
+ *
+ * Generally the Catch2 users should use specific includes they need,
+ * but this header can be used instead for ease-of-experimentation, or
+ * just plain convenience, at the cost of somewhat increased compilation
+ * times.
+ *
+ * When a new header is added to either the `interfaces` folder, or to
+ * the corresponding internal subfolder, it should be added here.
+ */
+
+
+#ifndef CATCH_INTERFACES_ALL_HPP_INCLUDED
+#define CATCH_INTERFACES_ALL_HPP_INCLUDED
+
+
+
+#ifndef CATCH_INTERFACES_REPORTER_FACTORY_HPP_INCLUDED
+#define CATCH_INTERFACES_REPORTER_FACTORY_HPP_INCLUDED
+
+
+#include <string>
+
+namespace Catch {
+
+    struct ReporterConfig;
+    class IConfig;
+    class IEventListener;
+    using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
+
+
+    class IReporterFactory {
+    public:
+        virtual ~IReporterFactory(); // = default
+
+        virtual IEventListenerPtr
+        create( ReporterConfig&& config ) const = 0;
+        virtual std::string getDescription() const = 0;
+    };
+    using IReporterFactoryPtr = Detail::unique_ptr<IReporterFactory>;
+
+    class EventListenerFactory {
+    public:
+        virtual ~EventListenerFactory(); // = default
+        virtual IEventListenerPtr create( IConfig const* config ) const = 0;
+        //! Return a meaningful name for the listener, e.g. its type name
+        virtual StringRef getName() const = 0;
+        //! Return listener's description if available
+        virtual std::string getDescription() const = 0;
+    };
+} // namespace Catch
+
+#endif // CATCH_INTERFACES_REPORTER_FACTORY_HPP_INCLUDED
+
+
+#ifndef CATCH_INTERFACES_REPORTER_REGISTRY_HPP_INCLUDED
+#define CATCH_INTERFACES_REPORTER_REGISTRY_HPP_INCLUDED
+
+
+
+#ifndef CATCH_CASE_INSENSITIVE_COMPARISONS_HPP_INCLUDED
+#define CATCH_CASE_INSENSITIVE_COMPARISONS_HPP_INCLUDED
+
+
+namespace Catch {
+    namespace Detail {
+        //! Provides case-insensitive `op<` semantics when called
+        struct CaseInsensitiveLess {
+            bool operator()( StringRef lhs,
+                             StringRef rhs ) const;
+        };
+
+        //! Provides case-insensitive `op==` semantics when called
+        struct CaseInsensitiveEqualTo {
+            bool operator()( StringRef lhs,
+                             StringRef rhs ) const;
+        };
+
+    } // namespace Detail
+} // namespace Catch
+
+#endif // CATCH_CASE_INSENSITIVE_COMPARISONS_HPP_INCLUDED
+
+#include <string>
+#include <vector>
+#include <map>
+
+namespace Catch {
+
+    class IConfig;
+
+    class IEventListener;
+    using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
+    class IReporterFactory;
+    using IReporterFactoryPtr = Detail::unique_ptr<IReporterFactory>;
+    struct ReporterConfig;
+    class EventListenerFactory;
+
+    class IReporterRegistry {
+    public:
+        using FactoryMap = std::map<std::string, IReporterFactoryPtr, Detail::CaseInsensitiveLess>;
+        using Listeners = std::vector<Detail::unique_ptr<EventListenerFactory>>;
+
+        virtual ~IReporterRegistry(); // = default
+        virtual IEventListenerPtr create( std::string const& name, ReporterConfig&& config ) const = 0;
+        virtual FactoryMap const& getFactories() const = 0;
+        virtual Listeners const& getListeners() const = 0;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_INTERFACES_REPORTER_REGISTRY_HPP_INCLUDED
+
+
+#ifndef CATCH_INTERFACES_TAG_ALIAS_REGISTRY_HPP_INCLUDED
+#define CATCH_INTERFACES_TAG_ALIAS_REGISTRY_HPP_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    struct TagAlias;
+
+    class ITagAliasRegistry {
+    public:
+        virtual ~ITagAliasRegistry(); // = default
+        // 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();
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_INTERFACES_TAG_ALIAS_REGISTRY_HPP_INCLUDED
+
+#endif // CATCH_INTERFACES_ALL_HPP_INCLUDED
+
+
+
+/** \file
+ * Wrapper for ANDROID_LOGWRITE configuration option
+ *
+ * We want to default to enabling it when compiled for android, but
+ * users of the library should also be able to disable it if they want
+ * to.
+ */
+
+#ifndef CATCH_CONFIG_ANDROID_LOGWRITE_HPP_INCLUDED
+#define CATCH_CONFIG_ANDROID_LOGWRITE_HPP_INCLUDED
+
+
+#if defined(__ANDROID__)
+#    define CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE
+#endif
+
+
+#if defined( CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE ) && \
+    !defined( CATCH_CONFIG_NO_ANDROID_LOGWRITE ) &&      \
+    !defined( CATCH_CONFIG_ANDROID_LOGWRITE )
+#    define CATCH_CONFIG_ANDROID_LOGWRITE
+#endif
+
+#endif // CATCH_CONFIG_ANDROID_LOGWRITE_HPP_INCLUDED
+
+
+
+/** \file
+ * Wrapper for UNCAUGHT_EXCEPTIONS configuration option
+ *
+ * For some functionality, Catch2 requires to know whether there is
+ * an active exception. Because `std::uncaught_exception` is deprecated
+ * in C++17, we want to use `std::uncaught_exceptions` if possible.
+ */
+
+#ifndef CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
+#define CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
+
+#if defined(_MSC_VER)
+#  if _MSC_VER >= 1900 // Visual Studio 2015 or newer
+#    define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+#  endif
+#endif
+
+
+#include <exception>
+
+#if defined(__cpp_lib_uncaught_exceptions) \
+    && !defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
+
+#  define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+#endif // __cpp_lib_uncaught_exceptions
+
+
+#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
+
+
+#endif // CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
+
+
+#ifndef CATCH_CONSOLE_WIDTH_HPP_INCLUDED
+#define CATCH_CONSOLE_WIDTH_HPP_INCLUDED
+
+// This include must be kept so that user's configured value for CONSOLE_WIDTH
+// is used before we attempt to provide a default value
+
+#ifndef CATCH_CONFIG_CONSOLE_WIDTH
+#define CATCH_CONFIG_CONSOLE_WIDTH 80
+#endif
+
+#endif // CATCH_CONSOLE_WIDTH_HPP_INCLUDED
+
+
+#ifndef CATCH_CONTAINER_NONMEMBERS_HPP_INCLUDED
+#define CATCH_CONTAINER_NONMEMBERS_HPP_INCLUDED
+
+
+#include <cstddef>
+#include <initializer_list>
+
+// We want a simple polyfill over `std::empty`, `std::size` and so on
+// for C++14 or C++ libraries with incomplete support.
+// We also have to handle that MSVC std lib will happily provide these
+// under older standards.
+#if defined(CATCH_CPP17_OR_GREATER) || defined(_MSC_VER)
+
+// We are already using this header either way, so there shouldn't
+// be much additional overhead in including it to get the feature
+// test macros
+#include <string>
+
+#  if !defined(__cpp_lib_nonmember_container_access)
+#      define CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS
+#  endif
+
+#else
+#define CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS
+#endif
+
+
+
+namespace Catch {
+namespace Detail {
+
+#if defined(CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS)
+    template <typename Container>
+    constexpr auto empty(Container const& cont) -> decltype(cont.empty()) {
+        return cont.empty();
+    }
+    template <typename T, std::size_t N>
+    constexpr bool empty(const T (&)[N]) noexcept {
+        // GCC < 7 does not support the const T(&)[] parameter syntax
+        // so we have to ignore the length explicitly
+        (void)N;
+        return false;
+    }
+    template <typename T>
+    constexpr bool empty(std::initializer_list<T> list) noexcept {
+        return list.size() > 0;
+    }
+
+
+    template <typename Container>
+    constexpr auto size(Container const& cont) -> decltype(cont.size()) {
+        return cont.size();
+    }
+    template <typename T, std::size_t N>
+    constexpr std::size_t size(const T(&)[N]) noexcept {
+        return N;
+    }
+#endif // CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS
+
+} // end namespace Detail
+} // end namespace Catch
+
+
+
+#endif // CATCH_CONTAINER_NONMEMBERS_HPP_INCLUDED
+
+
+#ifndef CATCH_DEBUG_CONSOLE_HPP_INCLUDED
+#define CATCH_DEBUG_CONSOLE_HPP_INCLUDED
+
+#include <string>
+
+namespace Catch {
+    void writeToDebugConsole( std::string const& text );
+}
+
+#endif // CATCH_DEBUG_CONSOLE_HPP_INCLUDED
+
+
+#ifndef CATCH_DEBUGGER_HPP_INCLUDED
+#define CATCH_DEBUGGER_HPP_INCLUDED
+
+
+namespace Catch {
+    bool isDebuggerActive();
+}
+
+#ifdef CATCH_PLATFORM_MAC
+
+    #if defined(__i386__) || defined(__x86_64__)
+        #define CATCH_TRAP() __asm__("int $3\n" : : ) /* NOLINT */
+    #elif defined(__aarch64__)
+        #define CATCH_TRAP()  __asm__(".inst 0xd43e0000")
+    #endif
+
+#elif defined(CATCH_PLATFORM_IPHONE)
+
+    // use inline assembler
+    #if defined(__i386__) || defined(__x86_64__)
+        #define CATCH_TRAP()  __asm__("int $3")
+    #elif defined(__aarch64__)
+        #define CATCH_TRAP()  __asm__(".inst 0xd4200000")
+    #elif defined(__arm__) && !defined(__thumb__)
+        #define CATCH_TRAP()  __asm__(".inst 0xe7f001f0")
+    #elif defined(__arm__) &&  defined(__thumb__)
+        #define CATCH_TRAP()  __asm__(".inst 0xde01")
+    #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>
+
+        #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
+
+#ifndef CATCH_BREAK_INTO_DEBUGGER
+    #ifdef CATCH_TRAP
+        #define CATCH_BREAK_INTO_DEBUGGER() []{ if( Catch::isDebuggerActive() ) { CATCH_TRAP(); } }()
+    #else
+        #define CATCH_BREAK_INTO_DEBUGGER() []{}()
+    #endif
+#endif
+
+#endif // CATCH_DEBUGGER_HPP_INCLUDED
+
+
+#ifndef CATCH_ENFORCE_HPP_INCLUDED
+#define CATCH_ENFORCE_HPP_INCLUDED
+
+
+#include <exception>
+
+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
+
+    [[noreturn]]
+    void throw_logic_error(std::string const& msg);
+    [[noreturn]]
+    void throw_domain_error(std::string const& msg);
+    [[noreturn]]
+    void throw_runtime_error(std::string const& msg);
+
+} // namespace Catch;
+
+#define CATCH_MAKE_MSG(...) \
+    (Catch::ReusableStringStream() << __VA_ARGS__).str()
+
+#define CATCH_INTERNAL_ERROR(...) \
+    Catch::throw_logic_error(CATCH_MAKE_MSG( CATCH_INTERNAL_LINEINFO << ": Internal Catch2 error: " << __VA_ARGS__))
+
+#define CATCH_ERROR(...) \
+    Catch::throw_domain_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
+
+#define CATCH_RUNTIME_ERROR(...) \
+    Catch::throw_runtime_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
+
+#define CATCH_ENFORCE( condition, ... ) \
+    do{ if( !(condition) ) CATCH_ERROR( __VA_ARGS__ ); } while(false)
+
+
+#endif // CATCH_ENFORCE_HPP_INCLUDED
+
+
+#ifndef CATCH_ENUM_VALUES_REGISTRY_HPP_INCLUDED
+#define CATCH_ENUM_VALUES_REGISTRY_HPP_INCLUDED
+
+
+#include <vector>
+
+namespace Catch {
+
+    namespace Detail {
+
+        Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values );
+
+        class EnumValuesRegistry : public IMutableEnumValuesRegistry {
+
+            std::vector<Catch::Detail::unique_ptr<EnumInfo>> m_enumInfos;
+
+            EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values) override;
+        };
+
+        std::vector<StringRef> parseEnums( StringRef enums );
+
+    } // Detail
+
+} // Catch
+
+#endif // CATCH_ENUM_VALUES_REGISTRY_HPP_INCLUDED
+
+
+#ifndef CATCH_ERRNO_GUARD_HPP_INCLUDED
+#define CATCH_ERRNO_GUARD_HPP_INCLUDED
+
+namespace Catch {
+
+    //! Simple RAII class that stores the value of `errno`
+    //! at construction and restores it at destruction.
+    class ErrnoGuard {
+    public:
+        // Keep these outlined to avoid dragging in macros from <cerrno>
+
+        ErrnoGuard();
+        ~ErrnoGuard();
+    private:
+        int m_oldErrno;
+    };
+
+}
+
+#endif // CATCH_ERRNO_GUARD_HPP_INCLUDED
+
+
+#ifndef CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED
+#define CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED
+
+
+#include <vector>
+#include <string>
+
+namespace Catch {
+
+    class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry {
+    public:
+        ~ExceptionTranslatorRegistry() override;
+        void registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator );
+        std::string translateActiveException() const override;
+        std::string tryTranslators() const;
+
+    private:
+        ExceptionTranslators m_translators;
+    };
+}
+
+#endif // CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED
+
+
+#ifndef CATCH_FATAL_CONDITION_HANDLER_HPP_INCLUDED
+#define CATCH_FATAL_CONDITION_HANDLER_HPP_INCLUDED
+
+
+#include <cassert>
+
+namespace Catch {
+
+    /**
+     * Wrapper for platform-specific fatal error (signals/SEH) handlers
+     *
+     * Tries to be cooperative with other handlers, and not step over
+     * other handlers. This means that unknown structured exceptions
+     * are passed on, previous signal handlers are called, and so on.
+     *
+     * Can only be instantiated once, and assumes that once a signal
+     * is caught, the binary will end up terminating. Thus, there
+     */
+    class FatalConditionHandler {
+        bool m_started = false;
+
+        // Install/disengage implementation for specific platform.
+        // Should be if-defed to work on current platform, can assume
+        // engage-disengage 1:1 pairing.
+        void engage_platform();
+        void disengage_platform() noexcept;
+    public:
+        // Should also have platform-specific implementations as needed
+        FatalConditionHandler();
+        ~FatalConditionHandler();
+
+        void engage() {
+            assert(!m_started && "Handler cannot be installed twice.");
+            m_started = true;
+            engage_platform();
+        }
+
+        void disengage() noexcept {
+            assert(m_started && "Handler cannot be uninstalled without being installed first");
+            m_started = false;
+            disengage_platform();
+        }
+    };
+
+    //! Simple RAII guard for (dis)engaging the FatalConditionHandler
+    class FatalConditionHandlerGuard {
+        FatalConditionHandler* m_handler;
+    public:
+        FatalConditionHandlerGuard(FatalConditionHandler* handler):
+            m_handler(handler) {
+            m_handler->engage();
+        }
+        ~FatalConditionHandlerGuard() {
+            m_handler->disengage();
+        }
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_FATAL_CONDITION_HANDLER_HPP_INCLUDED
+
+
+#ifndef CATCH_FLOATING_POINT_HELPERS_HPP_INCLUDED
+#define CATCH_FLOATING_POINT_HELPERS_HPP_INCLUDED
+
+
+
+#ifndef CATCH_POLYFILLS_HPP_INCLUDED
+#define CATCH_POLYFILLS_HPP_INCLUDED
+
+namespace Catch {
+    bool isnan(float f);
+    bool isnan(double d);
+}
+
+#endif // CATCH_POLYFILLS_HPP_INCLUDED
+
+#include <cassert>
+#include <cmath>
+#include <cstdint>
+#include <utility>
+#include <limits>
+
+namespace Catch {
+    namespace Detail {
+
+        uint32_t convertToBits(float f);
+        uint64_t convertToBits(double d);
+
+    } // end namespace Detail
+
+
+
+#if defined( __GNUC__ ) || defined( __clang__ )
+#    pragma GCC diagnostic push
+    // We do a bunch of direct compensations of floating point numbers,
+    // because we know what we are doing and actually do want the direct
+    // comparison behaviour.
+#    pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+
+    /**
+     * Calculates the ULP distance between two floating point numbers
+     *
+     * The ULP distance of two floating point numbers is the count of
+     * valid floating point numbers representable between them.
+     *
+     * There are some exceptions between how this function counts the
+     * distance, and the interpretation of the standard as implemented.
+     * by e.g. `nextafter`. For this function it always holds that:
+     * * `(x == y) => ulpDistance(x, y) == 0` (so `ulpDistance(-0, 0) == 0`)
+     * * `ulpDistance(maxFinite, INF) == 1`
+     * * `ulpDistance(x, -x) == 2 * ulpDistance(x, 0)`
+     *
+     * \pre `!isnan( lhs )`
+     * \pre `!isnan( rhs )`
+     * \pre floating point numbers are represented in IEEE-754 format
+     */
+    template <typename FP>
+    uint64_t ulpDistance( FP lhs, FP rhs ) {
+        assert( std::numeric_limits<FP>::is_iec559 &&
+            "ulpDistance assumes IEEE-754 format for floating point types" );
+        assert( !Catch::isnan( lhs ) &&
+                "Distance between NaN and number is not meaningful" );
+        assert( !Catch::isnan( rhs ) &&
+                "Distance between NaN and number is not meaningful" );
+
+        // We want X == Y to imply 0 ULP distance even if X and Y aren't
+        // bit-equal (-0 and 0), or X - Y != 0 (same sign infinities).
+        if ( lhs == rhs ) { return 0; }
+
+        // We need a properly typed positive zero for type inference.
+        static constexpr FP positive_zero{};
+
+        // We want to ensure that +/- 0 is always represented as positive zero
+        if ( lhs == positive_zero ) { lhs = positive_zero; }
+        if ( rhs == positive_zero ) { rhs = positive_zero; }
+
+        // If arguments have different signs, we can handle them by summing
+        // how far are they from 0 each.
+        if ( std::signbit( lhs ) != std::signbit( rhs ) ) {
+            return ulpDistance( std::abs( lhs ), positive_zero ) +
+                   ulpDistance( std::abs( rhs ), positive_zero );
+        }
+
+        // When both lhs and rhs are of the same sign, we can just
+        // read the numbers bitwise as integers, and then subtract them
+        // (assuming IEEE).
+        uint64_t lc = Detail::convertToBits( lhs );
+        uint64_t rc = Detail::convertToBits( rhs );
+
+        // The ulp distance between two numbers is symmetric, so to avoid
+        // dealing with overflows we want the bigger converted number on the lhs
+        if ( lc < rc ) {
+            std::swap( lc, rc );
+        }
+
+        return lc - rc;
+    }
+
+#if defined( __GNUC__ ) || defined( __clang__ )
+#    pragma GCC diagnostic pop
+#endif
+
+
+} // end namespace Catch
+
+#endif // CATCH_FLOATING_POINT_HELPERS_HPP_INCLUDED
+
+
+#ifndef CATCH_ISTREAM_HPP_INCLUDED
+#define CATCH_ISTREAM_HPP_INCLUDED
+
+
+#include <iosfwd>
+#include <cstddef>
+#include <ostream>
+#include <string>
+
+namespace Catch {
+
+    class IStream {
+    public:
+        virtual ~IStream(); // = default
+        virtual std::ostream& stream() = 0;
+        /**
+         * Best guess on whether the instance is writing to a console (e.g. via stdout/stderr)
+         *
+         * This is useful for e.g. Win32 colour support, because the Win32
+         * API manipulates console directly, unlike POSIX escape codes,
+         * that can be written anywhere.
+         *
+         * Due to variety of ways to change where the stdout/stderr is
+         * _actually_ being written, users should always assume that
+         * the answer might be wrong.
+         */
+        virtual bool isConsole() const { return false; }
+    };
+
+    /**
+     * Creates a stream wrapper that writes to specific file.
+     *
+     * Also recognizes 4 special filenames
+     * * `-` for stdout
+     * * `%stdout` for stdout
+     * * `%stderr` for stderr
+     * * `%debug` for platform specific debugging output
+     *
+     * \throws if passed an unrecognized %-prefixed stream
+     */
+    auto makeStream( std::string const& filename ) -> Detail::unique_ptr<IStream>;
+
+}
+
+#endif // CATCH_STREAM_HPP_INCLUDED
+
+
+#ifndef CATCH_LEAK_DETECTOR_HPP_INCLUDED
+#define CATCH_LEAK_DETECTOR_HPP_INCLUDED
+
+namespace Catch {
+
+    struct LeakDetector {
+        LeakDetector();
+        ~LeakDetector();
+    };
+
+}
+#endif // CATCH_LEAK_DETECTOR_HPP_INCLUDED
+
+
+#ifndef CATCH_LIST_HPP_INCLUDED
+#define CATCH_LIST_HPP_INCLUDED
+
+
+#include <set>
+#include <string>
+
+
+namespace Catch {
+
+    class IEventListener;
+    class Config;
+
+
+    struct ReporterDescription {
+        std::string name, description;
+    };
+    struct ListenerDescription {
+        StringRef name;
+        std::string description;
+    };
+
+    struct TagInfo {
+        void add(StringRef spelling);
+        std::string all() const;
+
+        std::set<StringRef> spellings;
+        std::size_t count = 0;
+    };
+
+    bool list( IEventListener& reporter, Config const& config );
+
+} // end namespace Catch
+
+#endif // CATCH_LIST_HPP_INCLUDED
+
+
+#ifndef CATCH_OUTPUT_REDIRECT_HPP_INCLUDED
+#define CATCH_OUTPUT_REDIRECT_HPP_INCLUDED
+
+
+#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;
+    };
+
+    class RedirectedStreams {
+    public:
+        RedirectedStreams(RedirectedStreams const&) = delete;
+        RedirectedStreams& operator=(RedirectedStreams const&) = delete;
+        RedirectedStreams(RedirectedStreams&&) = delete;
+        RedirectedStreams& operator=(RedirectedStreams&&) = delete;
+
+        RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr);
+        ~RedirectedStreams();
+    private:
+        std::string& m_redirectedCout;
+        std::string& m_redirectedCerr;
+        RedirectedStdOut m_redirectedStdOut;
+        RedirectedStdErr m_redirectedStdErr;
+    };
+
+#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 // CATCH_OUTPUT_REDIRECT_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_REGISTRY_HPP_INCLUDED
+#define CATCH_REPORTER_REGISTRY_HPP_INCLUDED
+
+
+#include <map>
+
+namespace Catch {
+
+    class ReporterRegistry : public IReporterRegistry {
+    public:
+
+        ReporterRegistry();
+        ~ReporterRegistry() override; // = default, out of line to allow fwd decl
+
+        IEventListenerPtr create( std::string const& name, ReporterConfig&& config ) const override;
+
+        void registerReporter( std::string const& name, IReporterFactoryPtr factory );
+        void registerListener( Detail::unique_ptr<EventListenerFactory> factory );
+
+        FactoryMap const& getFactories() const override;
+        Listeners const& getListeners() const override;
+
+    private:
+        FactoryMap m_factories;
+        Listeners m_listeners;
+    };
+}
+
+#endif // CATCH_REPORTER_REGISTRY_HPP_INCLUDED
+
+
+#ifndef CATCH_RUN_CONTEXT_HPP_INCLUDED
+#define CATCH_RUN_CONTEXT_HPP_INCLUDED
+
+
+
+#ifndef CATCH_TEST_CASE_TRACKER_HPP_INCLUDED
+#define CATCH_TEST_CASE_TRACKER_HPP_INCLUDED
+
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+namespace TestCaseTracking {
+
+    struct NameAndLocation {
+        std::string name;
+        SourceLineInfo location;
+
+        NameAndLocation( std::string const& _name, SourceLineInfo const& _location );
+        friend bool operator==(NameAndLocation const& lhs, NameAndLocation const& rhs) {
+            return lhs.name == rhs.name
+                && lhs.location == rhs.location;
+        }
+    };
+
+    class ITracker;
+
+    using ITrackerPtr = Catch::Detail::unique_ptr<ITracker>;
+
+    class ITracker {
+        NameAndLocation m_nameAndLocation;
+
+        using Children = std::vector<ITrackerPtr>;
+
+    protected:
+        enum CycleState {
+            NotStarted,
+            Executing,
+            ExecutingChildren,
+            NeedsAnotherRun,
+            CompletedSuccessfully,
+            Failed
+        };
+
+        ITracker* m_parent = nullptr;
+        Children m_children;
+        CycleState m_runState = NotStarted;
+
+    public:
+        ITracker( NameAndLocation const& nameAndLoc, ITracker* parent ):
+            m_nameAndLocation( nameAndLoc ),
+            m_parent( parent )
+        {}
+
+
+        // static queries
+        NameAndLocation const& nameAndLocation() const {
+            return m_nameAndLocation;
+        }
+        ITracker* parent() const {
+            return m_parent;
+        }
+
+        virtual ~ITracker(); // = default
+
+
+        // dynamic queries
+
+        //! Returns true if tracker run to completion (successfully or not)
+        virtual bool isComplete() const = 0;
+        //! Returns true if tracker run to completion succesfully
+        bool isSuccessfullyCompleted() const;
+        //! Returns true if tracker has started but hasn't been completed
+        bool isOpen() const;
+        //! Returns true iff tracker has started
+        bool hasStarted() const;
+
+        // actions
+        virtual void close() = 0; // Successfully complete
+        virtual void fail() = 0;
+        void markAsNeedingAnotherRun();
+
+        //! Register a nested ITracker
+        void addChild( ITrackerPtr&& child );
+        /**
+         * Returns ptr to specific child if register with this tracker.
+         *
+         * Returns nullptr if not found.
+         */
+        ITracker* findChild( NameAndLocation const& nameAndLocation );
+        //! Have any children been added?
+        bool hasChildren() const {
+            return !m_children.empty();
+        }
+
+
+        //! Marks tracker as executing a child, doing se recursively up the tree
+        void openChild();
+
+        /**
+         * Returns true if the instance is a section tracker
+         *
+         * Subclasses should override to true if they are, replaces RTTI
+         * for internal debug checks.
+         */
+        virtual bool isSectionTracker() const;
+        /**
+         * Returns true if the instance is a generator tracker
+         *
+         * Subclasses should override to true if they are, replaces RTTI
+         * for internal debug checks.
+         */
+        virtual bool isGeneratorTracker() const;
+    };
+
+    class TrackerContext {
+
+        enum RunState {
+            NotStarted,
+            Executing,
+            CompletedCycle
+        };
+
+        ITrackerPtr m_rootTracker;
+        ITracker* m_currentTracker = nullptr;
+        RunState m_runState = NotStarted;
+
+    public:
+
+        ITracker& startRun();
+        void endRun();
+
+        void startCycle();
+        void completeCycle();
+
+        bool completedCycle() const;
+        ITracker& currentTracker();
+        void setCurrentTracker( ITracker* tracker );
+    };
+
+    class TrackerBase : public ITracker {
+    protected:
+
+        TrackerContext& m_ctx;
+
+    public:
+        TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
+
+        bool isComplete() const override;
+
+        void open();
+
+        void close() override;
+        void fail() override;
+
+    private:
+        void moveToParent();
+        void moveToThis();
+    };
+
+    class SectionTracker : public TrackerBase {
+        std::vector<StringRef> m_filters;
+        std::string m_trimmed_name;
+    public:
+        SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
+
+        bool isSectionTracker() const override;
+
+        bool isComplete() const override;
+
+        static SectionTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation );
+
+        void tryOpen();
+
+        void addInitialFilters( std::vector<std::string> const& filters );
+        void addNextFilters( std::vector<StringRef> const& filters );
+        //! Returns filters active in this tracker
+        std::vector<StringRef> const& getFilters() const;
+        //! Returns whitespace-trimmed name of the tracked section
+        StringRef trimmedName() const;
+    };
+
+} // namespace TestCaseTracking
+
+using TestCaseTracking::ITracker;
+using TestCaseTracking::TrackerContext;
+using TestCaseTracking::SectionTracker;
+
+} // namespace Catch
+
+#endif // CATCH_TEST_CASE_TRACKER_HPP_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    class IMutableContext;
+    class IGeneratorTracker;
+    class IConfig;
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    class RunContext : public IResultCapture {
+
+    public:
+        RunContext( RunContext const& ) = delete;
+        RunContext& operator =( RunContext const& ) = delete;
+
+        explicit RunContext( IConfig const* _config, IEventListenerPtr&& reporter );
+
+        ~RunContext() override;
+
+        Totals runTest(TestCaseHandle const& testCase);
+
+    public: // IResultCapture
+
+        // Assertion handlers
+        void handleExpr
+                (   AssertionInfo const& info,
+                    ITransientExpression const& expr,
+                    AssertionReaction& reaction ) override;
+        void handleMessage
+                (   AssertionInfo const& info,
+                    ResultWas::OfType resultType,
+                    StringRef 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;
+
+        bool sectionStarted( SectionInfo const& sectionInfo, Counts& assertions ) override;
+
+        void sectionEnded( SectionEndInfo const& endInfo ) override;
+        void sectionEndedEarly( SectionEndInfo const& endInfo ) override;
+
+        auto acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker& override;
+
+        void benchmarkPreparing( StringRef name ) override;
+        void benchmarkStarting( BenchmarkInfo const& info ) override;
+        void benchmarkEnded( BenchmarkStats<> const& stats ) override;
+        void benchmarkFailed( StringRef error ) override;
+
+        void pushScopedMessage( MessageInfo const& message ) override;
+        void popScopedMessage( MessageInfo const& message ) override;
+
+        void emplaceUnscopedMessage( MessageBuilder const& builder ) override;
+
+        std::string getCurrentTestName() const override;
+
+        const AssertionResult* getLastResult() const override;
+
+        void exceptionEarlyReported() override;
+
+        void handleFatalErrorCondition( StringRef message ) override;
+
+        bool lastAssertionPassed() override;
+
+        void assertionPassed() override;
+
+    public:
+        // !TBD We need to do this another way!
+        bool aborting() const;
+
+    private:
+
+        void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr );
+        void invokeActiveTestCase();
+
+        void resetAssertionInfo();
+        bool testForMissingAssertions( Counts& assertions );
+
+        void assertionEnded( AssertionResult const& result );
+        void reportExpr
+                (   AssertionInfo const &info,
+                    ResultWas::OfType resultType,
+                    ITransientExpression const *expr,
+                    bool negated );
+
+        void populateReaction( AssertionReaction& reaction );
+
+    private:
+
+        void handleUnfinishedSections();
+
+        TestRunInfo m_runInfo;
+        IMutableContext& m_context;
+        TestCaseHandle const* m_activeTestCase = nullptr;
+        ITracker* m_testCaseTracker = nullptr;
+        Optional<AssertionResult> m_lastResult;
+
+        IConfig const* m_config;
+        Totals m_totals;
+        IEventListenerPtr m_reporter;
+        std::vector<MessageInfo> m_messages;
+        std::vector<ScopedMessage> m_messageScopes; /* Keeps owners of so-called unscoped messages. */
+        AssertionInfo m_lastAssertionInfo;
+        std::vector<SectionEndInfo> m_unfinishedSections;
+        std::vector<ITracker*> m_activeSections;
+        TrackerContext m_trackerContext;
+        FatalConditionHandler m_fatalConditionhandler;
+        bool m_lastAssertionPassed = false;
+        bool m_shouldReportUnexpected = true;
+        bool m_includeSuccessfulResults;
+    };
+
+    void seedRng(IConfig const& config);
+    unsigned int rngSeed();
+} // end namespace Catch
+
+#endif // CATCH_RUN_CONTEXT_HPP_INCLUDED
+
+
+#ifndef CATCH_SHARDING_HPP_INCLUDED
+#define CATCH_SHARDING_HPP_INCLUDED
+
+
+#include <cmath>
+#include <algorithm>
+
+namespace Catch {
+
+    template<typename Container>
+    Container createShard(Container const& container, std::size_t const shardCount, std::size_t const shardIndex) {
+        assert(shardCount > shardIndex);
+
+        if (shardCount == 1) {
+            return container;
+        }
+
+        const std::size_t totalTestCount = container.size();
+
+        const std::size_t shardSize = totalTestCount / shardCount;
+        const std::size_t leftoverTests = totalTestCount % shardCount;
+
+        const std::size_t startIndex = shardIndex * shardSize + (std::min)(shardIndex, leftoverTests);
+        const std::size_t endIndex = (shardIndex + 1) * shardSize + (std::min)(shardIndex + 1, leftoverTests);
+
+        auto startIterator = std::next(container.begin(), static_cast<std::ptrdiff_t>(startIndex));
+        auto endIterator = std::next(container.begin(), static_cast<std::ptrdiff_t>(endIndex));
+
+        return Container(startIterator, endIterator);
+    }
+
+}
+
+#endif // CATCH_SHARDING_HPP_INCLUDED
+
+
+#ifndef CATCH_SINGLETONS_HPP_INCLUDED
+#define CATCH_SINGLETONS_HPP_INCLUDED
+
+namespace Catch {
+
+    struct ISingleton {
+        virtual ~ISingleton(); // = default
+    };
+
+
+    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
+
+#endif // CATCH_SINGLETONS_HPP_INCLUDED
+
+
+#ifndef CATCH_STARTUP_EXCEPTION_REGISTRY_HPP_INCLUDED
+#define CATCH_STARTUP_EXCEPTION_REGISTRY_HPP_INCLUDED
+
+
+#include <vector>
+#include <exception>
+
+namespace Catch {
+
+    class StartupExceptionRegistry {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+    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;
+#endif
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_STARTUP_EXCEPTION_REGISTRY_HPP_INCLUDED
+
+
+
+#ifndef CATCH_STDSTREAMS_HPP_INCLUDED
+#define CATCH_STDSTREAMS_HPP_INCLUDED
+
+#include <iosfwd>
+
+namespace Catch {
+
+    std::ostream& cout();
+    std::ostream& cerr();
+    std::ostream& clog();
+
+} // namespace Catch
+
+#endif
+
+
+#ifndef CATCH_STRING_MANIP_HPP_INCLUDED
+#define CATCH_STRING_MANIP_HPP_INCLUDED
+
+
+#include <string>
+#include <iosfwd>
+#include <vector>
+
+namespace Catch {
+
+    bool startsWith( std::string const& s, std::string const& prefix );
+    bool startsWith( StringRef 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 );
+    char toLower( char c );
+    //! Returns a new string without whitespace at the start/end
+    std::string trim( std::string const& str );
+    //! Returns a substring of the original ref without whitespace. Beware lifetimes!
+    StringRef trim(StringRef ref);
+
+    // !!! Be aware, returns refs into original string - make sure original string outlives them
+    std::vector<StringRef> splitStringRef( StringRef str, char delimiter );
+    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );
+
+    /**
+     * Helper for streaming a "count [maybe-plural-of-label]" human-friendly string
+     *
+     * Usage example:
+     * ```cpp
+     * std::cout << "Found " << pluralise(count, "error") << '\n';
+     * ```
+     *
+     * **Important:** The provided string must outlive the instance
+     */
+    class pluralise {
+        std::uint64_t m_count;
+        StringRef m_label;
+
+    public:
+        constexpr pluralise(std::uint64_t count, StringRef label):
+            m_count(count),
+            m_label(label)
+        {}
+
+        friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser );
+    };
+}
+
+#endif // CATCH_STRING_MANIP_HPP_INCLUDED
+
+
+#ifndef CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED
+#define CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED
+
+
+#include <map>
+#include <string>
+
+namespace Catch {
+    struct SourceLineInfo;
+
+    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
+
+#endif // CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED
+
+
+#ifndef CATCH_TEST_CASE_INFO_HASHER_HPP_INCLUDED
+#define CATCH_TEST_CASE_INFO_HASHER_HPP_INCLUDED
+
+#include <cstdint>
+
+namespace Catch {
+
+    struct TestCaseInfo;
+
+    class TestCaseInfoHasher {
+    public:
+        using hash_t = std::uint64_t;
+        TestCaseInfoHasher( hash_t seed );
+        uint32_t operator()( TestCaseInfo const& t ) const;
+
+    private:
+        hash_t m_seed;
+    };
+
+} // namespace Catch
+
+#endif /* CATCH_TEST_CASE_INFO_HASHER_HPP_INCLUDED */
+
+
+#ifndef CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
+#define CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
+
+
+#include <vector>
+
+namespace Catch {
+
+    class TestCaseHandle;
+    class IConfig;
+    class TestSpec;
+
+    std::vector<TestCaseHandle> sortTests( IConfig const& config, std::vector<TestCaseHandle> const& unsortedTestCases );
+
+    bool isThrowSafe( TestCaseHandle const& testCase, IConfig const& config );
+    bool matchTest( TestCaseHandle const& testCase, TestSpec const& testSpec, IConfig const& config );
+
+    void enforceNoDuplicateTestCases( std::vector<TestCaseHandle> const& functions );
+
+    std::vector<TestCaseHandle> filterTests( std::vector<TestCaseHandle> const& testCases, TestSpec const& testSpec, IConfig const& config );
+    std::vector<TestCaseHandle> const& getAllTestCasesSorted( IConfig const& config );
+
+    class TestRegistry : public ITestCaseRegistry {
+    public:
+        ~TestRegistry() override = default;
+
+        void registerTest( Detail::unique_ptr<TestCaseInfo> testInfo, Detail::unique_ptr<ITestInvoker> testInvoker );
+
+        std::vector<TestCaseInfo*> const& getAllInfos() const override;
+        std::vector<TestCaseHandle> const& getAllTests() const override;
+        std::vector<TestCaseHandle> const& getAllTestsSorted( IConfig const& config ) const override;
+
+    private:
+        std::vector<Detail::unique_ptr<TestCaseInfo>> m_owned_test_infos;
+        // Keeps a materialized vector for `getAllInfos`.
+        // We should get rid of that eventually (see interface note)
+        std::vector<TestCaseInfo*> m_viewed_test_infos;
+
+        std::vector<Detail::unique_ptr<ITestInvoker>> m_invokers;
+        std::vector<TestCaseHandle> m_handles;
+        mutable TestRunOrder m_currentSortOrder = TestRunOrder::Declared;
+        mutable std::vector<TestCaseHandle> m_sortedFunctions;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    class TestInvokerAsFunction final : public ITestInvoker {
+        using TestType = void(*)();
+        TestType m_testAsFunction;
+    public:
+        TestInvokerAsFunction(TestType testAsFunction) noexcept:
+            m_testAsFunction(testAsFunction) {}
+
+        void invoke() const override;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+
+
+} // end namespace Catch
+
+
+#endif // CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
+
+
+#ifndef CATCH_TEST_SPEC_PARSER_HPP_INCLUDED
+#define CATCH_TEST_SPEC_PARSER_HPP_INCLUDED
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+
+#include <vector>
+#include <string>
+
+namespace Catch {
+
+    class ITagAliasRegistry;
+
+    class TestSpecParser {
+        enum Mode{ None, Name, QuotedName, Tag, EscapedName };
+        Mode m_mode = None;
+        Mode lastMode = None;
+        bool m_exclusion = false;
+        std::size_t m_pos = 0;
+        std::size_t m_realPatternPos = 0;
+        std::string m_arg;
+        std::string m_substring;
+        std::string m_patternName;
+        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:
+        bool visitChar( char c );
+        void startNewMode( Mode mode );
+        bool processNoneChar( char c );
+        void processNameChar( char c );
+        bool processOtherChar( char c );
+        void endMode();
+        void escape();
+        bool isControlChar( char c ) const;
+        void saveLastMode();
+        void revertBackToLastMode();
+        void addFilter();
+        bool separate();
+
+        // Handles common preprocessing of the pattern for name/tag patterns
+        std::string preprocessPattern();
+        // Adds the current pattern as a test name
+        void addNamePattern();
+        // Adds the current pattern as a tag
+        void addTagPattern();
+
+        inline void addCharToPattern(char c) {
+            m_substring += c;
+            m_patternName += c;
+            m_realPatternPos++;
+        }
+
+    };
+    TestSpec parseTestSpec( std::string const& arg );
+
+} // namespace Catch
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#endif // CATCH_TEST_SPEC_PARSER_HPP_INCLUDED
+
+
+#ifndef CATCH_TEXTFLOW_HPP_INCLUDED
+#define CATCH_TEXTFLOW_HPP_INCLUDED
+
+#include <cassert>
+#include <string>
+#include <vector>
+
+namespace Catch {
+    namespace TextFlow {
+
+        class Columns;
+
+        /**
+         * Represents a column of text with specific width and indentation
+         *
+         * When written out to a stream, it will perform linebreaking
+         * of the provided text so that the written lines fit within
+         * target width.
+         */
+        class Column {
+            // String to be written out
+            std::string m_string;
+            // Width of the column for linebreaking
+            size_t m_width = CATCH_CONFIG_CONSOLE_WIDTH - 1;
+            // Indentation of other lines (including first if initial indent is unset)
+            size_t m_indent = 0;
+            // Indentation of the first line
+            size_t m_initialIndent = std::string::npos;
+
+        public:
+            /**
+             * Iterates "lines" in `Column` and return sthem
+             */
+            class const_iterator {
+                friend Column;
+                struct EndTag {};
+
+                Column const& m_column;
+                // Where does the current line start?
+                size_t m_lineStart = 0;
+                // How long should the current line be?
+                size_t m_lineLength = 0;
+                // How far have we checked the string to iterate?
+                size_t m_parsedTo = 0;
+                // Should a '-' be appended to the line?
+                bool m_addHyphen = false;
+
+                const_iterator( Column const& column, EndTag ):
+                    m_column( column ), m_lineStart( m_column.m_string.size() ) {}
+
+                // Calculates the length of the current line
+                void calcLength();
+
+                // Returns current indention width
+                size_t indentSize() const;
+
+                // Creates an indented and (optionally) suffixed string from
+                // current iterator position, indentation and length.
+                std::string addIndentAndSuffix( size_t position,
+                                                size_t length ) const;
+
+            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 const_iterator( Column const& column );
+
+                std::string operator*() const;
+
+                const_iterator& operator++();
+                const_iterator operator++( int );
+
+                bool operator==( const_iterator const& other ) const {
+                    return m_lineStart == other.m_lineStart && &m_column == &other.m_column;
+                }
+                bool operator!=( const_iterator const& other ) const {
+                    return !operator==( other );
+                }
+            };
+            using iterator = const_iterator;
+
+            explicit Column( std::string const& text ): m_string( text ) {}
+
+            Column& width( size_t newWidth ) {
+                assert( newWidth > 0 );
+                m_width = newWidth;
+                return *this;
+            }
+            Column& indent( size_t newIndent ) {
+                m_indent = newIndent;
+                return *this;
+            }
+            Column& initialIndent( size_t newIndent ) {
+                m_initialIndent = newIndent;
+                return *this;
+            }
+
+            size_t width() const { return m_width; }
+            const_iterator begin() const { return const_iterator( *this ); }
+            const_iterator end() const { return { *this, const_iterator::EndTag{} }; }
+
+            friend std::ostream& operator<<( std::ostream& os,
+                                             Column const& col );
+
+            Columns operator+( Column const& other );
+        };
+
+        //! Creates a column that serves as an empty space of specific width
+        Column Spacer( size_t spaceWidth );
+
+        class Columns {
+            std::vector<Column> m_columns;
+
+        public:
+            class iterator {
+                friend Columns;
+                struct EndTag {};
+
+                std::vector<Column> const& m_columns;
+                std::vector<Column::const_iterator> m_iterators;
+                size_t m_activeIterators;
+
+                iterator( Columns const& columns, EndTag );
+
+            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 );
+
+                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;
+                }
+                std::string operator*() const;
+                iterator& operator++();
+                iterator operator++( int );
+            };
+            using const_iterator = iterator;
+
+            iterator begin() const { return iterator( *this ); }
+            iterator end() const { return { *this, iterator::EndTag() }; }
+
+            Columns& operator+=( Column const& col );
+            Columns operator+( Column const& col );
+
+            friend std::ostream& operator<<( std::ostream& os,
+                                             Columns const& cols );
+        };
+
+    } // namespace TextFlow
+} // namespace Catch
+#endif // CATCH_TEXTFLOW_HPP_INCLUDED
+
+
+#ifndef CATCH_TO_STRING_HPP_INCLUDED
+#define CATCH_TO_STRING_HPP_INCLUDED
+
+#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
+
+#endif // CATCH_TO_STRING_HPP_INCLUDED
+
+
+#ifndef CATCH_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
+#define CATCH_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
+
+namespace Catch {
+    bool uncaught_exceptions();
+} // end namespace Catch
+
+#endif // CATCH_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
+
+
+#ifndef CATCH_XMLWRITER_HPP_INCLUDED
+#define CATCH_XMLWRITER_HPP_INCLUDED
+
+
+#include <iosfwd>
+#include <vector>
+
+namespace Catch {
+    enum class XmlFormatting {
+        None = 0x00,
+        Indent = 0x01,
+        Newline = 0x02,
+    };
+
+    XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs);
+    XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs);
+
+    /**
+     * Helper for XML-encoding text (escaping angle brackets, quotes, etc)
+     *
+     * Note: doesn't take ownership of passed strings, and thus the
+     *       encoded string must outlive the encoding instance.
+     */
+    class XmlEncode {
+    public:
+        enum ForWhat { ForTextNodes, ForAttributes };
+
+        XmlEncode( StringRef str, ForWhat forWhat = ForTextNodes );
+
+        void encodeTo( std::ostream& os ) const;
+
+        friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode );
+
+    private:
+        StringRef m_str;
+        ForWhat m_forWhat;
+    };
+
+    class XmlWriter {
+    public:
+
+        class ScopedElement {
+        public:
+            ScopedElement( XmlWriter* writer, XmlFormatting fmt );
+
+            ScopedElement( ScopedElement&& other ) noexcept;
+            ScopedElement& operator=( ScopedElement&& other ) noexcept;
+
+            ~ScopedElement();
+
+            ScopedElement&
+            writeText( StringRef text,
+                       XmlFormatting fmt = XmlFormatting::Newline |
+                                           XmlFormatting::Indent );
+
+            ScopedElement& writeAttribute( StringRef name,
+                                           StringRef attribute );
+            template <typename T,
+                      // Without this SFINAE, this overload is a better match
+                      // for `std::string`, `char const*`, `char const[N]` args.
+                      // While it would still work, it would cause code bloat
+                      // and multiple iteration over the strings
+                      typename = typename std::enable_if_t<
+                          !std::is_convertible<T, StringRef>::value>>
+            ScopedElement& writeAttribute( StringRef name,
+                                           T const& attribute ) {
+                m_writer->writeAttribute( name, attribute );
+                return *this;
+            }
+
+        private:
+            XmlWriter* m_writer = nullptr;
+            XmlFormatting m_fmt;
+        };
+
+        XmlWriter( std::ostream& os );
+        ~XmlWriter();
+
+        XmlWriter( XmlWriter const& ) = delete;
+        XmlWriter& operator=( XmlWriter const& ) = delete;
+
+        XmlWriter& startElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+        ScopedElement scopedElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+        XmlWriter& endElement(XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+        //! The attribute content is XML-encoded
+        XmlWriter& writeAttribute( StringRef name, StringRef attribute );
+
+        //! Writes the attribute as "true/false"
+        XmlWriter& writeAttribute( StringRef name, bool attribute );
+
+        //! The attribute content is XML-encoded
+        XmlWriter& writeAttribute( StringRef name, char const* attribute );
+
+        //! The attribute value must provide op<<(ostream&, T). The resulting
+        //! serialization is XML-encoded
+        template <typename T,
+                  // Without this SFINAE, this overload is a better match
+                  // for `std::string`, `char const*`, `char const[N]` args.
+                  // While it would still work, it would cause code bloat
+                  // and multiple iteration over the strings
+                  typename = typename std::enable_if_t<
+                      !std::is_convertible<T, StringRef>::value>>
+        XmlWriter& writeAttribute( StringRef name, T const& attribute ) {
+            ReusableStringStream rss;
+            rss << attribute;
+            return writeAttribute( name, rss.str() );
+        }
+
+        //! Writes escaped `text` in a element
+        XmlWriter& writeText( StringRef text,
+                              XmlFormatting fmt = XmlFormatting::Newline |
+                                                  XmlFormatting::Indent );
+
+        //! Writes XML comment as "<!-- text -->"
+        XmlWriter& writeComment( StringRef text,
+                                 XmlFormatting fmt = XmlFormatting::Newline |
+                                                     XmlFormatting::Indent );
+
+        void writeStylesheetRef( StringRef url );
+
+        void ensureTagClosed();
+
+    private:
+
+        void applyFormatting(XmlFormatting fmt);
+
+        void writeDeclaration();
+
+        void newlineIfNecessary();
+
+        bool m_tagIsOpen = false;
+        bool m_needsNewline = false;
+        std::vector<std::string> m_tags;
+        std::string m_indent;
+        std::ostream& m_os;
+    };
+
+}
+
+#endif // CATCH_XMLWRITER_HPP_INCLUDED
+
+
+/** \file
+ * This is a convenience header for Catch2's Matcher support. It includes
+ * **all** of Catch2 headers related to matchers.
+ *
+ * Generally the Catch2 users should use specific includes they need,
+ * but this header can be used instead for ease-of-experimentation, or
+ * just plain convenience, at the cost of increased compilation times.
+ *
+ * When a new header is added to either the `matchers` folder, or to
+ * the corresponding internal subfolder, it should be added here.
+ */
+
+#ifndef CATCH_MATCHERS_ALL_HPP_INCLUDED
+#define CATCH_MATCHERS_ALL_HPP_INCLUDED
+
+
+
+#ifndef CATCH_MATCHERS_HPP_INCLUDED
+#define CATCH_MATCHERS_HPP_INCLUDED
+
+
+
+#ifndef CATCH_MATCHERS_IMPL_HPP_INCLUDED
+#define CATCH_MATCHERS_IMPL_HPP_INCLUDED
+
+
+namespace Catch {
+
+    template<typename ArgT, typename MatcherT>
+    class MatchExpr : public ITransientExpression {
+        ArgT && m_arg;
+        MatcherT const& m_matcher;
+        StringRef m_matcherString;
+    public:
+        MatchExpr( ArgT && arg, MatcherT const& matcher, StringRef matcherString )
+        :   ITransientExpression{ true, matcher.match( arg ) }, // not forwarding arg here on purpose
+            m_arg( CATCH_FORWARD(arg) ),
+            m_matcher( matcher ),
+            m_matcherString( matcherString )
+        {}
+
+        void streamReconstructedExpression( std::ostream& os ) const override {
+            os << Catch::Detail::stringify( m_arg )
+               << ' '
+               << m_matcher.toString();
+        }
+    };
+
+    namespace Matchers {
+        template <typename ArgT>
+        class MatcherBase;
+    }
+
+    using StringMatcher = Matchers::MatcherBase<std::string>;
+
+    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef matcherString  );
+
+    template<typename ArgT, typename MatcherT>
+    auto makeMatchExpr( ArgT && arg, MatcherT const& matcher, StringRef matcherString  ) -> MatchExpr<ArgT, MatcherT> {
+        return MatchExpr<ArgT, MatcherT>( CATCH_FORWARD(arg), matcher, matcherString );
+    }
+
+} // namespace Catch
+
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
+    do { \
+        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( false )
+
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS_MATCHES( macroName, exceptionType, resultDisposition, matcher, ... ) \
+    do { \
+        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.handleUnexpectedExceptionNotThrown(); \
+            } \
+            catch( exceptionType const& ex ) { \
+                catchAssertionHandler.handleExpr( Catch::makeMatchExpr( ex, matcher, #matcher##_catch_sr ) ); \
+            } \
+            catch( ... ) { \
+                catchAssertionHandler.handleUnexpectedInflightException(); \
+            } \
+        else \
+            catchAssertionHandler.handleThrowingCallSkipped(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+
+#endif // CATCH_MATCHERS_IMPL_HPP_INCLUDED
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+namespace Matchers {
+
+    class MatcherUntypedBase {
+    public:
+        MatcherUntypedBase() = default;
+
+        MatcherUntypedBase(MatcherUntypedBase const&) = default;
+        MatcherUntypedBase(MatcherUntypedBase&&) = default;
+
+        MatcherUntypedBase& operator = (MatcherUntypedBase const&) = delete;
+        MatcherUntypedBase& operator = (MatcherUntypedBase&&) = delete;
+
+        std::string toString() const;
+
+    protected:
+        virtual ~MatcherUntypedBase(); // = default;
+        virtual std::string describe() const = 0;
+        mutable std::string m_cachedToString;
+    };
+
+
+    template<typename T>
+    class MatcherBase : public MatcherUntypedBase {
+    public:
+        virtual bool match( T const& arg ) const = 0;
+    };
+
+    namespace Detail {
+
+        template<typename ArgT>
+        class MatchAllOf final : public MatcherBase<ArgT> {
+            std::vector<MatcherBase<ArgT> const*> m_matchers;
+
+        public:
+            MatchAllOf() = default;
+            MatchAllOf(MatchAllOf const&) = delete;
+            MatchAllOf& operator=(MatchAllOf const&) = delete;
+            MatchAllOf(MatchAllOf&&) = default;
+            MatchAllOf& operator=(MatchAllOf&&) = default;
+
+
+            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;
+            }
+
+            friend MatchAllOf operator&& (MatchAllOf&& lhs, MatcherBase<ArgT> const& rhs) {
+                lhs.m_matchers.push_back(&rhs);
+                return CATCH_MOVE(lhs);
+            }
+            friend MatchAllOf operator&& (MatcherBase<ArgT> const& lhs, MatchAllOf&& rhs) {
+                rhs.m_matchers.insert(rhs.m_matchers.begin(), &lhs);
+                return CATCH_MOVE(rhs);
+            }
+        };
+
+        //! lvalue overload is intentionally deleted, users should
+        //! not be trying to compose stored composition matchers
+        template<typename ArgT>
+        MatchAllOf<ArgT> operator&& (MatchAllOf<ArgT> const& lhs, MatcherBase<ArgT> const& rhs) = delete;
+        //! lvalue overload is intentionally deleted, users should
+        //! not be trying to compose stored composition matchers
+        template<typename ArgT>
+        MatchAllOf<ArgT> operator&& (MatcherBase<ArgT> const& lhs, MatchAllOf<ArgT> const& rhs) = delete;
+
+        template<typename ArgT>
+        class MatchAnyOf final : public MatcherBase<ArgT> {
+            std::vector<MatcherBase<ArgT> const*> m_matchers;
+        public:
+            MatchAnyOf() = default;
+            MatchAnyOf(MatchAnyOf const&) = delete;
+            MatchAnyOf& operator=(MatchAnyOf const&) = delete;
+            MatchAnyOf(MatchAnyOf&&) = default;
+            MatchAnyOf& operator=(MatchAnyOf&&) = default;
+
+            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;
+            }
+
+            friend MatchAnyOf operator|| (MatchAnyOf&& lhs, MatcherBase<ArgT> const& rhs) {
+                lhs.m_matchers.push_back(&rhs);
+                return CATCH_MOVE(lhs);
+            }
+            friend MatchAnyOf operator|| (MatcherBase<ArgT> const& lhs, MatchAnyOf&& rhs) {
+                rhs.m_matchers.insert(rhs.m_matchers.begin(), &lhs);
+                return CATCH_MOVE(rhs);
+            }
+        };
+
+        //! lvalue overload is intentionally deleted, users should
+        //! not be trying to compose stored composition matchers
+        template<typename ArgT>
+        MatchAnyOf<ArgT> operator|| (MatchAnyOf<ArgT> const& lhs, MatcherBase<ArgT> const& rhs) = delete;
+        //! lvalue overload is intentionally deleted, users should
+        //! not be trying to compose stored composition matchers
+        template<typename ArgT>
+        MatchAnyOf<ArgT> operator|| (MatcherBase<ArgT> const& lhs, MatchAnyOf<ArgT> const& rhs) = delete;
+
+        template<typename ArgT>
+        class MatchNotOf final : public MatcherBase<ArgT> {
+            MatcherBase<ArgT> const& m_underlyingMatcher;
+
+        public:
+            explicit 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();
+            }
+        };
+
+    } // namespace Detail
+
+    template <typename T>
+    Detail::MatchAllOf<T> operator&& (MatcherBase<T> const& lhs, MatcherBase<T> const& rhs) {
+        return Detail::MatchAllOf<T>{} && lhs && rhs;
+    }
+    template <typename T>
+    Detail::MatchAnyOf<T> operator|| (MatcherBase<T> const& lhs, MatcherBase<T> const& rhs) {
+        return Detail::MatchAnyOf<T>{} || lhs || rhs;
+    }
+
+    template <typename T>
+    Detail::MatchNotOf<T> operator! (MatcherBase<T> const& matcher) {
+        return Detail::MatchNotOf<T>{ matcher };
+    }
+
+
+} // namespace Matchers
+} // namespace Catch
+
+
+#if defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
+  #define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
+  #define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
+
+  #define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+  #define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+
+  #define CATCH_CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
+  #define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+
+#elif defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)
+
+  #define CATCH_REQUIRE_THROWS_WITH( expr, matcher )                   (void)(0)
+  #define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+
+  #define CATCH_CHECK_THROWS_WITH( expr, matcher )                     (void)(0)
+  #define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher )   (void)(0)
+
+  #define CATCH_CHECK_THAT( arg, matcher )                             (void)(0)
+  #define CATCH_REQUIRE_THAT( arg, matcher )                           (void)(0)
+
+#elif !defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
+
+  #define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
+  #define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
+
+  #define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+  #define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+
+  #define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
+  #define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+
+#elif !defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)
+
+  #define REQUIRE_THROWS_WITH( expr, matcher )                   (void)(0)
+  #define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+
+  #define CHECK_THROWS_WITH( expr, matcher )                     (void)(0)
+  #define CHECK_THROWS_MATCHES( expr, exceptionType, matcher )   (void)(0)
+
+  #define CHECK_THAT( arg, matcher )                             (void)(0)
+  #define REQUIRE_THAT( arg, matcher )                           (void)(0)
+
+#endif // end of user facing macro declarations
+
+#endif // CATCH_MATCHERS_HPP_INCLUDED
+
+
+#ifndef CATCH_MATCHERS_CONTAINER_PROPERTIES_HPP_INCLUDED
+#define CATCH_MATCHERS_CONTAINER_PROPERTIES_HPP_INCLUDED
+
+
+
+#ifndef CATCH_MATCHERS_TEMPLATED_HPP_INCLUDED
+#define CATCH_MATCHERS_TEMPLATED_HPP_INCLUDED
+
+
+#include <array>
+#include <algorithm>
+#include <string>
+#include <type_traits>
+
+namespace Catch {
+namespace Matchers {
+    class MatcherGenericBase : public MatcherUntypedBase {
+    public:
+        MatcherGenericBase() = default;
+        ~MatcherGenericBase() override; // = default;
+
+        MatcherGenericBase(MatcherGenericBase&) = default;
+        MatcherGenericBase(MatcherGenericBase&&) = default;
+
+        MatcherGenericBase& operator=(MatcherGenericBase const&) = delete;
+        MatcherGenericBase& operator=(MatcherGenericBase&&) = delete;
+    };
+
+
+    namespace Detail {
+        template<std::size_t N, std::size_t M>
+        std::array<void const*, N + M> array_cat(std::array<void const*, N> && lhs, std::array<void const*, M> && rhs) {
+            std::array<void const*, N + M> arr{};
+            std::copy_n(lhs.begin(), N, arr.begin());
+            std::copy_n(rhs.begin(), M, arr.begin() + N);
+            return arr;
+        }
+
+        template<std::size_t N>
+        std::array<void const*, N+1> array_cat(std::array<void const*, N> && lhs, void const* rhs) {
+            std::array<void const*, N+1> arr{};
+            std::copy_n(lhs.begin(), N, arr.begin());
+            arr[N] = rhs;
+            return arr;
+        }
+
+        template<std::size_t N>
+        std::array<void const*, N+1> array_cat(void const* lhs, std::array<void const*, N> && rhs) {
+            std::array<void const*, N + 1> arr{ {lhs} };
+            std::copy_n(rhs.begin(), N, arr.begin() + 1);
+            return arr;
+        }
+
+#if defined( __cpp_lib_logical_traits ) && __cpp_lib_logical_traits >= 201510
+
+        using std::conjunction;
+
+#else // __cpp_lib_logical_traits
+
+        template<typename... Cond>
+        struct conjunction : std::true_type {};
+
+        template<typename Cond, typename... Rest>
+        struct conjunction<Cond, Rest...> : std::integral_constant<bool, Cond::value && conjunction<Rest...>::value> {};
+
+#endif // __cpp_lib_logical_traits
+
+        template<typename T>
+        using is_generic_matcher = std::is_base_of<
+            Catch::Matchers::MatcherGenericBase,
+            std::remove_cv_t<std::remove_reference_t<T>>
+        >;
+
+        template<typename... Ts>
+        using are_generic_matchers = conjunction<is_generic_matcher<Ts>...>;
+
+        template<typename T>
+        using is_matcher = std::is_base_of<
+            Catch::Matchers::MatcherUntypedBase,
+            std::remove_cv_t<std::remove_reference_t<T>>
+        >;
+
+
+        template<std::size_t N, typename Arg>
+        bool match_all_of(Arg&&, std::array<void const*, N> const&, std::index_sequence<>) {
+            return true;
+        }
+
+        template<typename T, typename... MatcherTs, std::size_t N, typename Arg, std::size_t Idx, std::size_t... Indices>
+        bool match_all_of(Arg&& arg, std::array<void const*, N> const& matchers, std::index_sequence<Idx, Indices...>) {
+            return static_cast<T const*>(matchers[Idx])->match(arg) && match_all_of<MatcherTs...>(arg, matchers, std::index_sequence<Indices...>{});
+        }
+
+
+        template<std::size_t N, typename Arg>
+        bool match_any_of(Arg&&, std::array<void const*, N> const&, std::index_sequence<>) {
+            return false;
+        }
+
+        template<typename T, typename... MatcherTs, std::size_t N, typename Arg, std::size_t Idx, std::size_t... Indices>
+        bool match_any_of(Arg&& arg, std::array<void const*, N> const& matchers, std::index_sequence<Idx, Indices...>) {
+            return static_cast<T const*>(matchers[Idx])->match(arg) || match_any_of<MatcherTs...>(arg, matchers, std::index_sequence<Indices...>{});
+        }
+
+        std::string describe_multi_matcher(StringRef combine, std::string const* descriptions_begin, std::string const* descriptions_end);
+
+        template<typename... MatcherTs, std::size_t... Idx>
+        std::string describe_multi_matcher(StringRef combine, std::array<void const*, sizeof...(MatcherTs)> const& matchers, std::index_sequence<Idx...>) {
+            std::array<std::string, sizeof...(MatcherTs)> descriptions {{
+                static_cast<MatcherTs const*>(matchers[Idx])->toString()...
+            }};
+
+            return describe_multi_matcher(combine, descriptions.data(), descriptions.data() + descriptions.size());
+        }
+
+
+        template<typename... MatcherTs>
+        class MatchAllOfGeneric final : public MatcherGenericBase {
+        public:
+            MatchAllOfGeneric(MatchAllOfGeneric const&) = delete;
+            MatchAllOfGeneric& operator=(MatchAllOfGeneric const&) = delete;
+            MatchAllOfGeneric(MatchAllOfGeneric&&) = default;
+            MatchAllOfGeneric& operator=(MatchAllOfGeneric&&) = default;
+
+            MatchAllOfGeneric(MatcherTs const&... matchers) : m_matchers{ {std::addressof(matchers)...} } {}
+            explicit MatchAllOfGeneric(std::array<void const*, sizeof...(MatcherTs)> matchers) : m_matchers{matchers} {}
+
+            template<typename Arg>
+            bool match(Arg&& arg) const {
+                return match_all_of<MatcherTs...>(arg, m_matchers, std::index_sequence_for<MatcherTs...>{});
+            }
+
+            std::string describe() const override {
+                return describe_multi_matcher<MatcherTs...>(" and "_sr, m_matchers, std::index_sequence_for<MatcherTs...>{});
+            }
+
+            // Has to be public to enable the concatenating operators
+            // below, because they are not friend of the RHS, only LHS,
+            // and thus cannot access private fields of RHS
+            std::array<void const*, sizeof...( MatcherTs )> m_matchers;
+
+
+            //! Avoids type nesting for `GenericAllOf && GenericAllOf` case
+            template<typename... MatchersRHS>
+            friend
+            MatchAllOfGeneric<MatcherTs..., MatchersRHS...> operator && (
+                    MatchAllOfGeneric<MatcherTs...>&& lhs,
+                    MatchAllOfGeneric<MatchersRHS...>&& rhs) {
+                return MatchAllOfGeneric<MatcherTs..., MatchersRHS...>{array_cat(CATCH_MOVE(lhs.m_matchers), CATCH_MOVE(rhs.m_matchers))};
+            }
+
+            //! Avoids type nesting for `GenericAllOf && some matcher` case
+            template<typename MatcherRHS>
+            friend std::enable_if_t<is_matcher<MatcherRHS>::value,
+            MatchAllOfGeneric<MatcherTs..., MatcherRHS>> operator && (
+                    MatchAllOfGeneric<MatcherTs...>&& lhs,
+                    MatcherRHS const& rhs) {
+                return MatchAllOfGeneric<MatcherTs..., MatcherRHS>{array_cat(CATCH_MOVE(lhs.m_matchers), static_cast<void const*>(&rhs))};
+            }
+
+            //! Avoids type nesting for `some matcher && GenericAllOf` case
+            template<typename MatcherLHS>
+            friend std::enable_if_t<is_matcher<MatcherLHS>::value,
+            MatchAllOfGeneric<MatcherLHS, MatcherTs...>> operator && (
+                    MatcherLHS const& lhs,
+                    MatchAllOfGeneric<MatcherTs...>&& rhs) {
+                return MatchAllOfGeneric<MatcherLHS, MatcherTs...>{array_cat(static_cast<void const*>(std::addressof(lhs)), CATCH_MOVE(rhs.m_matchers))};
+            }
+        };
+
+
+        template<typename... MatcherTs>
+        class MatchAnyOfGeneric final : public MatcherGenericBase {
+        public:
+            MatchAnyOfGeneric(MatchAnyOfGeneric const&) = delete;
+            MatchAnyOfGeneric& operator=(MatchAnyOfGeneric const&) = delete;
+            MatchAnyOfGeneric(MatchAnyOfGeneric&&) = default;
+            MatchAnyOfGeneric& operator=(MatchAnyOfGeneric&&) = default;
+
+            MatchAnyOfGeneric(MatcherTs const&... matchers) : m_matchers{ {std::addressof(matchers)...} } {}
+            explicit MatchAnyOfGeneric(std::array<void const*, sizeof...(MatcherTs)> matchers) : m_matchers{matchers} {}
+
+            template<typename Arg>
+            bool match(Arg&& arg) const {
+                return match_any_of<MatcherTs...>(arg, m_matchers, std::index_sequence_for<MatcherTs...>{});
+            }
+
+            std::string describe() const override {
+                return describe_multi_matcher<MatcherTs...>(" or "_sr, m_matchers, std::index_sequence_for<MatcherTs...>{});
+            }
+
+
+            // Has to be public to enable the concatenating operators
+            // below, because they are not friend of the RHS, only LHS,
+            // and thus cannot access private fields of RHS
+            std::array<void const*, sizeof...( MatcherTs )> m_matchers;
+
+            //! Avoids type nesting for `GenericAnyOf || GenericAnyOf` case
+            template<typename... MatchersRHS>
+            friend MatchAnyOfGeneric<MatcherTs..., MatchersRHS...> operator || (
+                    MatchAnyOfGeneric<MatcherTs...>&& lhs,
+                    MatchAnyOfGeneric<MatchersRHS...>&& rhs) {
+                return MatchAnyOfGeneric<MatcherTs..., MatchersRHS...>{array_cat(CATCH_MOVE(lhs.m_matchers), CATCH_MOVE(rhs.m_matchers))};
+            }
+
+            //! Avoids type nesting for `GenericAnyOf || some matcher` case
+            template<typename MatcherRHS>
+            friend std::enable_if_t<is_matcher<MatcherRHS>::value,
+            MatchAnyOfGeneric<MatcherTs..., MatcherRHS>> operator || (
+                    MatchAnyOfGeneric<MatcherTs...>&& lhs,
+                    MatcherRHS const& rhs) {
+                return MatchAnyOfGeneric<MatcherTs..., MatcherRHS>{array_cat(CATCH_MOVE(lhs.m_matchers), static_cast<void const*>(std::addressof(rhs)))};
+            }
+
+            //! Avoids type nesting for `some matcher || GenericAnyOf` case
+            template<typename MatcherLHS>
+            friend std::enable_if_t<is_matcher<MatcherLHS>::value,
+            MatchAnyOfGeneric<MatcherLHS, MatcherTs...>> operator || (
+                MatcherLHS const& lhs,
+                MatchAnyOfGeneric<MatcherTs...>&& rhs) {
+                return MatchAnyOfGeneric<MatcherLHS, MatcherTs...>{array_cat(static_cast<void const*>(std::addressof(lhs)), CATCH_MOVE(rhs.m_matchers))};
+            }
+        };
+
+
+        template<typename MatcherT>
+        class MatchNotOfGeneric final : public MatcherGenericBase {
+            MatcherT const& m_matcher;
+
+        public:
+            MatchNotOfGeneric(MatchNotOfGeneric const&) = delete;
+            MatchNotOfGeneric& operator=(MatchNotOfGeneric const&) = delete;
+            MatchNotOfGeneric(MatchNotOfGeneric&&) = default;
+            MatchNotOfGeneric& operator=(MatchNotOfGeneric&&) = default;
+
+            explicit MatchNotOfGeneric(MatcherT const& matcher) : m_matcher{matcher} {}
+
+            template<typename Arg>
+            bool match(Arg&& arg) const {
+                return !m_matcher.match(arg);
+            }
+
+            std::string describe() const override {
+                return "not " + m_matcher.toString();
+            }
+
+            //! Negating negation can just unwrap and return underlying matcher
+            friend MatcherT const& operator ! (MatchNotOfGeneric<MatcherT> const& matcher) {
+                return matcher.m_matcher;
+            }
+        };
+    } // namespace Detail
+
+
+    // compose only generic matchers
+    template<typename MatcherLHS, typename MatcherRHS>
+    std::enable_if_t<Detail::are_generic_matchers<MatcherLHS, MatcherRHS>::value, Detail::MatchAllOfGeneric<MatcherLHS, MatcherRHS>>
+        operator && (MatcherLHS const& lhs, MatcherRHS const& rhs) {
+        return { lhs, rhs };
+    }
+
+    template<typename MatcherLHS, typename MatcherRHS>
+    std::enable_if_t<Detail::are_generic_matchers<MatcherLHS, MatcherRHS>::value, Detail::MatchAnyOfGeneric<MatcherLHS, MatcherRHS>>
+        operator || (MatcherLHS const& lhs, MatcherRHS const& rhs) {
+        return { lhs, rhs };
+    }
+
+    //! Wrap provided generic matcher in generic negator
+    template<typename MatcherT>
+    std::enable_if_t<Detail::is_generic_matcher<MatcherT>::value, Detail::MatchNotOfGeneric<MatcherT>>
+        operator ! (MatcherT const& matcher) {
+        return Detail::MatchNotOfGeneric<MatcherT>{matcher};
+    }
+
+
+    // compose mixed generic and non-generic matchers
+    template<typename MatcherLHS, typename ArgRHS>
+    std::enable_if_t<Detail::is_generic_matcher<MatcherLHS>::value, Detail::MatchAllOfGeneric<MatcherLHS, MatcherBase<ArgRHS>>>
+        operator && (MatcherLHS const& lhs, MatcherBase<ArgRHS> const& rhs) {
+        return { lhs, rhs };
+    }
+
+    template<typename ArgLHS, typename MatcherRHS>
+    std::enable_if_t<Detail::is_generic_matcher<MatcherRHS>::value, Detail::MatchAllOfGeneric<MatcherBase<ArgLHS>, MatcherRHS>>
+        operator && (MatcherBase<ArgLHS> const& lhs, MatcherRHS const& rhs) {
+        return { lhs, rhs };
+    }
+
+    template<typename MatcherLHS, typename ArgRHS>
+    std::enable_if_t<Detail::is_generic_matcher<MatcherLHS>::value, Detail::MatchAnyOfGeneric<MatcherLHS, MatcherBase<ArgRHS>>>
+        operator || (MatcherLHS const& lhs, MatcherBase<ArgRHS> const& rhs) {
+        return { lhs, rhs };
+    }
+
+    template<typename ArgLHS, typename MatcherRHS>
+    std::enable_if_t<Detail::is_generic_matcher<MatcherRHS>::value, Detail::MatchAnyOfGeneric<MatcherBase<ArgLHS>, MatcherRHS>>
+        operator || (MatcherBase<ArgLHS> const& lhs, MatcherRHS const& rhs) {
+        return { lhs, rhs };
+    }
+
+} // namespace Matchers
+} // namespace Catch
+
+#endif // CATCH_MATCHERS_TEMPLATED_HPP_INCLUDED
+
+namespace Catch {
+    namespace Matchers {
+
+        class IsEmptyMatcher final : public MatcherGenericBase {
+        public:
+            template <typename RangeLike>
+            bool match(RangeLike&& rng) const {
+#if defined(CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS)
+                using Catch::Detail::empty;
+#else
+                using std::empty;
+#endif
+                return empty(rng);
+            }
+
+            std::string describe() const override;
+        };
+
+        class HasSizeMatcher final : public MatcherGenericBase {
+            std::size_t m_target_size;
+        public:
+            explicit HasSizeMatcher(std::size_t target_size):
+                m_target_size(target_size)
+            {}
+
+            template <typename RangeLike>
+            bool match(RangeLike&& rng) const {
+#if defined(CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS)
+                using Catch::Detail::size;
+#else
+                using std::size;
+#endif
+                return size(rng) == m_target_size;
+            }
+
+            std::string describe() const override;
+        };
+
+        template <typename Matcher>
+        class SizeMatchesMatcher final : public MatcherGenericBase {
+            Matcher m_matcher;
+        public:
+            explicit SizeMatchesMatcher(Matcher m):
+                m_matcher(CATCH_MOVE(m))
+            {}
+
+            template <typename RangeLike>
+            bool match(RangeLike&& rng) const {
+#if defined(CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS)
+                using Catch::Detail::size;
+#else
+                using std::size;
+#endif
+                return m_matcher.match(size(rng));
+            }
+
+            std::string describe() const override {
+                return "size matches " + m_matcher.describe();
+            }
+        };
+
+
+        //! Creates a matcher that accepts empty ranges/containers
+        IsEmptyMatcher IsEmpty();
+        //! Creates a matcher that accepts ranges/containers with specific size
+        HasSizeMatcher SizeIs(std::size_t sz);
+        template <typename Matcher>
+        std::enable_if_t<Detail::is_matcher<Matcher>::value,
+        SizeMatchesMatcher<Matcher>> SizeIs(Matcher&& m) {
+            return SizeMatchesMatcher<Matcher>{CATCH_FORWARD(m)};
+        }
+
+    } // end namespace Matchers
+} // end namespace Catch
+
+#endif // CATCH_MATCHERS_CONTAINER_PROPERTIES_HPP_INCLUDED
+
+
+#ifndef CATCH_MATCHERS_CONTAINS_HPP_INCLUDED
+#define CATCH_MATCHERS_CONTAINS_HPP_INCLUDED
+
+
+#include <algorithm>
+#include <functional>
+
+namespace Catch {
+    namespace Matchers {
+        //! Matcher for checking that an element in range is equal to specific element
+        template <typename T, typename Equality>
+        class ContainsElementMatcher final : public MatcherGenericBase {
+            T m_desired;
+            Equality m_eq;
+        public:
+            template <typename T2, typename Equality2>
+            ContainsElementMatcher(T2&& target, Equality2&& predicate):
+                m_desired(CATCH_FORWARD(target)),
+                m_eq(CATCH_FORWARD(predicate))
+            {}
+
+            std::string describe() const override {
+                return "contains element " + Catch::Detail::stringify(m_desired);
+            }
+
+            template <typename RangeLike>
+            bool match(RangeLike&& rng) const {
+                using std::begin; using std::end;
+
+                return end(rng) != std::find_if(begin(rng), end(rng),
+                                               [&](auto const& elem) {
+                                                    return m_eq(elem, m_desired);
+                                               });
+            }
+        };
+
+        //! Meta-matcher for checking that an element in a range matches a specific matcher
+        template <typename Matcher>
+        class ContainsMatcherMatcher final : public MatcherGenericBase {
+            Matcher m_matcher;
+        public:
+            // Note that we do a copy+move to avoid having to SFINAE this
+            // constructor (and also avoid some perfect forwarding failure
+            // cases)
+            ContainsMatcherMatcher(Matcher matcher):
+                m_matcher(CATCH_MOVE(matcher))
+            {}
+
+            template <typename RangeLike>
+            bool match(RangeLike&& rng) const {
+                for (auto&& elem : rng) {
+                    if (m_matcher.match(elem)) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+            std::string describe() const override {
+                return "contains element matching " + m_matcher.describe();
+            }
+        };
+
+        /**
+         * Creates a matcher that checks whether a range contains a specific element.
+         *
+         * Uses `std::equal_to` to do the comparison
+         */
+        template <typename T>
+        std::enable_if_t<!Detail::is_matcher<T>::value,
+        ContainsElementMatcher<T, std::equal_to<>>> Contains(T&& elem) {
+            return { CATCH_FORWARD(elem), std::equal_to<>{} };
+        }
+
+        //! Creates a matcher that checks whether a range contains element matching a matcher
+        template <typename Matcher>
+        std::enable_if_t<Detail::is_matcher<Matcher>::value,
+        ContainsMatcherMatcher<Matcher>> Contains(Matcher&& matcher) {
+            return { CATCH_FORWARD(matcher) };
+        }
+
+        /**
+         * Creates a matcher that checks whether a range contains a specific element.
+         *
+         * Uses `eq` to do the comparisons
+         */
+        template <typename T, typename Equality>
+        ContainsElementMatcher<T, Equality> Contains(T&& elem, Equality&& eq) {
+            return { CATCH_FORWARD(elem), CATCH_FORWARD(eq) };
+        }
+
+    }
+}
+
+#endif // CATCH_MATCHERS_CONTAINS_HPP_INCLUDED
+
+
+#ifndef CATCH_MATCHERS_EXCEPTION_HPP_INCLUDED
+#define CATCH_MATCHERS_EXCEPTION_HPP_INCLUDED
+
+
+namespace Catch {
+namespace Matchers {
+
+class ExceptionMessageMatcher final : public MatcherBase<std::exception> {
+    std::string m_message;
+public:
+
+    ExceptionMessageMatcher(std::string const& message):
+        m_message(message)
+    {}
+
+    bool match(std::exception const& ex) const override;
+
+    std::string describe() const override;
+};
+
+//! Creates a matcher that checks whether a std derived exception has the provided message
+ExceptionMessageMatcher Message(std::string const& message);
+
+} // namespace Matchers
+} // namespace Catch
+
+#endif // CATCH_MATCHERS_EXCEPTION_HPP_INCLUDED
+
+
+#ifndef CATCH_MATCHERS_FLOATING_POINT_HPP_INCLUDED
+#define CATCH_MATCHERS_FLOATING_POINT_HPP_INCLUDED
+
+
+namespace Catch {
+namespace Matchers {
+
+    namespace Detail {
+        enum class FloatingPointKind : uint8_t;
+    }
+
+    class  WithinAbsMatcher final : public MatcherBase<double> {
+    public:
+        WithinAbsMatcher(double target, double margin);
+        bool match(double const& matchee) const override;
+        std::string describe() const override;
+    private:
+        double m_target;
+        double m_margin;
+    };
+
+    class WithinUlpsMatcher final : public MatcherBase<double> {
+    public:
+        WithinUlpsMatcher( double target,
+                           uint64_t ulps,
+                           Detail::FloatingPointKind baseType );
+        bool match(double const& matchee) const override;
+        std::string describe() const override;
+    private:
+        double m_target;
+        uint64_t m_ulps;
+        Detail::FloatingPointKind m_type;
+    };
+
+    // Given IEEE-754 format for floats and doubles, we can assume
+    // that float -> double promotion is lossless. Given this, we can
+    // assume that if we do the standard relative comparison of
+    // |lhs - rhs| <= epsilon * max(fabs(lhs), fabs(rhs)), then we get
+    // the same result if we do this for floats, as if we do this for
+    // doubles that were promoted from floats.
+    class WithinRelMatcher final : public MatcherBase<double> {
+    public:
+        WithinRelMatcher( double target, double epsilon );
+        bool match(double const& matchee) const override;
+        std::string describe() const override;
+    private:
+        double m_target;
+        double m_epsilon;
+    };
+
+    //! Creates a matcher that accepts doubles within certain ULP range of target
+    WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff);
+    //! Creates a matcher that accepts floats within certain ULP range of target
+    WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff);
+    //! Creates a matcher that accepts numbers within certain range of target
+    WithinAbsMatcher WithinAbs(double target, double margin);
+
+    //! Creates a matcher that accepts doubles within certain relative range of target
+    WithinRelMatcher WithinRel(double target, double eps);
+    //! Creates a matcher that accepts doubles within 100*DBL_EPS relative range of target
+    WithinRelMatcher WithinRel(double target);
+    //! Creates a matcher that accepts doubles within certain relative range of target
+    WithinRelMatcher WithinRel(float target, float eps);
+    //! Creates a matcher that accepts floats within 100*FLT_EPS relative range of target
+    WithinRelMatcher WithinRel(float target);
+
+} // namespace Matchers
+} // namespace Catch
+
+#endif // CATCH_MATCHERS_FLOATING_POINT_HPP_INCLUDED
+
+
+#ifndef CATCH_MATCHERS_PREDICATE_HPP_INCLUDED
+#define CATCH_MATCHERS_PREDICATE_HPP_INCLUDED
+
+
+#include <string>
+
+namespace Catch {
+namespace Matchers {
+
+namespace Detail {
+    std::string finalizeDescription(const std::string& desc);
+} // namespace Detail
+
+template <typename T, typename Predicate>
+class PredicateMatcher final : public MatcherBase<T> {
+    Predicate m_predicate;
+    std::string m_description;
+public:
+
+    PredicateMatcher(Predicate&& elem, std::string const& descr)
+        :m_predicate(CATCH_FORWARD(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;
+    }
+};
+
+    /**
+     * Creates a matcher that calls delegates `match` to the provided predicate.
+     *
+     * The user has to explicitly specify the argument type to the matcher
+     */
+    template<typename T, typename Pred>
+    PredicateMatcher<T, Pred> Predicate(Pred&& predicate, std::string const& description = "") {
+        static_assert(is_callable<Pred(T)>::value, "Predicate not callable with argument T");
+        static_assert(std::is_same<bool, FunctionReturnType<Pred, T>>::value, "Predicate does not return bool");
+        return PredicateMatcher<T, Pred>(CATCH_FORWARD(predicate), description);
+    }
+
+} // namespace Matchers
+} // namespace Catch
+
+#endif // CATCH_MATCHERS_PREDICATE_HPP_INCLUDED
+
+
+#ifndef CATCH_MATCHERS_QUANTIFIERS_HPP_INCLUDED
+#define CATCH_MATCHERS_QUANTIFIERS_HPP_INCLUDED
+
+
+namespace Catch {
+    namespace Matchers {
+        // Matcher for checking that all elements in range matches a given matcher.
+        template <typename Matcher>
+        class AllMatchMatcher final : public MatcherGenericBase {
+            Matcher m_matcher;
+        public:
+            AllMatchMatcher(Matcher matcher):
+                m_matcher(CATCH_MOVE(matcher))
+            {}
+
+            std::string describe() const override {
+                return "all match " + m_matcher.describe();
+            }
+
+            template <typename RangeLike>
+            bool match(RangeLike&& rng) const {
+                for (auto&& elem : rng) {
+                    if (!m_matcher.match(elem)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+        };
+
+        // Matcher for checking that no element in range matches a given matcher.
+        template <typename Matcher>
+        class NoneMatchMatcher final : public MatcherGenericBase {
+            Matcher m_matcher;
+        public:
+            NoneMatchMatcher(Matcher matcher):
+                m_matcher(CATCH_MOVE(matcher))
+            {}
+
+            std::string describe() const override {
+                return "none match " + m_matcher.describe();
+            }
+
+            template <typename RangeLike>
+            bool match(RangeLike&& rng) const {
+                for (auto&& elem : rng) {
+                    if (m_matcher.match(elem)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+        };
+
+        // Matcher for checking that at least one element in range matches a given matcher.
+        template <typename Matcher>
+        class AnyMatchMatcher final : public MatcherGenericBase {
+            Matcher m_matcher;
+        public:
+            AnyMatchMatcher(Matcher matcher):
+                m_matcher(CATCH_MOVE(matcher))
+            {}
+
+            std::string describe() const override {
+                return "any match " + m_matcher.describe();
+            }
+
+            template <typename RangeLike>
+            bool match(RangeLike&& rng) const {
+                for (auto&& elem : rng) {
+                    if (m_matcher.match(elem)) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+        };
+
+        // Matcher for checking that all elements in range are true.
+        class AllTrueMatcher final : public MatcherGenericBase {
+        public:
+            std::string describe() const override;
+
+            template <typename RangeLike>
+            bool match(RangeLike&& rng) const {
+                for (auto&& elem : rng) {
+                    if (!elem) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+        };
+
+        // Matcher for checking that no element in range is true.
+        class NoneTrueMatcher final : public MatcherGenericBase {
+        public:
+            std::string describe() const override;
+
+            template <typename RangeLike>
+            bool match(RangeLike&& rng) const {
+                for (auto&& elem : rng) {
+                    if (elem) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+        };
+
+        // Matcher for checking that any element in range is true.
+        class AnyTrueMatcher final : public MatcherGenericBase {
+        public:
+            std::string describe() const override;
+
+            template <typename RangeLike>
+            bool match(RangeLike&& rng) const {
+                for (auto&& elem : rng) {
+                    if (elem) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+        };
+
+        // Creates a matcher that checks whether all elements in a range match a matcher
+        template <typename Matcher>
+        AllMatchMatcher<Matcher> AllMatch(Matcher&& matcher) {
+            return { CATCH_FORWARD(matcher) };
+        }
+
+        // Creates a matcher that checks whether no element in a range matches a matcher.
+        template <typename Matcher>
+        NoneMatchMatcher<Matcher> NoneMatch(Matcher&& matcher) {
+            return { CATCH_FORWARD(matcher) };
+        }
+
+        // Creates a matcher that checks whether any element in a range matches a matcher.
+        template <typename Matcher>
+        AnyMatchMatcher<Matcher> AnyMatch(Matcher&& matcher) {
+            return { CATCH_FORWARD(matcher) };
+        }
+
+        // Creates a matcher that checks whether all elements in a range are true
+        AllTrueMatcher AllTrue();
+
+        // Creates a matcher that checks whether no element in a range is true
+        NoneTrueMatcher NoneTrue();
+
+        // Creates a matcher that checks whether any element in a range is true
+        AnyTrueMatcher AnyTrue();
+    }
+}
+
+#endif // CATCH_MATCHERS_QUANTIFIERS_HPP_INCLUDED
+
+
+#ifndef CATCH_MATCHERS_STRING_HPP_INCLUDED
+#define CATCH_MATCHERS_STRING_HPP_INCLUDED
+
+
+#include <string>
+
+namespace Catch {
+namespace Matchers {
+
+    struct CasedString {
+        CasedString( std::string const& str, CaseSensitive caseSensitivity );
+        std::string adjustString( std::string const& str ) const;
+        StringRef caseSensitivitySuffix() const;
+
+        CaseSensitive m_caseSensitivity;
+        std::string m_str;
+    };
+
+    class StringMatcherBase : public MatcherBase<std::string> {
+    protected:
+        CasedString m_comparator;
+        StringRef m_operation;
+
+    public:
+        StringMatcherBase( StringRef operation,
+                           CasedString const& comparator );
+        std::string describe() const override;
+    };
+
+    class StringEqualsMatcher final : public StringMatcherBase {
+    public:
+        StringEqualsMatcher( CasedString const& comparator );
+        bool match( std::string const& source ) const override;
+    };
+    class StringContainsMatcher final : public StringMatcherBase {
+    public:
+        StringContainsMatcher( CasedString const& comparator );
+        bool match( std::string const& source ) const override;
+    };
+    class StartsWithMatcher final : public StringMatcherBase {
+    public:
+        StartsWithMatcher( CasedString const& comparator );
+        bool match( std::string const& source ) const override;
+    };
+    class EndsWithMatcher final : public StringMatcherBase {
+    public:
+        EndsWithMatcher( CasedString const& comparator );
+        bool match( std::string const& source ) const override;
+    };
+
+    class RegexMatcher final : public MatcherBase<std::string> {
+        std::string m_regex;
+        CaseSensitive m_caseSensitivity;
+
+    public:
+        RegexMatcher( std::string regex, CaseSensitive caseSensitivity );
+        bool match( std::string const& matchee ) const override;
+        std::string describe() const override;
+    };
+
+    //! Creates matcher that accepts strings that are exactly equal to `str`
+    StringEqualsMatcher Equals( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
+    //! Creates matcher that accepts strings that contain `str`
+    StringContainsMatcher ContainsSubstring( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
+    //! Creates matcher that accepts strings that _end_ with `str`
+    EndsWithMatcher EndsWith( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
+    //! Creates matcher that accepts strings that _start_ with `str`
+    StartsWithMatcher StartsWith( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
+    //! Creates matcher that accepts strings matching `regex`
+    RegexMatcher Matches( std::string const& regex, CaseSensitive caseSensitivity = CaseSensitive::Yes );
+
+} // namespace Matchers
+} // namespace Catch
+
+#endif // CATCH_MATCHERS_STRING_HPP_INCLUDED
+
+
+#ifndef CATCH_MATCHERS_VECTOR_HPP_INCLUDED
+#define CATCH_MATCHERS_VECTOR_HPP_INCLUDED
+
+
+#include <algorithm>
+
+namespace Catch {
+namespace Matchers {
+
+    template<typename T, typename Alloc>
+    class VectorContainsElementMatcher final : public MatcherBase<std::vector<T, Alloc>> {
+        T const& m_comparator;
+
+    public:
+        VectorContainsElementMatcher(T const& comparator):
+            m_comparator(comparator)
+        {}
+
+        bool match(std::vector<T, Alloc> 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 );
+        }
+    };
+
+    template<typename T, typename AllocComp, typename AllocMatch>
+    class ContainsMatcher final : public MatcherBase<std::vector<T, AllocMatch>> {
+        std::vector<T, AllocComp> const& m_comparator;
+
+    public:
+        ContainsMatcher(std::vector<T, AllocComp> const& comparator):
+            m_comparator( comparator )
+        {}
+
+        bool match(std::vector<T, AllocMatch> 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 );
+        }
+    };
+
+    template<typename T, typename AllocComp, typename AllocMatch>
+    class EqualsMatcher final : public MatcherBase<std::vector<T, AllocMatch>> {
+        std::vector<T, AllocComp> const& m_comparator;
+
+    public:
+        EqualsMatcher(std::vector<T, AllocComp> const& comparator):
+            m_comparator( comparator )
+        {}
+
+        bool match(std::vector<T, AllocMatch> 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 );
+        }
+    };
+
+    template<typename T, typename AllocComp, typename AllocMatch>
+    class ApproxMatcher final : public MatcherBase<std::vector<T, AllocMatch>> {
+        std::vector<T, AllocComp> const& m_comparator;
+        mutable Catch::Approx approx = Catch::Approx::custom();
+
+    public:
+        ApproxMatcher(std::vector<T, AllocComp> const& comparator):
+            m_comparator( comparator )
+        {}
+
+        bool match(std::vector<T, AllocMatch> const& v) const override {
+            if (m_comparator.size() != v.size())
+                return false;
+            for (std::size_t i = 0; i < v.size(); ++i)
+                if (m_comparator[i] != approx(v[i]))
+                    return false;
+            return true;
+        }
+        std::string describe() const override {
+            return "is approx: " + ::Catch::Detail::stringify( m_comparator );
+        }
+        template <typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+        ApproxMatcher& epsilon( T const& newEpsilon ) {
+            approx.epsilon(static_cast<double>(newEpsilon));
+            return *this;
+        }
+        template <typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+        ApproxMatcher& margin( T const& newMargin ) {
+            approx.margin(static_cast<double>(newMargin));
+            return *this;
+        }
+        template <typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+        ApproxMatcher& scale( T const& newScale ) {
+            approx.scale(static_cast<double>(newScale));
+            return *this;
+        }
+    };
+
+    template<typename T, typename AllocComp, typename AllocMatch>
+    class UnorderedEqualsMatcher final : public MatcherBase<std::vector<T, AllocMatch>> {
+        std::vector<T, AllocComp> const& m_target;
+
+    public:
+        UnorderedEqualsMatcher(std::vector<T, AllocComp> const& target):
+            m_target(target)
+        {}
+        bool match(std::vector<T, AllocMatch> const& vec) const override {
+            if (m_target.size() != vec.size()) {
+                return false;
+            }
+            return std::is_permutation(m_target.begin(), m_target.end(), vec.begin());
+        }
+
+        std::string describe() const override {
+            return "UnorderedEquals: " + ::Catch::Detail::stringify(m_target);
+        }
+    };
+
+
+    // The following functions create the actual matcher objects.
+    // This allows the types to be inferred
+
+    //! Creates a matcher that matches vectors that contain all elements in `comparator`
+    template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
+    ContainsMatcher<T, AllocComp, AllocMatch> Contains( std::vector<T, AllocComp> const& comparator ) {
+        return ContainsMatcher<T, AllocComp, AllocMatch>(comparator);
+    }
+
+    //! Creates a matcher that matches vectors that contain `comparator` as an element
+    template<typename T, typename Alloc = std::allocator<T>>
+    VectorContainsElementMatcher<T, Alloc> VectorContains( T const& comparator ) {
+        return VectorContainsElementMatcher<T, Alloc>(comparator);
+    }
+
+    //! Creates a matcher that matches vectors that are exactly equal to `comparator`
+    template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
+    EqualsMatcher<T, AllocComp, AllocMatch> Equals( std::vector<T, AllocComp> const& comparator ) {
+        return EqualsMatcher<T, AllocComp, AllocMatch>(comparator);
+    }
+
+    //! Creates a matcher that matches vectors that `comparator` as an element
+    template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
+    ApproxMatcher<T, AllocComp, AllocMatch> Approx( std::vector<T, AllocComp> const& comparator ) {
+        return ApproxMatcher<T, AllocComp, AllocMatch>(comparator);
+    }
+
+    //! Creates a matcher that matches vectors that is equal to `target` modulo permutation
+    template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
+    UnorderedEqualsMatcher<T, AllocComp, AllocMatch> UnorderedEquals(std::vector<T, AllocComp> const& target) {
+        return UnorderedEqualsMatcher<T, AllocComp, AllocMatch>(target);
+    }
+
+} // namespace Matchers
+} // namespace Catch
+
+#endif // CATCH_MATCHERS_VECTOR_HPP_INCLUDED
+
+#endif // CATCH_MATCHERS_ALL_HPP_INCLUDED
+
+
+/** \file
+ * This is a convenience header for Catch2's Reporter support. It includes
+ * **all** of Catch2 headers related to reporters, including all reporters.
+ *
+ * Generally the Catch2 users should use specific includes they need,
+ * but this header can be used instead for ease-of-experimentation, or
+ * just plain convenience, at the cost of (significantly) increased
+ * compilation times.
+ *
+ * When a new header (reporter) is added to either the `reporter` folder,
+ * or to the corresponding internal subfolder, it should be added here.
+ */
+
+#ifndef CATCH_REPORTERS_ALL_HPP_INCLUDED
+#define CATCH_REPORTERS_ALL_HPP_INCLUDED
+
+
+
+#ifndef CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
+#define CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
+
+
+
+#ifndef CATCH_REPORTER_STREAMING_BASE_HPP_INCLUDED
+#define CATCH_REPORTER_STREAMING_BASE_HPP_INCLUDED
+
+
+
+#ifndef CATCH_REPORTER_COMMON_BASE_HPP_INCLUDED
+#define CATCH_REPORTER_COMMON_BASE_HPP_INCLUDED
+
+
+#include <map>
+#include <string>
+
+namespace Catch {
+    class ColourImpl;
+
+    /**
+     * This is the base class for all reporters.
+     *
+     * If are writing a reporter, you must derive from this type, or one
+     * of the helper reporter bases that are derived from this type.
+     *
+     * ReporterBase centralizes handling of various common tasks in reporters,
+     * like storing the right stream for the reporters to write to, and
+     * providing the default implementation of the different listing events.
+     */
+    class ReporterBase : public IEventListener {
+    protected:
+        //! The stream wrapper as passed to us by outside code
+        Detail::unique_ptr<IStream> m_wrapped_stream;
+        //! Cached output stream from `m_wrapped_stream` to reduce
+        //! number of indirect calls needed to write output.
+        std::ostream& m_stream;
+        //! Colour implementation this reporter was configured for
+        Detail::unique_ptr<ColourImpl> m_colour;
+        //! The custom reporter options user passed down to the reporter
+        std::map<std::string, std::string> m_customOptions;
+
+    public:
+        ReporterBase( ReporterConfig&& config );
+        ~ReporterBase() override; // = default;
+
+        /**
+         * Provides a simple default listing of reporters.
+         *
+         * Should look roughly like the reporter listing in v2 and earlier
+         * versions of Catch2.
+         */
+        void listReporters(
+            std::vector<ReporterDescription> const& descriptions ) override;
+        /**
+         * Provides a simple default listing of listeners
+         *
+         * Looks similarly to listing of reporters, but with listener type
+         * instead of reporter name.
+         */
+        void listListeners(
+            std::vector<ListenerDescription> const& descriptions ) override;
+        /**
+         * Provides a simple default listing of tests.
+         *
+         * Should look roughly like the test listing in v2 and earlier versions
+         * of Catch2. Especially supports low-verbosity listing that mimics the
+         * old `--list-test-names-only` output.
+         */
+        void listTests( std::vector<TestCaseHandle> const& tests ) override;
+        /**
+         * Provides a simple default listing of tags.
+         *
+         * Should look roughly like the tag listing in v2 and earlier versions
+         * of Catch2.
+         */
+        void listTags( std::vector<TagInfo> const& tags ) override;
+    };
+} // namespace Catch
+
+#endif // CATCH_REPORTER_COMMON_BASE_HPP_INCLUDED
+
+#include <vector>
+
+namespace Catch {
+
+    class StreamingReporterBase : public ReporterBase {
+    public:
+        // GCC5 compat: we cannot use inherited constructor, because it
+        //              doesn't implement backport of P0136
+        StreamingReporterBase(ReporterConfig&& _config):
+            ReporterBase(CATCH_MOVE(_config))
+        {}
+        ~StreamingReporterBase() override;
+
+        void benchmarkPreparing( StringRef ) override {}
+        void benchmarkStarting( BenchmarkInfo const& ) override {}
+        void benchmarkEnded( BenchmarkStats<> const& ) override {}
+        void benchmarkFailed( StringRef ) override {}
+
+        void fatalErrorEncountered( StringRef /*error*/ ) override {}
+        void noMatchingTestCases( StringRef /*unmatchedSpec*/ ) override {}
+        void reportInvalidTestSpec( StringRef /*invalidArgument*/ ) override {}
+
+        void testRunStarting( TestRunInfo const& _testRunInfo ) override;
+
+        void testCaseStarting(TestCaseInfo const& _testInfo) override  {
+            currentTestCaseInfo = &_testInfo;
+        }
+        void testCasePartialStarting( TestCaseInfo const&, uint64_t ) override {}
+        void sectionStarting(SectionInfo const& _sectionInfo) override {
+            m_sectionStack.push_back(_sectionInfo);
+        }
+
+        void assertionStarting( AssertionInfo const& ) override {}
+        void assertionEnded( AssertionStats const& ) override {}
+
+        void sectionEnded(SectionStats const& /* _sectionStats */) override {
+            m_sectionStack.pop_back();
+        }
+        void testCasePartialEnded( TestCaseStats const&, uint64_t ) override {}
+        void testCaseEnded(TestCaseStats const& /* _testCaseStats */) override {
+            currentTestCaseInfo = nullptr;
+        }
+        void testRunEnded( TestRunStats const& /* _testRunStats */ ) override;
+
+        void skipTest(TestCaseInfo const&) override {
+            // Don't do anything with this by default.
+            // It can optionally be overridden in the derived class.
+        }
+
+    protected:
+        TestRunInfo currentTestRunInfo{ "test run has not started yet"_sr };
+        TestCaseInfo const* currentTestCaseInfo = nullptr;
+
+        //! Stack of all _active_ sections in the _current_ test case
+        std::vector<SectionInfo> m_sectionStack;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_STREAMING_BASE_HPP_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    class AutomakeReporter final : public StreamingReporterBase {
+    public:
+        // GCC5 compat: we cannot use inherited constructor, because it
+        //              doesn't implement backport of P0136
+        AutomakeReporter(ReporterConfig&& _config):
+            StreamingReporterBase(CATCH_MOVE(_config))
+        {}
+        ~AutomakeReporter() override;
+
+        static std::string getDescription() {
+            using namespace std::string_literals;
+            return "Reports test results in the format of Automake .trs files"s;
+        }
+
+        void testCaseEnded(TestCaseStats const& _testCaseStats) override;
+        void skipTest(TestCaseInfo const& testInfo) override;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_COMPACT_HPP_INCLUDED
+#define CATCH_REPORTER_COMPACT_HPP_INCLUDED
+
+
+
+
+namespace Catch {
+
+    class CompactReporter final : public StreamingReporterBase {
+    public:
+        using StreamingReporterBase::StreamingReporterBase;
+
+        ~CompactReporter() override;
+
+        static std::string getDescription();
+
+        void noMatchingTestCases( StringRef unmatchedSpec ) override;
+
+        void testRunStarting( TestRunInfo const& _testInfo ) override;
+
+        void assertionEnded(AssertionStats const& _assertionStats) override;
+
+        void sectionEnded(SectionStats const& _sectionStats) override;
+
+        void testRunEnded(TestRunStats const& _testRunStats) override;
+
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_COMPACT_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_CONSOLE_HPP_INCLUDED
+#define CATCH_REPORTER_CONSOLE_HPP_INCLUDED
+
+
+namespace Catch {
+    // Fwd decls
+    struct SummaryColumn;
+    class TablePrinter;
+
+    class ConsoleReporter final : public StreamingReporterBase {
+        Detail::unique_ptr<TablePrinter> m_tablePrinter;
+
+    public:
+        ConsoleReporter(ReporterConfig&& config);
+        ~ConsoleReporter() override;
+        static std::string getDescription();
+
+        void noMatchingTestCases( StringRef unmatchedSpec ) override;
+        void reportInvalidTestSpec( StringRef arg ) override;
+
+        void assertionStarting(AssertionInfo const&) override;
+
+        void assertionEnded(AssertionStats const& _assertionStats) override;
+
+        void sectionStarting(SectionInfo const& _sectionInfo) override;
+        void sectionEnded(SectionStats const& _sectionStats) override;
+
+        void benchmarkPreparing( StringRef name ) override;
+        void benchmarkStarting(BenchmarkInfo const& info) override;
+        void benchmarkEnded(BenchmarkStats<> const& stats) override;
+        void benchmarkFailed( StringRef error ) override;
+
+        void testCaseEnded(TestCaseStats const& _testCaseStats) override;
+        void testRunEnded(TestRunStats const& _testRunStats) override;
+        void testRunStarting(TestRunInfo const& _testRunInfo) override;
+
+    private:
+        void lazyPrint();
+
+        void lazyPrintWithoutClosingBenchmarkTable();
+        void lazyPrintRunInfo();
+        void printTestCaseAndSectionHeader();
+
+        void printClosedHeader(std::string const& _name);
+        void printOpenHeader(std::string const& _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);
+
+
+        void printTotals(Totals const& totals);
+        void printSummaryRow(StringRef label, std::vector<SummaryColumn> const& cols, std::size_t row);
+
+        void printTotalsDivider(Totals const& totals);
+        void printSummaryDivider();
+
+        bool m_headerPrinted = false;
+        bool m_testRunInfoPrinted = false;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_CONSOLE_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_CUMULATIVE_BASE_HPP_INCLUDED
+#define CATCH_REPORTER_CUMULATIVE_BASE_HPP_INCLUDED
+
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+    namespace Detail {
+
+        //! Represents either an assertion or a benchmark result to be handled by cumulative reporter later
+        class AssertionOrBenchmarkResult {
+            // This should really be a variant, but this is much faster
+            // to write and the data layout here is already terrible
+            // enough that we do not have to care about the object size.
+            Optional<AssertionStats> m_assertion;
+            Optional<BenchmarkStats<>> m_benchmark;
+        public:
+            AssertionOrBenchmarkResult(AssertionStats const& assertion);
+            AssertionOrBenchmarkResult(BenchmarkStats<> const& benchmark);
+
+            bool isAssertion() const;
+            bool isBenchmark() const;
+
+            AssertionStats const& asAssertion() const;
+            BenchmarkStats<> const& asBenchmark() const;
+        };
+    }
+
+    /**
+     * Utility base for reporters that need to handle all results at once
+     *
+     * It stores tree of all test cases, sections and assertions, and after the
+     * test run is finished, calls into `testRunEndedCumulative` to pass the
+     * control to the deriving class.
+     *
+     * If you are deriving from this class and override any testing related
+     * member functions, you should first call into the base's implementation to
+     * avoid breaking the tree construction.
+     *
+     * Due to the way this base functions, it has to expand assertions up-front,
+     * even if they are later unused (e.g. because the deriving reporter does
+     * not report successful assertions, or because the deriving reporter does
+     * not use assertion expansion at all). Derived classes can use two
+     * customization points, `m_shouldStoreSuccesfulAssertions` and
+     * `m_shouldStoreFailedAssertions`, to disable the expansion and gain extra
+     * performance. **Accessing the assertion expansions if it wasn't stored is
+     * UB.**
+     */
+    class CumulativeReporterBase : public ReporterBase {
+    public:
+        template<typename T, typename ChildNodeT>
+        struct Node {
+            explicit Node( T const& _value ) : value( _value ) {}
+
+            using ChildNodes = std::vector<Detail::unique_ptr<ChildNodeT>>;
+            T value;
+            ChildNodes children;
+        };
+        struct SectionNode {
+            explicit SectionNode(SectionStats const& _stats) : stats(_stats) {}
+
+            bool operator == (SectionNode const& other) const {
+                return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
+            }
+
+            bool hasAnyAssertions() const;
+
+            SectionStats stats;
+            std::vector<Detail::unique_ptr<SectionNode>> childSections;
+            std::vector<Detail::AssertionOrBenchmarkResult> assertionsAndBenchmarks;
+            std::string stdOut;
+            std::string stdErr;
+        };
+
+
+        using TestCaseNode = Node<TestCaseStats, SectionNode>;
+        using TestRunNode = Node<TestRunStats, TestCaseNode>;
+
+        // GCC5 compat: we cannot use inherited constructor, because it
+        //              doesn't implement backport of P0136
+        CumulativeReporterBase(ReporterConfig&& _config):
+            ReporterBase(CATCH_MOVE(_config))
+        {}
+        ~CumulativeReporterBase() override;
+
+        void benchmarkPreparing( StringRef ) override {}
+        void benchmarkStarting( BenchmarkInfo const& ) override {}
+        void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
+        void benchmarkFailed( StringRef ) override {}
+
+        void noMatchingTestCases( StringRef ) override {}
+        void reportInvalidTestSpec( StringRef ) override {}
+        void fatalErrorEncountered( StringRef /*error*/ ) override {}
+
+        void testRunStarting( TestRunInfo const& ) override {}
+
+        void testCaseStarting( TestCaseInfo const& ) override {}
+        void testCasePartialStarting( TestCaseInfo const&, uint64_t ) override {}
+        void sectionStarting( SectionInfo const& sectionInfo ) override;
+
+        void assertionStarting( AssertionInfo const& ) override {}
+
+        void assertionEnded( AssertionStats const& assertionStats ) override;
+        void sectionEnded( SectionStats const& sectionStats ) override;
+        void testCasePartialEnded( TestCaseStats const&, uint64_t ) override {}
+        void testCaseEnded( TestCaseStats const& testCaseStats ) override;
+        void testRunEnded( TestRunStats const& testRunStats ) override;
+        //! Customization point: called after last test finishes (testRunEnded has been handled)
+        virtual void testRunEndedCumulative() = 0;
+
+        void skipTest(TestCaseInfo const&) override {}
+
+    protected:
+        //! Should the cumulative base store the assertion expansion for succesful assertions?
+        bool m_shouldStoreSuccesfulAssertions = true;
+        //! Should the cumulative base store the assertion expansion for failed assertions?
+        bool m_shouldStoreFailedAssertions = true;
+
+        // We need lazy construction here. We should probably refactor it
+        // later, after the events are redone.
+        //! The root node of the test run tree.
+        Detail::unique_ptr<TestRunNode> m_testRun;
+
+    private:
+        // Note: We rely on pointer identity being stable, which is why
+        //       we store pointers to the nodes rather than the values.
+        std::vector<Detail::unique_ptr<TestCaseNode>> m_testCases;
+        // Root section of the _current_ test case
+        Detail::unique_ptr<SectionNode> m_rootSection;
+        // Deepest section of the _current_ test case
+        SectionNode* m_deepestSection = nullptr;
+        // Stack of _active_ sections in the _current_ test case
+        std::vector<SectionNode*> m_sectionStack;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_CUMULATIVE_BASE_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_EVENT_LISTENER_HPP_INCLUDED
+#define CATCH_REPORTER_EVENT_LISTENER_HPP_INCLUDED
+
+
+namespace Catch {
+
+    /**
+     * Base class to simplify implementing listeners.
+     *
+     * Provides empty default implementation for all IEventListener member
+     * functions, so that a listener implementation can pick which
+     * member functions it actually cares about.
+     */
+    class EventListenerBase : public IEventListener {
+    public:
+        using IEventListener::IEventListener;
+
+        void reportInvalidTestSpec( StringRef unmatchedSpec ) override;
+        void fatalErrorEncountered( StringRef error ) override;
+
+        void benchmarkPreparing( StringRef name ) override;
+        void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
+        void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
+        void benchmarkFailed( StringRef error ) override;
+
+        void assertionStarting( AssertionInfo const& assertionInfo ) override;
+        void assertionEnded( AssertionStats const& assertionStats ) override;
+
+        void listReporters(
+            std::vector<ReporterDescription> const& descriptions ) override;
+        void listListeners(
+            std::vector<ListenerDescription> const& descriptions ) override;
+        void listTests( std::vector<TestCaseHandle> const& tests ) override;
+        void listTags( std::vector<TagInfo> const& tagInfos ) override;
+
+        void noMatchingTestCases( StringRef unmatchedSpec ) override;
+        void testRunStarting( TestRunInfo const& testRunInfo ) override;
+        void testCaseStarting( TestCaseInfo const& testInfo ) override;
+        void testCasePartialStarting( TestCaseInfo const& testInfo,
+                                      uint64_t partNumber ) override;
+        void sectionStarting( SectionInfo const& sectionInfo ) override;
+        void sectionEnded( SectionStats const& sectionStats ) override;
+        void testCasePartialEnded( TestCaseStats const& testCaseStats,
+                                   uint64_t partNumber ) override;
+        void testCaseEnded( TestCaseStats const& testCaseStats ) override;
+        void testRunEnded( TestRunStats const& testRunStats ) override;
+        void skipTest( TestCaseInfo const& testInfo ) override;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_EVENT_LISTENER_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_HELPERS_HPP_INCLUDED
+#define CATCH_REPORTER_HELPERS_HPP_INCLUDED
+
+#include <iosfwd>
+#include <string>
+#include <vector>
+
+
+namespace Catch {
+
+    class IConfig;
+    class TestCaseHandle;
+    class ColourImpl;
+
+    // Returns double formatted as %.3f (format expected on output)
+    std::string getFormattedDuration( double duration );
+
+    //! Should the reporter show duration of test given current configuration?
+    bool shouldShowDuration( IConfig const& config, double duration );
+
+    std::string serializeFilters( std::vector<std::string> const& filters );
+
+    struct lineOfChars {
+        char c;
+        constexpr lineOfChars( char c_ ): c( c_ ) {}
+
+        friend std::ostream& operator<<( std::ostream& out, lineOfChars value );
+    };
+
+    /**
+     * Lists reporter descriptions to the provided stream in user-friendly
+     * format
+     *
+     * Used as the default listing implementation by the first party reporter
+     * bases. The output should be backwards compatible with the output of
+     * Catch2 v2 binaries.
+     */
+    void
+    defaultListReporters( std::ostream& out,
+                          std::vector<ReporterDescription> const& descriptions,
+                          Verbosity verbosity );
+
+    /**
+     * Lists listeners descriptions to the provided stream in user-friendly
+     * format
+     */
+    void defaultListListeners( std::ostream& out,
+                               std::vector<ListenerDescription> const& descriptions );
+
+    /**
+     * Lists tag information to the provided stream in user-friendly format
+     *
+     * Used as the default listing implementation by the first party reporter
+     * bases. The output should be backwards compatible with the output of
+     * Catch2 v2 binaries.
+     */
+    void defaultListTags( std::ostream& out, std::vector<TagInfo> const& tags, bool isFiltered );
+
+    /**
+     * Lists test case information to the provided stream in user-friendly
+     * format
+     *
+     * Used as the default listing implementation by the first party reporter
+     * bases. The output is backwards compatible with the output of Catch2
+     * v2 binaries, and also supports the format specific to the old
+     * `--list-test-names-only` option, for people who used it in integrations.
+     */
+    void defaultListTests( std::ostream& out,
+                           ColourImpl* streamColour,
+                           std::vector<TestCaseHandle> const& tests,
+                           bool isFiltered,
+                           Verbosity verbosity );
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_HELPERS_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_JUNIT_HPP_INCLUDED
+#define CATCH_REPORTER_JUNIT_HPP_INCLUDED
+
+
+
+namespace Catch {
+
+    class JunitReporter final : public CumulativeReporterBase {
+    public:
+        JunitReporter(ReporterConfig&& _config);
+
+        ~JunitReporter() override = default;
+
+        static std::string getDescription();
+
+        void testRunStarting(TestRunInfo const& runInfo) override;
+
+        void testCaseStarting(TestCaseInfo const& testCaseInfo) override;
+        void assertionEnded(AssertionStats const& assertionStats) override;
+
+        void testCaseEnded(TestCaseStats const& testCaseStats) override;
+
+        void testRunEndedCumulative() override;
+
+    private:
+        void writeRun(TestRunNode const& testRunNode, double suiteTime);
+
+        void writeTestCase(TestCaseNode const& testCaseNode);
+
+        void writeSection( std::string const& className,
+                           std::string const& rootName,
+                           SectionNode const& sectionNode,
+                           bool testOkToFail );
+
+        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
+
+#endif // CATCH_REPORTER_JUNIT_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_MULTI_HPP_INCLUDED
+#define CATCH_REPORTER_MULTI_HPP_INCLUDED
+
+
+namespace Catch {
+
+    class MultiReporter final : public IEventListener {
+        /*
+         * Stores all added reporters and listeners
+         *
+         * All Listeners are stored before all reporters, and individual
+         * listeners/reporters are stored in order of insertion.
+         */
+        std::vector<IEventListenerPtr> m_reporterLikes;
+        bool m_haveNoncapturingReporters = false;
+
+        // Keep track of how many listeners we have already inserted,
+        // so that we can insert them into the main vector at the right place
+        size_t m_insertedListeners = 0;
+
+        void updatePreferences(IEventListener const& reporterish);
+
+    public:
+        using IEventListener::IEventListener;
+
+        void addListener( IEventListenerPtr&& listener );
+        void addReporter( IEventListenerPtr&& reporter );
+
+    public: // IEventListener
+
+        void noMatchingTestCases( StringRef unmatchedSpec ) override;
+        void fatalErrorEncountered( StringRef error ) override;
+        void reportInvalidTestSpec( StringRef arg ) override;
+
+        void benchmarkPreparing( StringRef name ) override;
+        void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
+        void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
+        void benchmarkFailed( StringRef error ) override;
+
+        void testRunStarting( TestRunInfo const& testRunInfo ) override;
+        void testCaseStarting( TestCaseInfo const& testInfo ) override;
+        void testCasePartialStarting(TestCaseInfo const& testInfo, uint64_t partNumber) override;
+        void sectionStarting( SectionInfo const& sectionInfo ) override;
+        void assertionStarting( AssertionInfo const& assertionInfo ) override;
+
+        void assertionEnded( AssertionStats const& assertionStats ) override;
+        void sectionEnded( SectionStats const& sectionStats ) override;
+        void testCasePartialEnded(TestCaseStats const& testInfo, uint64_t partNumber) override;
+        void testCaseEnded( TestCaseStats const& testCaseStats ) override;
+        void testRunEnded( TestRunStats const& testRunStats ) override;
+
+        void skipTest( TestCaseInfo const& testInfo ) override;
+
+        void listReporters(std::vector<ReporterDescription> const& descriptions) override;
+        void listListeners(std::vector<ListenerDescription> const& descriptions) override;
+        void listTests(std::vector<TestCaseHandle> const& tests) override;
+        void listTags(std::vector<TagInfo> const& tags) override;
+
+
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_MULTI_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
+#define CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
+
+
+#include <type_traits>
+
+namespace Catch {
+
+    namespace Detail {
+
+        template <typename T, typename = void>
+        struct has_description : std::false_type {};
+
+        template <typename T>
+        struct has_description<
+            T,
+            void_t<decltype( T::getDescription() )>>
+            : std::true_type {};
+
+        //! Indirection for reporter registration, so that the error handling is
+        //! independent on the reporter's concrete type
+        void registerReporterImpl( std::string const& name,
+                                   IReporterFactoryPtr reporterPtr );
+
+    } // namespace Detail
+
+    class IEventListener;
+    using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
+
+    template <typename T>
+    class ReporterFactory : public IReporterFactory {
+
+        IEventListenerPtr create( ReporterConfig&& config ) const override {
+            return Detail::make_unique<T>( CATCH_MOVE(config) );
+        }
+
+        std::string getDescription() const override {
+            return T::getDescription();
+        }
+    };
+
+
+    template<typename T>
+    class ReporterRegistrar {
+    public:
+        explicit ReporterRegistrar( std::string const& name ) {
+            registerReporterImpl( name,
+                                  Detail::make_unique<ReporterFactory<T>>() );
+        }
+    };
+
+    template<typename T>
+    class ListenerRegistrar {
+
+        class TypedListenerFactory : public EventListenerFactory {
+            StringRef m_listenerName;
+
+            std::string getDescriptionImpl( std::true_type ) const {
+                return T::getDescription();
+            }
+
+            std::string getDescriptionImpl( std::false_type ) const {
+                return "(No description provided)";
+            }
+
+        public:
+            TypedListenerFactory( StringRef listenerName ):
+                m_listenerName( listenerName ) {}
+
+            IEventListenerPtr create( IConfig const* config ) const override {
+                return Detail::make_unique<T>( config );
+            }
+
+            StringRef getName() const override {
+                return m_listenerName;
+            }
+
+            std::string getDescription() const override {
+                return getDescriptionImpl( Detail::has_description<T>{} );
+            }
+        };
+
+    public:
+        ListenerRegistrar(StringRef listenerName) {
+            getMutableRegistryHub().registerListener( Detail::make_unique<TypedListenerFactory>(listenerName) );
+        }
+    };
+}
+
+#if !defined(CATCH_CONFIG_DISABLE)
+
+#    define CATCH_REGISTER_REPORTER( name, reporterType )                      \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                              \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                               \
+        namespace {                                                            \
+            Catch::ReporterRegistrar<reporterType> INTERNAL_CATCH_UNIQUE_NAME( \
+                catch_internal_RegistrarFor )( name );                         \
+        }                                                                      \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+#    define CATCH_REGISTER_LISTENER( listenerType )                            \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                              \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                               \
+        namespace {                                                            \
+            Catch::ListenerRegistrar<listenerType> INTERNAL_CATCH_UNIQUE_NAME( \
+                catch_internal_RegistrarFor )( #listenerType );                \
+        }                                                                      \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+#else // CATCH_CONFIG_DISABLE
+
+#define CATCH_REGISTER_REPORTER(name, reporterType)
+#define CATCH_REGISTER_LISTENER(listenerType)
+
+#endif // CATCH_CONFIG_DISABLE
+
+#endif // CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
+#define CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
+
+
+
+namespace Catch {
+
+    class SonarQubeReporter final : public CumulativeReporterBase {
+    public:
+        SonarQubeReporter(ReporterConfig&& config)
+        : CumulativeReporterBase(CATCH_MOVE(config))
+        , xml(m_stream) {
+            m_preferences.shouldRedirectStdOut = true;
+            m_preferences.shouldReportAllAssertions = true;
+            m_shouldStoreSuccesfulAssertions = false;
+        }
+
+        ~SonarQubeReporter() override = default;
+
+        static std::string getDescription() {
+            using namespace std::string_literals;
+            return "Reports test results in the Generic Test Data SonarQube XML format"s;
+        }
+
+        void testRunStarting( TestRunInfo const& testRunInfo ) override;
+
+        void testRunEndedCumulative() override {
+            writeRun( *m_testRun );
+            xml.endElement();
+        }
+
+        void writeRun( TestRunNode const& groupNode );
+
+        void writeTestFile(std::string const& filename, std::vector<TestCaseNode const*> const& testCaseNodes);
+
+        void writeTestCase(TestCaseNode const& testCaseNode);
+
+        void writeSection(std::string const& rootName, SectionNode const& sectionNode, bool okToFail);
+
+        void writeAssertions(SectionNode const& sectionNode, bool okToFail);
+
+        void writeAssertion(AssertionStats const& stats, bool okToFail);
+
+    private:
+        XmlWriter xml;
+    };
+
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_TAP_HPP_INCLUDED
+#define CATCH_REPORTER_TAP_HPP_INCLUDED
+
+
+namespace Catch {
+
+    class TAPReporter final : public StreamingReporterBase {
+    public:
+        TAPReporter( ReporterConfig&& config ):
+            StreamingReporterBase( CATCH_MOVE(config) ) {
+            m_preferences.shouldReportAllAssertions = true;
+        }
+        ~TAPReporter() override = default;
+
+        static std::string getDescription() {
+            using namespace std::string_literals;
+            return "Reports test results in TAP format, suitable for test harnesses"s;
+        }
+
+        void testRunStarting( TestRunInfo const& testInfo ) override;
+
+        void noMatchingTestCases( StringRef unmatchedSpec ) override;
+
+        void assertionEnded(AssertionStats const& _assertionStats) override;
+
+        void testRunEnded(TestRunStats const& _testRunStats) override;
+
+    private:
+        std::size_t counter = 0;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_TAP_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
+#define CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
+
+
+#include <cstring>
+
+#ifdef __clang__
+#   pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+namespace Catch {
+
+    class TeamCityReporter final : public StreamingReporterBase {
+    public:
+        TeamCityReporter( ReporterConfig&& _config )
+        :   StreamingReporterBase( CATCH_MOVE(_config) )
+        {
+            m_preferences.shouldRedirectStdOut = true;
+        }
+
+        ~TeamCityReporter() override;
+
+        static std::string getDescription() {
+            using namespace std::string_literals;
+            return "Reports test results as TeamCity service messages"s;
+        }
+
+        void testRunStarting( TestRunInfo const& groupInfo ) override;
+        void testRunEnded( TestRunStats const& testGroupStats ) override;
+
+
+        void assertionEnded(AssertionStats const& assertionStats) override;
+
+        void sectionStarting(SectionInfo const& sectionInfo) override {
+            m_headerPrintedForThisSection = false;
+            StreamingReporterBase::sectionStarting( sectionInfo );
+        }
+
+        void testCaseStarting(TestCaseInfo const& testInfo) override;
+
+        void testCaseEnded(TestCaseStats const& testCaseStats) override;
+
+    private:
+        void printSectionHeader(std::ostream& os);
+
+        bool m_headerPrintedForThisSection = false;
+        Timer m_testTimer;
+    };
+
+} // end namespace Catch
+
+#ifdef __clang__
+#   pragma clang diagnostic pop
+#endif
+
+#endif // CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_XML_HPP_INCLUDED
+#define CATCH_REPORTER_XML_HPP_INCLUDED
+
+
+
+
+namespace Catch {
+    class XmlReporter : public StreamingReporterBase {
+    public:
+        XmlReporter(ReporterConfig&& _config);
+
+        ~XmlReporter() override;
+
+        static std::string getDescription();
+
+        virtual std::string getStylesheetRef() const;
+
+        void writeSourceInfo(SourceLineInfo const& sourceInfo);
+
+    public: // StreamingReporterBase
+
+        void testRunStarting(TestRunInfo const& testInfo) override;
+
+        void testCaseStarting(TestCaseInfo const& testInfo) override;
+
+        void sectionStarting(SectionInfo const& sectionInfo) override;
+
+        void assertionStarting(AssertionInfo const&) override;
+
+        void assertionEnded(AssertionStats const& assertionStats) override;
+
+        void sectionEnded(SectionStats const& sectionStats) override;
+
+        void testCaseEnded(TestCaseStats const& testCaseStats) override;
+
+        void testRunEnded(TestRunStats const& testRunStats) override;
+
+        void benchmarkPreparing( StringRef name ) override;
+        void benchmarkStarting(BenchmarkInfo const&) override;
+        void benchmarkEnded(BenchmarkStats<> const&) override;
+        void benchmarkFailed( StringRef error ) override;
+
+        void listReporters(std::vector<ReporterDescription> const& descriptions) override;
+        void listListeners(std::vector<ListenerDescription> const& descriptions) override;
+        void listTests(std::vector<TestCaseHandle> const& tests) override;
+        void listTags(std::vector<TagInfo> const& tags) override;
+
+    private:
+        Timer m_testCaseTimer;
+        XmlWriter m_xml;
+        int m_sectionDepth = 0;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_XML_HPP_INCLUDED
+
+#endif // CATCH_REPORTERS_ALL_HPP_INCLUDED
+
+#endif // CATCH_ALL_HPP_INCLUDED
+#endif // CATCH_AMALGAMATED_HPP_INCLUDED
diff --git a/Tests/Detour/Tests_Detour.cpp b/Tests/Detour/Tests_Detour.cpp
index 252be20e7..0e7d30a37 100644
--- a/Tests/Detour/Tests_Detour.cpp
+++ b/Tests/Detour/Tests_Detour.cpp
@@ -1,4 +1,4 @@
-#include "catch.hpp"
+#include "catch_amalgamated.hpp"
 
 #include "DetourCommon.h"
 
@@ -16,18 +16,18 @@ TEST_CASE("dtRandomPointInConvexPoly")
 		float out[3];
 
 		dtRandomPointInConvexPoly(pts, npts, areas, 0.0f, 1.0f, out);
-		REQUIRE(out[0] == Approx(0));
-		REQUIRE(out[1] == Approx(0));
-		REQUIRE(out[2] == Approx(1));
+		REQUIRE(out[0] == Catch::Approx(0));
+		REQUIRE(out[1] == Catch::Approx(0));
+		REQUIRE(out[2] == Catch::Approx(1));
 
 		dtRandomPointInConvexPoly(pts, npts, areas, 0.5f, 1.0f, out);
-		REQUIRE(out[0] == Approx(1.0f / 2));
-		REQUIRE(out[1] == Approx(0));
-		REQUIRE(out[2] == Approx(1.0f / 2));
+		REQUIRE(out[0] == Catch::Approx(1.0f / 2));
+		REQUIRE(out[1] == Catch::Approx(0));
+		REQUIRE(out[2] == Catch::Approx(1.0f / 2));
 
 		dtRandomPointInConvexPoly(pts, npts, areas, 1.0f, 1.0f, out);
-		REQUIRE(out[0] == Approx(1));
-		REQUIRE(out[1] == Approx(0));
-		REQUIRE(out[2] == Approx(0));
+		REQUIRE(out[0] == Catch::Approx(1));
+		REQUIRE(out[1] == Catch::Approx(0));
+		REQUIRE(out[2] == Catch::Approx(0));
 	}
 }
diff --git a/Tests/Recast/Tests_Recast.cpp b/Tests/Recast/Tests_Recast.cpp
index 7c12bc773..e21995941 100644
--- a/Tests/Recast/Tests_Recast.cpp
+++ b/Tests/Recast/Tests_Recast.cpp
@@ -1,7 +1,7 @@
 #include <stdio.h>
 #include <string.h>
 
-#include "catch.hpp"
+#include "catch_amalgamated.hpp"
 
 #include "Recast.h"
 #include "RecastAlloc.h"
@@ -92,8 +92,8 @@ TEST_CASE("rcSqrt")
 {
 	SECTION("Sqrt gets the sqrt of a number")
 	{
-		REQUIRE(rcSqrt(4) == Approx(2));
-		REQUIRE(rcSqrt(81) == Approx(9));
+		REQUIRE(rcSqrt(4) == Catch::Approx(2));
+		REQUIRE(rcSqrt(81) == Catch::Approx(9));
 	}
 }
 
@@ -105,9 +105,9 @@ TEST_CASE("rcVcross")
 		float v2[3] = {4, 9, 2};
 		float result[3];
 		rcVcross(result, v1, v2);
-		REQUIRE(result[0] == Approx(-15));
-		REQUIRE(result[1] == Approx(-2));
-		REQUIRE(result[2] == Approx(39));
+		REQUIRE(result[0] == Catch::Approx(-15));
+		REQUIRE(result[1] == Catch::Approx(-2));
+		REQUIRE(result[2] == Catch::Approx(39));
 	}
 
 	SECTION("Cross product with itself is zero")
@@ -115,9 +115,9 @@ TEST_CASE("rcVcross")
 		float v1[3] = {3, -3, 1};
 		float result[3];
 		rcVcross(result, v1, v1);
-		REQUIRE(result[0] == Approx(0));
-		REQUIRE(result[1] == Approx(0));
-		REQUIRE(result[2] == Approx(0));
+		REQUIRE(result[0] == Catch::Approx(0));
+		REQUIRE(result[1] == Catch::Approx(0));
+		REQUIRE(result[2] == Catch::Approx(0));
 	}
 }
 
@@ -127,7 +127,7 @@ TEST_CASE("rcVdot")
 	{
 		float v1[] = { 1, 0, 0 };
 		float result = rcVdot(v1, v1);
-		REQUIRE(result == Approx(1));
+		REQUIRE(result == Catch::Approx(1));
 	}
 
 	SECTION("Dot zero vector with anything is zero")
@@ -136,7 +136,7 @@ TEST_CASE("rcVdot")
 		float v2[] = { 0, 0, 0 };
 
 		float result = rcVdot(v1, v2);
-		REQUIRE(result == Approx(0));
+		REQUIRE(result == Catch::Approx(0));
 	}
 }
 
@@ -148,9 +148,9 @@ TEST_CASE("rcVmad")
 		float v2[3] = {0, 2, 4};
 		float result[3];
 		rcVmad(result, v1, v2, 2);
-		REQUIRE(result[0] == Approx(1));
-		REQUIRE(result[1] == Approx(6));
-		REQUIRE(result[2] == Approx(11));
+		REQUIRE(result[0] == Catch::Approx(1));
+		REQUIRE(result[1] == Catch::Approx(6));
+		REQUIRE(result[2] == Catch::Approx(11));
 	}
 
 	SECTION("second vector is scaled, first is not")
@@ -159,9 +159,9 @@ TEST_CASE("rcVmad")
 		float v2[3] = {5, 6, 7};
 		float result[3];
 		rcVmad(result, v1, v2, 0);
-		REQUIRE(result[0] == Approx(1));
-		REQUIRE(result[1] == Approx(2));
-		REQUIRE(result[2] == Approx(3));
+		REQUIRE(result[0] == Catch::Approx(1));
+		REQUIRE(result[1] == Catch::Approx(2));
+		REQUIRE(result[2] == Catch::Approx(3));
 	}
 }
 
@@ -173,9 +173,9 @@ TEST_CASE("rcVadd")
 		float v2[3] = {5, 6, 7};
 		float result[3];
 		rcVadd(result, v1, v2);
-		REQUIRE(result[0] == Approx(6));
-		REQUIRE(result[1] == Approx(8));
-		REQUIRE(result[2] == Approx(10));
+		REQUIRE(result[0] == Catch::Approx(6));
+		REQUIRE(result[1] == Catch::Approx(8));
+		REQUIRE(result[2] == Catch::Approx(10));
 	}
 }
 
@@ -187,9 +187,9 @@ TEST_CASE("rcVsub")
 		float v2[3] = {1, 2, 3};
 		float result[3];
 		rcVsub(result, v1, v2);
-		REQUIRE(result[0] == Approx(4));
-		REQUIRE(result[1] == Approx(2));
-		REQUIRE(result[2] == Approx(0));
+		REQUIRE(result[0] == Catch::Approx(4));
+		REQUIRE(result[1] == Catch::Approx(2));
+		REQUIRE(result[2] == Catch::Approx(0));
 	}
 }
 
@@ -200,9 +200,9 @@ TEST_CASE("rcVmin")
 		float v1[3] = {5, 4, 0};
 		float v2[3] = {1, 2, 9};
 		rcVmin(v1, v2);
-		REQUIRE(v1[0] == Approx(1));
-		REQUIRE(v1[1] == Approx(2));
-		REQUIRE(v1[2] == Approx(0));
+		REQUIRE(v1[0] == Catch::Approx(1));
+		REQUIRE(v1[1] == Catch::Approx(2));
+		REQUIRE(v1[2] == Catch::Approx(0));
 	}
 
 	SECTION("v1 is min")
@@ -210,9 +210,9 @@ TEST_CASE("rcVmin")
 		float v1[3] = {1, 2, 3};
 		float v2[3] = {4, 5, 6};
 		rcVmin(v1, v2);
-		REQUIRE(v1[0] == Approx(1));
-		REQUIRE(v1[1] == Approx(2));
-		REQUIRE(v1[2] == Approx(3));
+		REQUIRE(v1[0] == Catch::Approx(1));
+		REQUIRE(v1[1] == Catch::Approx(2));
+		REQUIRE(v1[2] == Catch::Approx(3));
 	}
 
 	SECTION("v2 is min")
@@ -220,9 +220,9 @@ TEST_CASE("rcVmin")
 		float v1[3] = {4, 5, 6};
 		float v2[3] = {1, 2, 3};
 		rcVmin(v1, v2);
-		REQUIRE(v1[0] == Approx(1));
-		REQUIRE(v1[1] == Approx(2));
-		REQUIRE(v1[2] == Approx(3));
+		REQUIRE(v1[0] == Catch::Approx(1));
+		REQUIRE(v1[1] == Catch::Approx(2));
+		REQUIRE(v1[2] == Catch::Approx(3));
 	}
 }
 
@@ -233,9 +233,9 @@ TEST_CASE("rcVmax")
 		float v1[3] = {5, 4, 0};
 		float v2[3] = {1, 2, 9};
 		rcVmax(v1, v2);
-		REQUIRE(v1[0] == Approx(5));
-		REQUIRE(v1[1] == Approx(4));
-		REQUIRE(v1[2] == Approx(9));
+		REQUIRE(v1[0] == Catch::Approx(5));
+		REQUIRE(v1[1] == Catch::Approx(4));
+		REQUIRE(v1[2] == Catch::Approx(9));
 	}
 
 	SECTION("v2 is max")
@@ -243,9 +243,9 @@ TEST_CASE("rcVmax")
 		float v1[3] = {1, 2, 3};
 		float v2[3] = {4, 5, 6};
 		rcVmax(v1, v2);
-		REQUIRE(v1[0] == Approx(4));
-		REQUIRE(v1[1] == Approx(5));
-		REQUIRE(v1[2] == Approx(6));
+		REQUIRE(v1[0] == Catch::Approx(4));
+		REQUIRE(v1[1] == Catch::Approx(5));
+		REQUIRE(v1[2] == Catch::Approx(6));
 	}
 
 	SECTION("v1 is max")
@@ -253,9 +253,9 @@ TEST_CASE("rcVmax")
 		float v1[3] = {4, 5, 6};
 		float v2[3] = {1, 2, 3};
 		rcVmax(v1, v2);
-		REQUIRE(v1[0] == Approx(4));
-		REQUIRE(v1[1] == Approx(5));
-		REQUIRE(v1[2] == Approx(6));
+		REQUIRE(v1[0] == Catch::Approx(4));
+		REQUIRE(v1[1] == Catch::Approx(5));
+		REQUIRE(v1[2] == Catch::Approx(6));
 	}
 }
 
@@ -266,12 +266,12 @@ TEST_CASE("rcVcopy")
 		float v1[3] = {5, 4, 0};
 		float result[3] = {1, 2, 9};
 		rcVcopy(result, v1);
-		REQUIRE(result[0] == Approx(5));
-		REQUIRE(result[1] == Approx(4));
-		REQUIRE(result[2] == Approx(0));
-		REQUIRE(v1[0] == Approx(5));
-		REQUIRE(v1[1] == Approx(4));
-		REQUIRE(v1[2] == Approx(0));
+		REQUIRE(result[0] == Catch::Approx(5));
+		REQUIRE(result[1] == Catch::Approx(4));
+		REQUIRE(result[2] == Catch::Approx(0));
+		REQUIRE(v1[0] == Catch::Approx(5));
+		REQUIRE(v1[1] == Catch::Approx(4));
+		REQUIRE(v1[2] == Catch::Approx(0));
 	}
 }
 
@@ -283,7 +283,7 @@ TEST_CASE("rcVdist")
 		float v2[3] = {1, 3, 1};
 		float result = rcVdist(v1, v2);
 
-		REQUIRE(result == Approx(3.4641f));
+		REQUIRE(result == Catch::Approx(3.4641f));
 	}
 
 	SECTION("Distance from zero is magnitude")
@@ -292,7 +292,7 @@ TEST_CASE("rcVdist")
 		float v2[3] = {0, 0, 0};
 		float distance = rcVdist(v1, v2);
 		float magnitude = rcSqrt(rcSqr(v1[0]) + rcSqr(v1[1]) + rcSqr(v1[2]));
-		REQUIRE(distance == Approx(magnitude));
+		REQUIRE(distance == Catch::Approx(magnitude));
 	}
 }
 
@@ -304,7 +304,7 @@ TEST_CASE("rcVdistSqr")
 		float v2[3] = {1, 3, 1};
 		float result = rcVdistSqr(v1, v2);
 
-		REQUIRE(result == Approx(12));
+		REQUIRE(result == Catch::Approx(12));
 	}
 
 	SECTION("squared distance from zero is squared magnitude")
@@ -313,7 +313,7 @@ TEST_CASE("rcVdistSqr")
 		float v2[3] = {0, 0, 0};
 		float distance = rcVdistSqr(v1, v2);
 		float magnitude = rcSqr(v1[0]) + rcSqr(v1[1]) + rcSqr(v1[2]);
-		REQUIRE(distance == Approx(magnitude));
+		REQUIRE(distance == Catch::Approx(magnitude));
 	}
 }
 
@@ -323,11 +323,11 @@ TEST_CASE("rcVnormalize")
 	{
 		float v[3] = {3, 3, 3};
 		rcVnormalize(v);
-		REQUIRE(v[0] == Approx(rcSqrt(1.0f / 3.0f)));
-		REQUIRE(v[1] == Approx(rcSqrt(1.0f / 3.0f)));
-		REQUIRE(v[2] == Approx(rcSqrt(1.0f / 3.0f)));
+		REQUIRE(v[0] == Catch::Approx(rcSqrt(1.0f / 3.0f)));
+		REQUIRE(v[1] == Catch::Approx(rcSqrt(1.0f / 3.0f)));
+		REQUIRE(v[2] == Catch::Approx(rcSqrt(1.0f / 3.0f)));
 		float magnitude = rcSqrt(rcSqr(v[0]) + rcSqr(v[1]) + rcSqr(v[2]));
-		REQUIRE(magnitude == Approx(1));
+		REQUIRE(magnitude == Catch::Approx(1));
 	}
 }
 
@@ -340,13 +340,13 @@ TEST_CASE("rcCalcBounds")
 		float bmax[3];
 		rcCalcBounds(verts, 1, bmin, bmax);
 
-		REQUIRE(bmin[0] == Approx(verts[0]));
-		REQUIRE(bmin[1] == Approx(verts[1]));
-		REQUIRE(bmin[2] == Approx(verts[2]));
+		REQUIRE(bmin[0] == Catch::Approx(verts[0]));
+		REQUIRE(bmin[1] == Catch::Approx(verts[1]));
+		REQUIRE(bmin[2] == Catch::Approx(verts[2]));
 
-		REQUIRE(bmax[0] == Approx(verts[0]));
-		REQUIRE(bmax[1] == Approx(verts[1]));
-		REQUIRE(bmax[2] == Approx(verts[2]));
+		REQUIRE(bmax[0] == Catch::Approx(verts[0]));
+		REQUIRE(bmax[1] == Catch::Approx(verts[1]));
+		REQUIRE(bmax[2] == Catch::Approx(verts[2]));
 	}
 
 	SECTION("bounds of more than one vector")
@@ -359,13 +359,13 @@ TEST_CASE("rcCalcBounds")
 		float bmax[3];
 		rcCalcBounds(verts, 2, bmin, bmax);
 
-		REQUIRE(bmin[0] == Approx(0));
-		REQUIRE(bmin[1] == Approx(2));
-		REQUIRE(bmin[2] == Approx(3));
+		REQUIRE(bmin[0] == Catch::Approx(0));
+		REQUIRE(bmin[1] == Catch::Approx(2));
+		REQUIRE(bmin[2] == Catch::Approx(3));
 
-		REQUIRE(bmax[0] == Approx(1));
-		REQUIRE(bmax[1] == Approx(2));
-		REQUIRE(bmax[2] == Approx(5));
+		REQUIRE(bmax[0] == Catch::Approx(1));
+		REQUIRE(bmax[1] == Catch::Approx(2));
+		REQUIRE(bmax[2] == Catch::Approx(5));
 	}
 }
 
@@ -422,16 +422,16 @@ TEST_CASE("rcCreateHeightfield")
 		REQUIRE(heightfield.width == width);
 		REQUIRE(heightfield.height == height);
 
-		REQUIRE(heightfield.bmin[0] == Approx(bmin[0]));
-		REQUIRE(heightfield.bmin[1] == Approx(bmin[1]));
-		REQUIRE(heightfield.bmin[2] == Approx(bmin[2]));
+		REQUIRE(heightfield.bmin[0] == Catch::Approx(bmin[0]));
+		REQUIRE(heightfield.bmin[1] == Catch::Approx(bmin[1]));
+		REQUIRE(heightfield.bmin[2] == Catch::Approx(bmin[2]));
 
-		REQUIRE(heightfield.bmax[0] == Approx(bmax[0]));
-		REQUIRE(heightfield.bmax[1] == Approx(bmax[1]));
-		REQUIRE(heightfield.bmax[2] == Approx(bmax[2]));
+		REQUIRE(heightfield.bmax[0] == Catch::Approx(bmax[0]));
+		REQUIRE(heightfield.bmax[1] == Catch::Approx(bmax[1]));
+		REQUIRE(heightfield.bmax[2] == Catch::Approx(bmax[2]));
 
-		REQUIRE(heightfield.cs == Approx(cellSize));
-		REQUIRE(heightfield.ch == Approx(cellHeight));
+		REQUIRE(heightfield.cs == Catch::Approx(cellSize));
+		REQUIRE(heightfield.ch == Catch::Approx(cellHeight));
 
 		REQUIRE(heightfield.spans != 0);
 		REQUIRE(heightfield.pools == 0);
diff --git a/Tests/catch.hpp b/Tests/catch.hpp
deleted file mode 100644
index fdb046fe4..000000000
--- a/Tests/catch.hpp
+++ /dev/null
@@ -1,11689 +0,0 @@
-/*
- *  Catch v1.12.2
- *  Generated: 2018-05-14 15:10:01.112442
- *  ----------------------------------------------------------
- *  This file has been merged from multiple headers. Please don't edit it directly
- *  Copyright (c) 2012 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
-
-#define TWOBLUECUBES_CATCH_HPP_INCLUDED
-
-#ifdef __clang__
-#    pragma clang system_header
-#elif defined __GNUC__
-#    pragma GCC system_header
-#endif
-
-// #included from: internal/catch_suppress_warnings.h
-
-#ifdef __clang__
-#   ifdef __ICC // icpc defines the __clang__ macro
-#       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 "-Wc++98-compat"
-#       pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
-#       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"
-#    pragma GCC diagnostic ignored "-Wparentheses"
-
-#    pragma GCC diagnostic push
-#    pragma GCC diagnostic ignored "-Wpadded"
-#endif
-#if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)
-#  define CATCH_IMPL
-#endif
-
-#ifdef CATCH_IMPL
-#  ifndef CLARA_CONFIG_MAIN
-#    define CLARA_CONFIG_MAIN_NOT_DEFINED
-#    define CLARA_CONFIG_MAIN
-#  endif
-#endif
-
-// #included from: internal/catch_notimplemented_exception.h
-#define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_H_INCLUDED
-
-// #included from: catch_common.h
-#define TWOBLUECUBES_CATCH_COMMON_H_INCLUDED
-
-// #included from: catch_compiler_capabilities.h
-#define TWOBLUECUBES_CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
-
-// Detect a number of compiler features - mostly C++11/14 conformance - by compiler
-// The following features are defined:
-//
-// CATCH_CONFIG_CPP11_NULLPTR : is nullptr supported?
-// CATCH_CONFIG_CPP11_NOEXCEPT : is noexcept supported?
-// CATCH_CONFIG_CPP11_GENERATED_METHODS : The delete and default keywords for compiler generated methods
-// CATCH_CONFIG_CPP11_IS_ENUM : std::is_enum is supported?
-// CATCH_CONFIG_CPP11_TUPLE : std::tuple is supported
-// CATCH_CONFIG_CPP11_LONG_LONG : is long long supported?
-// CATCH_CONFIG_CPP11_OVERRIDE : is override supported?
-// CATCH_CONFIG_CPP11_UNIQUE_PTR : is unique_ptr supported (otherwise use auto_ptr)
-// CATCH_CONFIG_CPP11_SHUFFLE : is std::shuffle supported?
-// CATCH_CONFIG_CPP11_TYPE_TRAITS : are type_traits and enable_if supported?
-
-// CATCH_CONFIG_CPP11_OR_GREATER : Is C++11 supported?
-
-// CATCH_CONFIG_VARIADIC_MACROS : are variadic macros supported?
-// CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported?
-// CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported?
-// CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported?
-// ****************
-// Note to maintainers: if new toggles are added please document them
-// in configuration.md, too
-// ****************
-
-// In general each macro has a _NO_<feature name> form
-// (e.g. CATCH_CONFIG_CPP11_NO_NULLPTR) which disables the feature.
-// Many features, at point of detection, define an _INTERNAL_ macro, so they
-// can be combined, en-mass, with the _NO_ forms later.
-
-// All the C++11 features can be disabled with CATCH_CONFIG_NO_CPP11
-
-#ifdef __cplusplus
-
-#  if __cplusplus >= 201103L
-#    define CATCH_CPP11_OR_GREATER
-#  endif
-
-#  if __cplusplus >= 201402L
-#    define CATCH_CPP14_OR_GREATER
-#  endif
-
-#endif
-
-#ifdef __clang__
-
-#  if __has_feature(cxx_nullptr)
-#    define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR
-#  endif
-
-#  if __has_feature(cxx_noexcept)
-#    define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT
-#  endif
-
-#   if defined(CATCH_CPP11_OR_GREATER)
-#       define CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
-            _Pragma( "clang diagnostic push" ) \
-            _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" )
-#       define CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
-            _Pragma( "clang diagnostic pop" )
-
-#       define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
-            _Pragma( "clang diagnostic push" ) \
-            _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
-#       define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
-            _Pragma( "clang diagnostic pop" )
-#   endif
-
-#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
-
-#endif
-
-#ifdef __OS400__
-#       define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
-#       define CATCH_CONFIG_COLOUR_NONE
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// Cygwin
-#ifdef __CYGWIN__
-
-// 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
-
-#endif // __CYGWIN__
-
-////////////////////////////////////////////////////////////////////////////////
-// Borland
-#ifdef __BORLANDC__
-
-#endif // __BORLANDC__
-
-////////////////////////////////////////////////////////////////////////////////
-// EDG
-#ifdef __EDG_VERSION__
-
-#endif // __EDG_VERSION__
-
-////////////////////////////////////////////////////////////////////////////////
-// Digital Mars
-#ifdef __DMC__
-
-#endif // __DMC__
-
-////////////////////////////////////////////////////////////////////////////////
-// GCC
-#ifdef __GNUC__
-
-#   if __GNUC__ == 4 && __GNUC_MINOR__ >= 6 && defined(__GXX_EXPERIMENTAL_CXX0X__)
-#       define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR
-#   endif
-
-// - otherwise more recent versions define __cplusplus >= 201103L
-// and will get picked up below
-
-#endif // __GNUC__
-
-////////////////////////////////////////////////////////////////////////////////
-// Visual C++
-#ifdef _MSC_VER
-
-#define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
-
-#if (_MSC_VER >= 1600)
-#   define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR
-#   define CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR
-#endif
-
-#if (_MSC_VER >= 1900 ) // (VC++ 13 (VS2015))
-#define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT
-#define CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS
-#define CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE
-#define CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS
-#endif
-
-#endif // _MSC_VER
-
-////////////////////////////////////////////////////////////////////////////////
-
-// Use variadic macros if the compiler supports them
-#if ( defined _MSC_VER && _MSC_VER > 1400 && !defined __EDGE__) || \
-    ( defined __WAVE__ && __WAVE_HAS_VARIADICS ) || \
-    ( defined __GNUC__ && __GNUC__ >= 3 ) || \
-    ( !defined __cplusplus && __STDC_VERSION__ >= 199901L || __cplusplus >= 201103L )
-
-#define CATCH_INTERNAL_CONFIG_VARIADIC_MACROS
-
-#endif
-
-// Use __COUNTER__ if the compiler supports it
-#if ( defined _MSC_VER && _MSC_VER >= 1300 ) || \
-    ( defined __GNUC__  && ( __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3 )) ) || \
-    ( defined __clang__ && __clang_major__ >= 3 )
-
-// Use of __COUNTER__ is suppressed during code analysis in CLion/AppCode 2017.2.x and former,
-// because __COUNTER__ is not properly handled by it.
-// This does not affect compilation
-#if ( !defined __JETBRAINS_IDE__ || __JETBRAINS_IDE__ >= 20170300L )
-    #define CATCH_INTERNAL_CONFIG_COUNTER
-#endif
-
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// C++ language feature support
-
-// catch all support for C++11
-#if defined(CATCH_CPP11_OR_GREATER)
-
-#  if !defined(CATCH_INTERNAL_CONFIG_CPP11_NULLPTR)
-#    define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR
-#  endif
-
-#  ifndef CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT
-#    define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT
-#  endif
-
-#  ifndef CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS
-#    define CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS
-#  endif
-
-#  ifndef CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM
-#    define CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM
-#  endif
-
-#  ifndef CATCH_INTERNAL_CONFIG_CPP11_TUPLE
-#    define CATCH_INTERNAL_CONFIG_CPP11_TUPLE
-#  endif
-
-#  ifndef CATCH_INTERNAL_CONFIG_VARIADIC_MACROS
-#    define CATCH_INTERNAL_CONFIG_VARIADIC_MACROS
-#  endif
-
-#  if !defined(CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG)
-#    define CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG
-#  endif
-
-#  if !defined(CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE)
-#    define CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE
-#  endif
-#  if !defined(CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR)
-#    define CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR
-#  endif
-# if !defined(CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE)
-#   define CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE
-#  endif
-# if !defined(CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS)
-#  define CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS
-# endif
-
-#endif // __cplusplus >= 201103L
-
-// Now set the actual defines based on the above + anything the user has configured
-#if defined(CATCH_INTERNAL_CONFIG_CPP11_NULLPTR) && !defined(CATCH_CONFIG_CPP11_NO_NULLPTR) && !defined(CATCH_CONFIG_CPP11_NULLPTR) && !defined(CATCH_CONFIG_NO_CPP11)
-#   define CATCH_CONFIG_CPP11_NULLPTR
-#endif
-#if defined(CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_CONFIG_CPP11_NO_NOEXCEPT) && !defined(CATCH_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_CONFIG_NO_CPP11)
-#   define CATCH_CONFIG_CPP11_NOEXCEPT
-#endif
-#if defined(CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS) && !defined(CATCH_CONFIG_CPP11_NO_GENERATED_METHODS) && !defined(CATCH_CONFIG_CPP11_GENERATED_METHODS) && !defined(CATCH_CONFIG_NO_CPP11)
-#   define CATCH_CONFIG_CPP11_GENERATED_METHODS
-#endif
-#if defined(CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM) && !defined(CATCH_CONFIG_CPP11_NO_IS_ENUM) && !defined(CATCH_CONFIG_CPP11_IS_ENUM) && !defined(CATCH_CONFIG_NO_CPP11)
-#   define CATCH_CONFIG_CPP11_IS_ENUM
-#endif
-#if defined(CATCH_INTERNAL_CONFIG_CPP11_TUPLE) && !defined(CATCH_CONFIG_CPP11_NO_TUPLE) && !defined(CATCH_CONFIG_CPP11_TUPLE) && !defined(CATCH_CONFIG_NO_CPP11)
-#   define CATCH_CONFIG_CPP11_TUPLE
-#endif
-#if defined(CATCH_INTERNAL_CONFIG_VARIADIC_MACROS) && !defined(CATCH_CONFIG_NO_VARIADIC_MACROS) && !defined(CATCH_CONFIG_VARIADIC_MACROS)
-#   define CATCH_CONFIG_VARIADIC_MACROS
-#endif
-#if defined(CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG) && !defined(CATCH_CONFIG_CPP11_NO_LONG_LONG) && !defined(CATCH_CONFIG_CPP11_LONG_LONG) && !defined(CATCH_CONFIG_NO_CPP11)
-#   define CATCH_CONFIG_CPP11_LONG_LONG
-#endif
-#if defined(CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE) && !defined(CATCH_CONFIG_CPP11_NO_OVERRIDE) && !defined(CATCH_CONFIG_CPP11_OVERRIDE) && !defined(CATCH_CONFIG_NO_CPP11)
-#   define CATCH_CONFIG_CPP11_OVERRIDE
-#endif
-#if defined(CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR) && !defined(CATCH_CONFIG_CPP11_NO_UNIQUE_PTR) && !defined(CATCH_CONFIG_CPP11_UNIQUE_PTR) && !defined(CATCH_CONFIG_NO_CPP11)
-#   define CATCH_CONFIG_CPP11_UNIQUE_PTR
-#endif
-#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_CPP11_SHUFFLE) && !defined(CATCH_CONFIG_CPP11_NO_SHUFFLE) && !defined(CATCH_CONFIG_CPP11_SHUFFLE) && !defined(CATCH_CONFIG_NO_CPP11)
-#   define CATCH_CONFIG_CPP11_SHUFFLE
-#endif
-# if defined(CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS) && !defined(CATCH_CONFIG_CPP11_NO_TYPE_TRAITS) && !defined(CATCH_CONFIG_CPP11_TYPE_TRAITS) && !defined(CATCH_CONFIG_NO_CPP11)
-#  define CATCH_CONFIG_CPP11_TYPE_TRAITS
-# endif
-#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_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)
-#   define CATCH_CONFIG_POSIX_SIGNALS
-#endif
-
-#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
-#   define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS
-#endif
-#if !defined(CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS
-#   define CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS
-#endif
-
-// noexcept support:
-#if defined(CATCH_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_NOEXCEPT)
-#  define CATCH_NOEXCEPT noexcept
-#  define CATCH_NOEXCEPT_IS(x) noexcept(x)
-#else
-#  define CATCH_NOEXCEPT throw()
-#  define CATCH_NOEXCEPT_IS(x)
-#endif
-
-// nullptr support
-#ifdef CATCH_CONFIG_CPP11_NULLPTR
-#   define CATCH_NULL nullptr
-#else
-#   define CATCH_NULL NULL
-#endif
-
-// override support
-#ifdef CATCH_CONFIG_CPP11_OVERRIDE
-#   define CATCH_OVERRIDE override
-#else
-#   define CATCH_OVERRIDE
-#endif
-
-// unique_ptr support
-#ifdef CATCH_CONFIG_CPP11_UNIQUE_PTR
-#   define CATCH_AUTO_PTR( T ) std::unique_ptr<T>
-#else
-#   define CATCH_AUTO_PTR( T ) std::auto_ptr<T>
-#endif
-
-#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line
-#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )
-#ifdef CATCH_CONFIG_COUNTER
-#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ )
-#else
-#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )
-#endif
-
-#define INTERNAL_CATCH_STRINGIFY2( expr ) #expr
-#define INTERNAL_CATCH_STRINGIFY( expr ) INTERNAL_CATCH_STRINGIFY2( expr )
-
-#include <sstream>
-#include <algorithm>
-
-namespace Catch {
-
-    struct IConfig;
-
-    struct CaseSensitive { enum Choice {
-        Yes,
-        No
-    }; };
-
-    class NonCopyable {
-#ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
-        NonCopyable( NonCopyable const& )              = delete;
-        NonCopyable( NonCopyable && )                  = delete;
-        NonCopyable& operator = ( NonCopyable const& ) = delete;
-        NonCopyable& operator = ( NonCopyable && )     = delete;
-#else
-        NonCopyable( NonCopyable const& info );
-        NonCopyable& operator = ( NonCopyable const& );
-#endif
-
-    protected:
-        NonCopyable() {}
-        virtual ~NonCopyable();
-    };
-
-    class SafeBool {
-    public:
-        typedef void (SafeBool::*type)() const;
-
-        static type makeSafe( bool value ) {
-            return value ? &SafeBool::trueValue : 0;
-        }
-    private:
-        void trueValue() const {}
-    };
-
-    template<typename ContainerT>
-    void deleteAll( ContainerT& container ) {
-        typename ContainerT::const_iterator it = container.begin();
-        typename ContainerT::const_iterator itEnd = container.end();
-        for(; it != itEnd; ++it )
-            delete *it;
-    }
-    template<typename AssociativeContainerT>
-    void deleteAllValues( AssociativeContainerT& container ) {
-        typename AssociativeContainerT::const_iterator it = container.begin();
-        typename AssociativeContainerT::const_iterator itEnd = container.end();
-        for(; it != itEnd; ++it )
-            delete it->second;
-    }
-
-    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 );
-
-        friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser );
-
-        std::size_t m_count;
-        std::string m_label;
-    };
-
-    struct SourceLineInfo {
-
-        SourceLineInfo();
-        SourceLineInfo( char const* _file, std::size_t _line );
-#  ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
-        SourceLineInfo(SourceLineInfo const& other)          = default;
-        SourceLineInfo( SourceLineInfo && )                  = default;
-        SourceLineInfo& operator = ( SourceLineInfo const& ) = default;
-        SourceLineInfo& operator = ( SourceLineInfo && )     = default;
-#  endif
-        bool empty() const;
-        bool operator == ( SourceLineInfo const& other ) const;
-        bool operator < ( SourceLineInfo const& other ) const;
-
-        char const* file;
-        std::size_t line;
-    };
-
-    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info );
-
-    // This is just here to avoid compiler warnings with macro constants and boolean literals
-    inline bool isTrue( bool value ){ return value; }
-    inline bool alwaysTrue() { return true; }
-    inline bool alwaysFalse() { return false; }
-
-    void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo );
-
-    void seedRng( IConfig const& config );
-    unsigned int rngSeed();
-
-    // Use this in variadic streaming macros to allow
-    //    >> +StreamEndStop
-    // as well as
-    //    >> stuff +StreamEndStop
-    struct StreamEndStop {
-        std::string operator+() {
-            return std::string();
-        }
-    };
-    template<typename T>
-    T const& operator + ( T const& value, StreamEndStop ) {
-        return value;
-    }
-}
-
-#define CATCH_INTERNAL_LINEINFO ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )
-#define CATCH_INTERNAL_ERROR( msg ) ::Catch::throwLogicError( msg, CATCH_INTERNAL_LINEINFO );
-
-namespace Catch {
-
-    class NotImplementedException : public std::exception
-    {
-    public:
-        NotImplementedException( SourceLineInfo const& lineInfo );
-
-        virtual ~NotImplementedException() CATCH_NOEXCEPT {}
-
-        virtual const char* what() const CATCH_NOEXCEPT;
-
-    private:
-        std::string m_what;
-        SourceLineInfo m_lineInfo;
-    };
-
-} // end namespace Catch
-
-///////////////////////////////////////////////////////////////////////////////
-#define CATCH_NOT_IMPLEMENTED throw Catch::NotImplementedException( CATCH_INTERNAL_LINEINFO )
-
-// #included from: internal/catch_context.h
-#define TWOBLUECUBES_CATCH_CONTEXT_H_INCLUDED
-
-// #included from: catch_interfaces_generators.h
-#define TWOBLUECUBES_CATCH_INTERFACES_GENERATORS_H_INCLUDED
-
-#include <string>
-
-namespace Catch {
-
-    struct IGeneratorInfo {
-        virtual ~IGeneratorInfo();
-        virtual bool moveNext() = 0;
-        virtual std::size_t getCurrentIndex() const = 0;
-    };
-
-    struct IGeneratorsForTest {
-        virtual ~IGeneratorsForTest();
-
-        virtual IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) = 0;
-        virtual bool moveNext() = 0;
-    };
-
-    IGeneratorsForTest* createGeneratorsForTest();
-
-} // end namespace Catch
-
-// #included from: catch_ptr.hpp
-#define TWOBLUECUBES_CATCH_PTR_HPP_INCLUDED
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-namespace Catch {
-
-    // An intrusive reference counting smart pointer.
-    // T must implement addRef() and release() methods
-    // typically implementing the IShared interface
-    template<typename T>
-    class Ptr {
-    public:
-        Ptr() : m_p( CATCH_NULL ){}
-        Ptr( T* p ) : m_p( p ){
-            if( m_p )
-                m_p->addRef();
-        }
-        Ptr( Ptr const& other ) : m_p( other.m_p ){
-            if( m_p )
-                m_p->addRef();
-        }
-        ~Ptr(){
-            if( m_p )
-                m_p->release();
-        }
-        void reset() {
-            if( m_p )
-                m_p->release();
-            m_p = CATCH_NULL;
-        }
-        Ptr& operator = ( T* p ){
-            Ptr temp( p );
-            swap( temp );
-            return *this;
-        }
-        Ptr& operator = ( Ptr const& other ){
-            Ptr temp( other );
-            swap( temp );
-            return *this;
-        }
-        void swap( Ptr& other ) { std::swap( m_p, other.m_p ); }
-        T* get() const{ return m_p; }
-        T& operator*() const { return *m_p; }
-        T* operator->() const { return m_p; }
-        bool operator !() const { return m_p == CATCH_NULL; }
-        operator SafeBool::type() const { return SafeBool::makeSafe( m_p != CATCH_NULL ); }
-
-    private:
-        T* m_p;
-    };
-
-    struct IShared : NonCopyable {
-        virtual ~IShared();
-        virtual void addRef() const = 0;
-        virtual void release() const = 0;
-    };
-
-    template<typename T = IShared>
-    struct SharedImpl : T {
-
-        SharedImpl() : m_rc( 0 ){}
-
-        virtual void addRef() const {
-            ++m_rc;
-        }
-        virtual void release() const {
-            if( --m_rc == 0 )
-                delete this;
-        }
-
-        mutable unsigned int m_rc;
-    };
-
-} // end namespace Catch
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-namespace Catch {
-
-    class TestCase;
-    class Stream;
-    struct IResultCapture;
-    struct IRunner;
-    struct IGeneratorsForTest;
-    struct IConfig;
-
-    struct IContext
-    {
-        virtual ~IContext();
-
-        virtual IResultCapture* getResultCapture() = 0;
-        virtual IRunner* getRunner() = 0;
-        virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) = 0;
-        virtual bool advanceGeneratorsForCurrentTest() = 0;
-        virtual Ptr<IConfig const> getConfig() const = 0;
-    };
-
-    struct IMutableContext : IContext
-    {
-        virtual ~IMutableContext();
-        virtual void setResultCapture( IResultCapture* resultCapture ) = 0;
-        virtual void setRunner( IRunner* runner ) = 0;
-        virtual void setConfig( Ptr<IConfig const> const& config ) = 0;
-    };
-
-    IContext& getCurrentContext();
-    IMutableContext& getCurrentMutableContext();
-    void cleanUpContext();
-    Stream createStream( std::string const& streamName );
-
-}
-
-// #included from: internal/catch_test_registry.hpp
-#define TWOBLUECUBES_CATCH_TEST_REGISTRY_HPP_INCLUDED
-
-// #included from: catch_interfaces_testcase.h
-#define TWOBLUECUBES_CATCH_INTERFACES_TESTCASE_H_INCLUDED
-
-#include <vector>
-
-namespace Catch {
-
-    class TestSpec;
-
-    struct ITestCase : IShared {
-        virtual void invoke () const = 0;
-    protected:
-        virtual ~ITestCase();
-    };
-
-    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;
-    };
-
-    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 );
-
-}
-
-namespace Catch {
-
-template<typename C>
-class MethodTestCase : public SharedImpl<ITestCase> {
-
-public:
-    MethodTestCase( void (C::*method)() ) : m_method( method ) {}
-
-    virtual void invoke() const {
-        C obj;
-        (obj.*m_method)();
-    }
-
-private:
-    virtual ~MethodTestCase() {}
-
-    void (C::*m_method)();
-};
-
-typedef void(*TestFunction)();
-
-struct NameAndDesc {
-    NameAndDesc( const char* _name = "", const char* _description= "" )
-    : name( _name ), description( _description )
-    {}
-
-    const char* name;
-    const char* description;
-};
-
-void registerTestCase
-    (   ITestCase* testCase,
-        char const* className,
-        NameAndDesc const& nameAndDesc,
-        SourceLineInfo const& lineInfo );
-
-struct AutoReg {
-
-    AutoReg
-        (   TestFunction function,
-            SourceLineInfo const& lineInfo,
-            NameAndDesc const& nameAndDesc );
-
-    template<typename C>
-    AutoReg
-        (   void (C::*method)(),
-            char const* className,
-            NameAndDesc const& nameAndDesc,
-            SourceLineInfo const& lineInfo ) {
-
-        registerTestCase
-            (   new MethodTestCase<C>( method ),
-                className,
-                nameAndDesc,
-                lineInfo );
-    }
-
-    ~AutoReg();
-
-private:
-    AutoReg( AutoReg const& );
-    void operator= ( AutoReg const& );
-};
-
-void registerTestCaseFunction
-    (   TestFunction function,
-        SourceLineInfo const& lineInfo,
-        NameAndDesc const& nameAndDesc );
-
-} // end namespace Catch
-
-#ifdef CATCH_CONFIG_VARIADIC_MACROS
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \
-        static void TestName(); \
-        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &TestName, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); } /* NOLINT */ \
-        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
-        static void TestName()
-    #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, ... ) \
-        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); } /* NOLINT */ \
-        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\
-        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
-        namespace{ \
-            struct TestName : ClassName{ \
-                void test(); \
-            }; \
-            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &TestName::test, #ClassName, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); /* NOLINT */ \
-        } \
-        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
-        void TestName::test()
-    #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, ... ) \
-        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
-        Catch::AutoReg( Function, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); /* NOLINT */ \
-        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS
-
-#else
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TESTCASE2( TestName, Name, Desc ) \
-        static void TestName(); \
-        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &TestName, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) ); } /* NOLINT */ \
-        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
-        static void TestName()
-    #define INTERNAL_CATCH_TESTCASE( Name, Desc ) \
-        INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), Name, Desc )
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, Name, Desc ) \
-        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( Name, Desc ), CATCH_INTERNAL_LINEINFO ); } /* NOLINT */ \
-        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestCaseName, ClassName, TestName, Desc )\
-        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
-        namespace{ \
-            struct TestCaseName : ClassName{ \
-                void test(); \
-            }; \
-            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &TestCaseName::test, #ClassName, Catch::NameAndDesc( TestName, Desc ), CATCH_INTERNAL_LINEINFO ); /* NOLINT */ \
-        } \
-        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
-        void TestCaseName::test()
-    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, TestName, Desc )\
-        INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), ClassName, TestName, Desc )
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, Name, Desc ) \
-        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
-        Catch::AutoReg( Function, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) ); /* NOLINT */ \
-        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS
-
-#endif
-
-// #included from: internal/catch_capture.hpp
-#define TWOBLUECUBES_CATCH_CAPTURE_HPP_INCLUDED
-
-// #included from: catch_result_builder.h
-#define TWOBLUECUBES_CATCH_RESULT_BUILDER_H_INCLUDED
-
-// #included from: catch_result_type.h
-#define TWOBLUECUBES_CATCH_RESULT_TYPE_H_INCLUDED
-
-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
-
-    }; };
-
-    inline bool isOk( ResultWas::OfType resultType ) {
-        return ( resultType & ResultWas::FailureBit ) == 0;
-    }
-    inline bool isJustInfo( int flags ) {
-        return flags == ResultWas::Info;
-    }
-
-    // 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
-    }; };
-
-    inline ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) {
-        return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) | static_cast<int>( rhs ) );
-    }
-
-    inline bool shouldContinueOnFailure( int flags )    { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }
-    inline bool isFalseTest( int flags )                { return ( flags & ResultDisposition::FalseTest ) != 0; }
-    inline bool shouldSuppressFailure( int flags )      { return ( flags & ResultDisposition::SuppressFail ) != 0; }
-
-} // end namespace Catch
-
-// #included from: catch_assertionresult.h
-#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_H_INCLUDED
-
-#include <string>
-
-namespace Catch {
-
-    struct STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison;
-
-    struct DecomposedExpression
-    {
-        virtual ~DecomposedExpression() {}
-        virtual bool isBinaryExpression() const {
-            return false;
-        }
-        virtual void reconstructExpression( std::string& dest ) const = 0;
-
-        // Only simple binary comparisons can be decomposed.
-        // If more complex check is required then wrap sub-expressions in parentheses.
-        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator + ( T const& );
-        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator - ( T const& );
-        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator * ( T const& );
-        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator / ( T const& );
-        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator % ( T const& );
-        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator && ( T const& );
-        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator || ( T const& );
-
-    private:
-        DecomposedExpression& operator = (DecomposedExpression const&);
-    };
-
-    struct AssertionInfo
-    {
-        AssertionInfo();
-        AssertionInfo(  char const * _macroName,
-                        SourceLineInfo const& _lineInfo,
-                        char const * _capturedExpression,
-                        ResultDisposition::Flags _resultDisposition,
-                        char const * _secondArg = "");
-
-        char const * macroName;
-        SourceLineInfo lineInfo;
-        char const * capturedExpression;
-        ResultDisposition::Flags resultDisposition;
-        char const * secondArg;
-    };
-
-    struct AssertionResultData
-    {
-        AssertionResultData() : decomposedExpression( CATCH_NULL )
-                              , resultType( ResultWas::Unknown )
-                              , negated( false )
-                              , parenthesized( false ) {}
-
-        void negate( bool parenthesize ) {
-            negated = !negated;
-            parenthesized = parenthesize;
-            if( resultType == ResultWas::Ok )
-                resultType = ResultWas::ExpressionFailed;
-            else if( resultType == ResultWas::ExpressionFailed )
-                resultType = ResultWas::Ok;
-        }
-
-        std::string const& reconstructExpression() const {
-            if( decomposedExpression != CATCH_NULL ) {
-                decomposedExpression->reconstructExpression( reconstructedExpression );
-                if( parenthesized ) {
-                    reconstructedExpression.insert( 0, 1, '(' );
-                    reconstructedExpression.append( 1, ')' );
-                }
-                if( negated ) {
-                    reconstructedExpression.insert( 0, 1, '!' );
-                }
-                decomposedExpression = CATCH_NULL;
-            }
-            return reconstructedExpression;
-        }
-
-        mutable DecomposedExpression const* decomposedExpression;
-        mutable std::string reconstructedExpression;
-        std::string message;
-        ResultWas::OfType resultType;
-        bool negated;
-        bool parenthesized;
-    };
-
-    class AssertionResult {
-    public:
-        AssertionResult();
-        AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
-        ~AssertionResult();
-#  ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
-         AssertionResult( AssertionResult const& )              = default;
-         AssertionResult( AssertionResult && )                  = default;
-         AssertionResult& operator = ( AssertionResult const& ) = default;
-         AssertionResult& operator = ( AssertionResult && )     = default;
-#  endif
-
-        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;
-        void discardDecomposedExpression() const;
-        void expandDecomposedExpression() const;
-
-    protected:
-        AssertionInfo m_info;
-        AssertionResultData m_resultData;
-    };
-
-} // end namespace Catch
-
-// #included from: catch_matchers.hpp
-#define TWOBLUECUBES_CATCH_MATCHERS_HPP_INCLUDED
-
-namespace Catch {
-namespace Matchers {
-    namespace Impl {
-
-        template<typename ArgT> struct MatchAllOf;
-        template<typename ArgT> struct MatchAnyOf;
-        template<typename ArgT> struct MatchNotOf;
-
-        class MatcherUntypedBase {
-        public:
-            std::string toString() const {
-                if( m_cachedToString.empty() )
-                    m_cachedToString = describe();
-                return m_cachedToString;
-            }
-
-        protected:
-            virtual ~MatcherUntypedBase();
-            virtual std::string describe() const = 0;
-            mutable std::string m_cachedToString;
-        private:
-            MatcherUntypedBase& operator = ( MatcherUntypedBase const& );
-        };
-
-        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> {
-            virtual bool match( ArgT const& arg ) const CATCH_OVERRIDE {
-                for( std::size_t i = 0; i < m_matchers.size(); ++i ) {
-                    if (!m_matchers[i]->match(arg))
-                        return false;
-                }
-                return true;
-            }
-            virtual std::string describe() const CATCH_OVERRIDE {
-                std::string description;
-                description.reserve( 4 + m_matchers.size()*32 );
-                description += "( ";
-                for( std::size_t i = 0; i < m_matchers.size(); ++i ) {
-                    if( i != 0 )
-                        description += " and ";
-                    description += m_matchers[i]->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> {
-
-            virtual bool match( ArgT const& arg ) const CATCH_OVERRIDE {
-                for( std::size_t i = 0; i < m_matchers.size(); ++i ) {
-                    if (m_matchers[i]->match(arg))
-                        return true;
-                }
-                return false;
-            }
-            virtual std::string describe() const CATCH_OVERRIDE {
-                std::string description;
-                description.reserve( 4 + m_matchers.size()*32 );
-                description += "( ";
-                for( std::size_t i = 0; i < m_matchers.size(); ++i ) {
-                    if( i != 0 )
-                        description += " or ";
-                    description += m_matchers[i]->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 ) {}
-
-            virtual bool match( ArgT const& arg ) const CATCH_OVERRIDE {
-                return !m_underlyingMatcher.match( arg );
-            }
-
-            virtual std::string describe() const CATCH_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
-
-    // The following functions create the actual matcher objects.
-    // This allows the types to be inferred
-    // - deprecated: prefer ||, && and !
-    template<typename T>
-    Impl::MatchNotOf<T> Not( Impl::MatcherBase<T> const& underlyingMatcher ) {
-        return Impl::MatchNotOf<T>( underlyingMatcher );
-    }
-    template<typename T>
-    Impl::MatchAllOf<T> AllOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2 ) {
-        return Impl::MatchAllOf<T>() && m1 && m2;
-    }
-    template<typename T>
-    Impl::MatchAllOf<T> AllOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2, Impl::MatcherBase<T> const& m3 ) {
-        return Impl::MatchAllOf<T>() && m1 && m2 && m3;
-    }
-    template<typename T>
-    Impl::MatchAnyOf<T> AnyOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2 ) {
-        return Impl::MatchAnyOf<T>() || m1 || m2;
-    }
-    template<typename T>
-    Impl::MatchAnyOf<T> AnyOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2, Impl::MatcherBase<T> const& m3 ) {
-        return Impl::MatchAnyOf<T>() || m1 || m2 || m3;
-    }
-
-} // namespace Matchers
-
-using namespace Matchers;
-using Matchers::Impl::MatcherBase;
-
-} // namespace Catch
-
-namespace Catch {
-
-    struct TestFailureException{};
-
-    template<typename T> class ExpressionLhs;
-
-    struct CopyableStream {
-        CopyableStream() {}
-        CopyableStream( CopyableStream const& other ) {
-            oss << other.oss.str();
-        }
-        CopyableStream& operator=( CopyableStream const& other ) {
-            oss.str(std::string());
-            oss << other.oss.str();
-            return *this;
-        }
-        std::ostringstream oss;
-    };
-
-    class ResultBuilder : public DecomposedExpression {
-    public:
-        ResultBuilder(  char const* macroName,
-                        SourceLineInfo const& lineInfo,
-                        char const* capturedExpression,
-                        ResultDisposition::Flags resultDisposition,
-                        char const* secondArg = "" );
-        ~ResultBuilder();
-
-        template<typename T>
-        ExpressionLhs<T const&> operator <= ( T const& operand );
-        ExpressionLhs<bool> operator <= ( bool value );
-
-        template<typename T>
-        ResultBuilder& operator << ( T const& value ) {
-            stream().oss << value;
-            return *this;
-        }
-
-        ResultBuilder& setResultType( ResultWas::OfType result );
-        ResultBuilder& setResultType( bool result );
-
-        void endExpression( DecomposedExpression const& expr );
-
-        virtual void reconstructExpression( std::string& dest ) const CATCH_OVERRIDE;
-
-        AssertionResult build() const;
-        AssertionResult build( DecomposedExpression const& expr ) const;
-
-        void useActiveException( ResultDisposition::Flags resultDisposition = ResultDisposition::Normal );
-        void captureResult( ResultWas::OfType resultType );
-        void captureExpression();
-        void captureExpectedException( std::string const& expectedMessage );
-        void captureExpectedException( Matchers::Impl::MatcherBase<std::string> const& matcher );
-        void handleResult( AssertionResult const& result );
-        void react();
-        bool shouldDebugBreak() const;
-        bool allowThrows() const;
-
-        template<typename ArgT, typename MatcherT>
-        void captureMatch( ArgT const& arg, MatcherT const& matcher, char const* matcherString );
-
-        void setExceptionGuard();
-        void unsetExceptionGuard();
-
-    private:
-        AssertionInfo m_assertionInfo;
-        AssertionResultData m_data;
-
-        CopyableStream &stream()
-        {
-            if(!m_usedStream)
-            {
-                m_usedStream = true;
-                m_stream().oss.str("");
-            }
-            return m_stream();
-        }
-
-        static CopyableStream &m_stream()
-        {
-            static CopyableStream s;
-            return s;
-        }
-
-        bool m_shouldDebugBreak;
-        bool m_shouldThrow;
-        bool m_guardException;
-        bool m_usedStream;
-    };
-
-} // namespace Catch
-
-// Include after due to circular dependency:
-// #included from: catch_expression_lhs.hpp
-#define TWOBLUECUBES_CATCH_EXPRESSION_LHS_HPP_INCLUDED
-
-// #included from: catch_evaluate.hpp
-#define TWOBLUECUBES_CATCH_EVALUATE_HPP_INCLUDED
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
-#pragma warning(disable:4018) // more "signed/unsigned mismatch"
-#pragma warning(disable:4312) // Converting int to T* using reinterpret_cast (issue on x64 platform)
-#endif
-
-#include <cstddef>
-
-namespace Catch {
-namespace Internal {
-
-    enum Operator {
-        IsEqualTo,
-        IsNotEqualTo,
-        IsLessThan,
-        IsGreaterThan,
-        IsLessThanOrEqualTo,
-        IsGreaterThanOrEqualTo
-    };
-
-    template<Operator Op> struct OperatorTraits             { static const char* getName(){ return "*error*"; } };
-    template<> struct OperatorTraits<IsEqualTo>             { static const char* getName(){ return "=="; } };
-    template<> struct OperatorTraits<IsNotEqualTo>          { static const char* getName(){ return "!="; } };
-    template<> struct OperatorTraits<IsLessThan>            { static const char* getName(){ return "<"; } };
-    template<> struct OperatorTraits<IsGreaterThan>         { static const char* getName(){ return ">"; } };
-    template<> struct OperatorTraits<IsLessThanOrEqualTo>   { static const char* getName(){ return "<="; } };
-    template<> struct OperatorTraits<IsGreaterThanOrEqualTo>{ static const char* getName(){ return ">="; } };
-
-    template<typename T>
-    T& opCast(T const& t) { return const_cast<T&>(t); }
-
-// nullptr_t support based on pull request #154 from Konstantin Baumann
-#ifdef CATCH_CONFIG_CPP11_NULLPTR
-    inline std::nullptr_t opCast(std::nullptr_t) { return nullptr; }
-#endif // CATCH_CONFIG_CPP11_NULLPTR
-
-    // So the compare overloads can be operator agnostic we convey the operator as a template
-    // enum, which is used to specialise an Evaluator for doing the comparison.
-    template<typename T1, typename T2, Operator Op>
-    struct Evaluator{};
-
-    template<typename T1, typename T2>
-    struct Evaluator<T1, T2, IsEqualTo> {
-        static bool evaluate( T1 const& lhs, T2 const& rhs) {
-            return bool( opCast( lhs ) ==  opCast( rhs ) );
-        }
-    };
-    template<typename T1, typename T2>
-    struct Evaluator<T1, T2, IsNotEqualTo> {
-        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
-            return bool( opCast( lhs ) != opCast( rhs ) );
-        }
-    };
-    template<typename T1, typename T2>
-    struct Evaluator<T1, T2, IsLessThan> {
-        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
-            return bool( opCast( lhs ) < opCast( rhs ) );
-        }
-    };
-    template<typename T1, typename T2>
-    struct Evaluator<T1, T2, IsGreaterThan> {
-        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
-            return bool( opCast( lhs ) > opCast( rhs ) );
-        }
-    };
-    template<typename T1, typename T2>
-    struct Evaluator<T1, T2, IsGreaterThanOrEqualTo> {
-        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
-            return bool( opCast( lhs ) >= opCast( rhs ) );
-        }
-    };
-    template<typename T1, typename T2>
-    struct Evaluator<T1, T2, IsLessThanOrEqualTo> {
-        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
-            return bool( opCast( lhs ) <= opCast( rhs ) );
-        }
-    };
-
-    template<Operator Op, typename T1, typename T2>
-    bool applyEvaluator( T1 const& lhs, T2 const& rhs ) {
-        return Evaluator<T1, T2, Op>::evaluate( lhs, rhs );
-    }
-
-    // This level of indirection allows us to specialise for integer types
-    // to avoid signed/ unsigned warnings
-
-    // "base" overload
-    template<Operator Op, typename T1, typename T2>
-    bool compare( T1 const& lhs, T2 const& rhs ) {
-        return Evaluator<T1, T2, Op>::evaluate( lhs, rhs );
-    }
-
-    // unsigned X to int
-    template<Operator Op> bool compare( unsigned int lhs, int rhs ) {
-        return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
-    }
-    template<Operator Op> bool compare( unsigned long lhs, int rhs ) {
-        return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
-    }
-    template<Operator Op> bool compare( unsigned char lhs, int rhs ) {
-        return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
-    }
-
-    // unsigned X to long
-    template<Operator Op> bool compare( unsigned int lhs, long rhs ) {
-        return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
-    }
-    template<Operator Op> bool compare( unsigned long lhs, long rhs ) {
-        return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
-    }
-    template<Operator Op> bool compare( unsigned char lhs, long rhs ) {
-        return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
-    }
-
-    // int to unsigned X
-    template<Operator Op> bool compare( int lhs, unsigned int rhs ) {
-        return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
-    }
-    template<Operator Op> bool compare( int lhs, unsigned long rhs ) {
-        return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
-    }
-    template<Operator Op> bool compare( int lhs, unsigned char rhs ) {
-        return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
-    }
-
-    // long to unsigned X
-    template<Operator Op> bool compare( long lhs, unsigned int rhs ) {
-        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
-    }
-    template<Operator Op> bool compare( long lhs, unsigned long rhs ) {
-        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
-    }
-    template<Operator Op> bool compare( long lhs, unsigned char rhs ) {
-        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
-    }
-
-    // pointer to long (when comparing against NULL)
-    template<Operator Op, typename T> bool compare( long lhs, T* rhs ) {
-        return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
-    }
-    template<Operator Op, typename T> bool compare( T* lhs, long rhs ) {
-        return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
-    }
-
-    // pointer to int (when comparing against NULL)
-    template<Operator Op, typename T> bool compare( int lhs, T* rhs ) {
-        return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
-    }
-    template<Operator Op, typename T> bool compare( T* lhs, int rhs ) {
-        return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
-    }
-
-#ifdef CATCH_CONFIG_CPP11_LONG_LONG
-    // long long to unsigned X
-    template<Operator Op> bool compare( long long lhs, unsigned int rhs ) {
-        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
-    }
-    template<Operator Op> bool compare( long long lhs, unsigned long rhs ) {
-        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
-    }
-    template<Operator Op> bool compare( long long lhs, unsigned long long rhs ) {
-        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
-    }
-    template<Operator Op> bool compare( long long lhs, unsigned char rhs ) {
-        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
-    }
-
-    // unsigned long long to X
-    template<Operator Op> bool compare( unsigned long long lhs, int rhs ) {
-        return applyEvaluator<Op>( static_cast<long>( lhs ), rhs );
-    }
-    template<Operator Op> bool compare( unsigned long long lhs, long rhs ) {
-        return applyEvaluator<Op>( static_cast<long>( lhs ), rhs );
-    }
-    template<Operator Op> bool compare( unsigned long long lhs, long long rhs ) {
-        return applyEvaluator<Op>( static_cast<long>( lhs ), rhs );
-    }
-    template<Operator Op> bool compare( unsigned long long lhs, char rhs ) {
-        return applyEvaluator<Op>( static_cast<long>( lhs ), rhs );
-    }
-
-    // pointer to long long (when comparing against NULL)
-    template<Operator Op, typename T> bool compare( long long lhs, T* rhs ) {
-        return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
-    }
-    template<Operator Op, typename T> bool compare( T* lhs, long long rhs ) {
-        return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
-    }
-#endif // CATCH_CONFIG_CPP11_LONG_LONG
-
-#ifdef CATCH_CONFIG_CPP11_NULLPTR
-    // pointer to nullptr_t (when comparing against nullptr)
-    template<Operator Op, typename T> bool compare( std::nullptr_t, T* rhs ) {
-        return Evaluator<T*, T*, Op>::evaluate( nullptr, rhs );
-    }
-    template<Operator Op, typename T> bool compare( T* lhs, std::nullptr_t ) {
-        return Evaluator<T*, T*, Op>::evaluate( lhs, nullptr );
-    }
-#endif // CATCH_CONFIG_CPP11_NULLPTR
-
-} // end of namespace Internal
-} // end of namespace Catch
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-// #included from: catch_tostring.h
-#define TWOBLUECUBES_CATCH_TOSTRING_H_INCLUDED
-
-#include <sstream>
-#include <iomanip>
-#include <limits>
-#include <vector>
-#include <cstddef>
-
-#ifdef __OBJC__
-// #included from: catch_objc_arc.hpp
-#define TWOBLUECUBES_CATCH_OBJC_ARC_HPP_INCLUDED
-
-#import <Foundation/Foundation.h>
-
-#ifdef __has_feature
-#define CATCH_ARC_ENABLED __has_feature(objc_arc)
-#else
-#define CATCH_ARC_ENABLED 0
-#endif
-
-void arcSafeRelease( NSObject* obj );
-id performOptionalSelector( id obj, SEL sel );
-
-#if !CATCH_ARC_ENABLED
-inline void arcSafeRelease( NSObject* obj ) {
-    [obj release];
-}
-inline id performOptionalSelector( id obj, SEL sel ) {
-    if( [obj respondsToSelector: sel] )
-        return [obj performSelector: sel];
-    return nil;
-}
-#define CATCH_UNSAFE_UNRETAINED
-#define CATCH_ARC_STRONG
-#else
-inline void arcSafeRelease( NSObject* ){}
-inline id performOptionalSelector( id obj, SEL sel ) {
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
-#endif
-    if( [obj respondsToSelector: sel] )
-        return [obj performSelector: sel];
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-    return nil;
-}
-#define CATCH_UNSAFE_UNRETAINED __unsafe_unretained
-#define CATCH_ARC_STRONG __strong
-#endif
-
-#endif
-
-#ifdef CATCH_CONFIG_CPP11_TUPLE
-#include <tuple>
-#endif
-
-#ifdef CATCH_CONFIG_CPP11_IS_ENUM
-#include <type_traits>
-#endif
-
-namespace Catch {
-
-// Why we're here.
-template<typename T>
-std::string toString( T const& value );
-
-// Built in overloads
-
-std::string toString( std::string const& value );
-std::string toString( std::wstring const& value );
-std::string toString( const char* const value );
-std::string toString( char* const value );
-std::string toString( const wchar_t* const value );
-std::string toString( wchar_t* const value );
-std::string toString( int value );
-std::string toString( unsigned long value );
-std::string toString( unsigned int value );
-std::string toString( const double value );
-std::string toString( const float value );
-std::string toString( bool value );
-std::string toString( char value );
-std::string toString( signed char value );
-std::string toString( unsigned char value );
-
-#ifdef CATCH_CONFIG_CPP11_LONG_LONG
-std::string toString( long long value );
-std::string toString( unsigned long long value );
-#endif
-
-#ifdef CATCH_CONFIG_CPP11_NULLPTR
-std::string toString( std::nullptr_t );
-#endif
-
-#ifdef __OBJC__
-    std::string toString( NSString const * const& nsstring );
-    std::string toString( NSString * CATCH_ARC_STRONG & nsstring );
-    std::string toString( NSObject* const& nsObject );
-#endif
-
-namespace Detail {
-
-    extern const std::string unprintableString;
-
- #if !defined(CATCH_CONFIG_CPP11_STREAM_INSERTABLE_CHECK)
-    struct BorgType {
-        template<typename T> BorgType( T const& );
-    };
-
-    struct TrueType { char sizer[1]; };
-    struct FalseType { char sizer[2]; };
-
-    TrueType& testStreamable( std::ostream& );
-    FalseType testStreamable( FalseType );
-
-    FalseType operator<<( std::ostream const&, BorgType const& );
-
-    template<typename T>
-    struct IsStreamInsertable {
-        static std::ostream &s;
-        static T  const&t;
-        enum { value = sizeof( testStreamable(s << t) ) == sizeof( TrueType ) };
-    };
-#else
-    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;
-    };
-#endif
-
-#if defined(CATCH_CONFIG_CPP11_IS_ENUM)
-    template<typename T,
-             bool IsEnum = std::is_enum<T>::value
-             >
-    struct EnumStringMaker
-    {
-        static std::string convert( T const& ) { return unprintableString; }
-    };
-
-    template<typename T>
-    struct EnumStringMaker<T,true>
-    {
-        static std::string convert( T const& v )
-        {
-            return ::Catch::toString(
-                static_cast<typename std::underlying_type<T>::type>(v)
-                );
-        }
-    };
-#endif
-    template<bool C>
-    struct StringMakerBase {
-#if defined(CATCH_CONFIG_CPP11_IS_ENUM)
-        template<typename T>
-        static std::string convert( T const& v )
-        {
-            return EnumStringMaker<T>::convert( v );
-        }
-#else
-        template<typename T>
-        static std::string convert( T const& ) { return unprintableString; }
-#endif
-    };
-
-    template<>
-    struct StringMakerBase<true> {
-        template<typename T>
-        static std::string convert( T const& _value ) {
-            std::ostringstream oss;
-            oss << _value;
-            return oss.str();
-        }
-    };
-
-    std::string rawMemoryToString( const void *object, std::size_t size );
-
-    template<typename T>
-    std::string rawMemoryToString( const T& object ) {
-      return rawMemoryToString( &object, sizeof(object) );
-    }
-
-} // end namespace Detail
-
-template<typename T>
-struct StringMaker :
-    Detail::StringMakerBase<Detail::IsStreamInsertable<T>::value> {};
-
-template<typename T>
-struct StringMaker<T*> {
-    template<typename U>
-    static std::string convert( U* p ) {
-        if( !p )
-            return "NULL";
-        else
-            return Detail::rawMemoryToString( p );
-    }
-};
-
-template<typename R, typename C>
-struct StringMaker<R C::*> {
-    static std::string convert( R C::* p ) {
-        if( !p )
-            return "NULL";
-        else
-            return Detail::rawMemoryToString( p );
-    }
-};
-
-namespace Detail {
-    template<typename InputIterator>
-    std::string rangeToString( InputIterator first, InputIterator last );
-}
-
-//template<typename T, typename Allocator>
-//struct StringMaker<std::vector<T, Allocator> > {
-//    static std::string convert( std::vector<T,Allocator> const& v ) {
-//        return Detail::rangeToString( v.begin(), v.end() );
-//    }
-//};
-
-template<typename T, typename Allocator>
-std::string toString( std::vector<T,Allocator> const& v ) {
-    return Detail::rangeToString( v.begin(), v.end() );
-}
-
-#ifdef CATCH_CONFIG_CPP11_TUPLE
-
-// toString for tuples
-namespace TupleDetail {
-  template<
-      typename Tuple,
-      std::size_t N = 0,
-      bool = (N < std::tuple_size<Tuple>::value)
-      >
-  struct ElementPrinter {
-      static void print( const Tuple& tuple, std::ostream& os )
-      {
-          os << ( N ? ", " : " " )
-             << Catch::toString(std::get<N>(tuple));
-          ElementPrinter<Tuple,N+1>::print(tuple,os);
-      }
-  };
-
-  template<
-      typename Tuple,
-      std::size_t N
-      >
-  struct ElementPrinter<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 << '{';
-        TupleDetail::ElementPrinter<std::tuple<Types...>>::print( tuple, os );
-        os << " }";
-        return os.str();
-    }
-};
-#endif // CATCH_CONFIG_CPP11_TUPLE
-
-namespace Detail {
-    template<typename T>
-    std::string makeString( T const& value ) {
-        return StringMaker<T>::convert( value );
-    }
-} // end namespace Detail
-
-/// \brief converts any type to a string
-///
-/// The default template forwards on to ostringstream - except when an
-/// ostringstream overload does not exist - in which case it attempts to detect
-/// that and writes {?}.
-/// Overload (not specialise) this template for custom typs that you don't want
-/// to provide an ostream overload for.
-template<typename T>
-std::string toString( T const& value ) {
-    return StringMaker<T>::convert( value );
-}
-
-    namespace Detail {
-    template<typename InputIterator>
-    std::string rangeToString( InputIterator first, InputIterator last ) {
-        std::ostringstream oss;
-        oss << "{ ";
-        if( first != last ) {
-            oss << Catch::toString( *first );
-            for( ++first ; first != last ; ++first )
-                oss << ", " << Catch::toString( *first );
-        }
-        oss << " }";
-        return oss.str();
-    }
-}
-
-} // end namespace Catch
-
-namespace Catch {
-
-template<typename LhsT, Internal::Operator Op, typename RhsT>
-class BinaryExpression;
-
-template<typename ArgT, typename MatcherT>
-class MatchExpression;
-
-// Wraps the LHS of an expression and overloads comparison operators
-// for also capturing those and RHS (if any)
-template<typename T>
-class ExpressionLhs : public DecomposedExpression {
-public:
-    ExpressionLhs( ResultBuilder& rb, T lhs ) : m_rb( rb ), m_lhs( lhs ), m_truthy(false) {}
-
-    ExpressionLhs& operator = ( const ExpressionLhs& );
-
-    template<typename RhsT>
-    BinaryExpression<T, Internal::IsEqualTo, RhsT const&>
-    operator == ( RhsT const& rhs ) {
-        return captureExpression<Internal::IsEqualTo>( rhs );
-    }
-
-    template<typename RhsT>
-    BinaryExpression<T, Internal::IsNotEqualTo, RhsT const&>
-    operator != ( RhsT const& rhs ) {
-        return captureExpression<Internal::IsNotEqualTo>( rhs );
-    }
-
-    template<typename RhsT>
-    BinaryExpression<T, Internal::IsLessThan, RhsT const&>
-    operator < ( RhsT const& rhs ) {
-        return captureExpression<Internal::IsLessThan>( rhs );
-    }
-
-    template<typename RhsT>
-    BinaryExpression<T, Internal::IsGreaterThan, RhsT const&>
-    operator > ( RhsT const& rhs ) {
-        return captureExpression<Internal::IsGreaterThan>( rhs );
-    }
-
-    template<typename RhsT>
-    BinaryExpression<T, Internal::IsLessThanOrEqualTo, RhsT const&>
-    operator <= ( RhsT const& rhs ) {
-        return captureExpression<Internal::IsLessThanOrEqualTo>( rhs );
-    }
-
-    template<typename RhsT>
-    BinaryExpression<T, Internal::IsGreaterThanOrEqualTo, RhsT const&>
-    operator >= ( RhsT const& rhs ) {
-        return captureExpression<Internal::IsGreaterThanOrEqualTo>( rhs );
-    }
-
-    BinaryExpression<T, Internal::IsEqualTo, bool> operator == ( bool rhs ) {
-        return captureExpression<Internal::IsEqualTo>( rhs );
-    }
-
-    BinaryExpression<T, Internal::IsNotEqualTo, bool> operator != ( bool rhs ) {
-        return captureExpression<Internal::IsNotEqualTo>( rhs );
-    }
-
-    void endExpression() {
-        m_truthy = m_lhs ? true : false;
-        m_rb
-            .setResultType( m_truthy )
-            .endExpression( *this );
-    }
-
-    virtual void reconstructExpression( std::string& dest ) const CATCH_OVERRIDE {
-        dest = Catch::toString( m_lhs );
-    }
-
-private:
-    template<Internal::Operator Op, typename RhsT>
-    BinaryExpression<T, Op, RhsT&> captureExpression( RhsT& rhs ) const {
-        return BinaryExpression<T, Op, RhsT&>( m_rb, m_lhs, rhs );
-    }
-
-    template<Internal::Operator Op>
-    BinaryExpression<T, Op, bool> captureExpression( bool rhs ) const {
-        return BinaryExpression<T, Op, bool>( m_rb, m_lhs, rhs );
-    }
-
-private:
-    ResultBuilder& m_rb;
-    T m_lhs;
-    bool m_truthy;
-};
-
-template<typename LhsT, Internal::Operator Op, typename RhsT>
-class BinaryExpression : public DecomposedExpression {
-public:
-    BinaryExpression( ResultBuilder& rb, LhsT lhs, RhsT rhs )
-        : m_rb( rb ), m_lhs( lhs ), m_rhs( rhs ) {}
-
-    BinaryExpression& operator = ( BinaryExpression& );
-
-    void endExpression() const {
-        m_rb
-            .setResultType( Internal::compare<Op>( m_lhs, m_rhs ) )
-            .endExpression( *this );
-    }
-
-    virtual bool isBinaryExpression() const CATCH_OVERRIDE {
-        return true;
-    }
-
-    virtual void reconstructExpression( std::string& dest ) const CATCH_OVERRIDE {
-        std::string lhs = Catch::toString( m_lhs );
-        std::string rhs = Catch::toString( m_rhs );
-        char delim = lhs.size() + rhs.size() < 40 &&
-                     lhs.find('\n') == std::string::npos &&
-                     rhs.find('\n') == std::string::npos ? ' ' : '\n';
-        dest.reserve( 7 + lhs.size() + rhs.size() );
-                   // 2 for spaces around operator
-                   // 2 for operator
-                   // 2 for parentheses (conditionally added later)
-                   // 1 for negation (conditionally added later)
-        dest = lhs;
-        dest += delim;
-        dest += Internal::OperatorTraits<Op>::getName();
-        dest += delim;
-        dest += rhs;
-    }
-
-private:
-    ResultBuilder& m_rb;
-    LhsT m_lhs;
-    RhsT m_rhs;
-};
-
-template<typename ArgT, typename MatcherT>
-class MatchExpression : public DecomposedExpression {
-public:
-    MatchExpression( ArgT arg, MatcherT matcher, char const* matcherString )
-        : m_arg( arg ), m_matcher( matcher ), m_matcherString( matcherString ) {}
-
-    virtual bool isBinaryExpression() const CATCH_OVERRIDE {
-        return true;
-    }
-
-    virtual void reconstructExpression( std::string& dest ) const CATCH_OVERRIDE {
-        std::string matcherAsString = m_matcher.toString();
-        dest = Catch::toString( m_arg );
-        dest += ' ';
-        if( matcherAsString == Detail::unprintableString )
-            dest += m_matcherString;
-        else
-            dest += matcherAsString;
-    }
-
-private:
-    ArgT m_arg;
-    MatcherT m_matcher;
-    char const* m_matcherString;
-};
-
-} // end namespace Catch
-
-
-namespace Catch {
-
-    template<typename T>
-    ExpressionLhs<T const&> ResultBuilder::operator <= ( T const& operand ) {
-        return ExpressionLhs<T const&>( *this, operand );
-    }
-
-    inline ExpressionLhs<bool> ResultBuilder::operator <= ( bool value ) {
-        return ExpressionLhs<bool>( *this, value );
-    }
-
-    template<typename ArgT, typename MatcherT>
-    void ResultBuilder::captureMatch( ArgT const& arg, MatcherT const& matcher,
-                                             char const* matcherString ) {
-        MatchExpression<ArgT const&, MatcherT const&> expr( arg, matcher, matcherString );
-        setResultType( matcher.match( arg ) );
-        endExpression( expr );
-    }
-
-} // namespace Catch
-
-// #included from: catch_message.h
-#define TWOBLUECUBES_CATCH_MESSAGE_H_INCLUDED
-
-#include <string>
-
-namespace Catch {
-
-    struct MessageInfo {
-        MessageInfo(    std::string const& _macroName,
-                        SourceLineInfo const& _lineInfo,
-                        ResultWas::OfType _type );
-
-        std::string macroName;
-        SourceLineInfo lineInfo;
-        ResultWas::OfType type;
-        std::string message;
-        unsigned int sequence;
-
-        bool operator == ( MessageInfo const& other ) const {
-            return sequence == other.sequence;
-        }
-        bool operator < ( MessageInfo const& other ) const {
-            return sequence < other.sequence;
-        }
-    private:
-        static unsigned int globalCount;
-    };
-
-    struct MessageBuilder {
-        MessageBuilder( std::string const& macroName,
-                        SourceLineInfo const& lineInfo,
-                        ResultWas::OfType type )
-        : m_info( macroName, lineInfo, type )
-        {}
-
-        template<typename T>
-        MessageBuilder& operator << ( T const& value ) {
-            m_stream << value;
-            return *this;
-        }
-
-        MessageInfo m_info;
-        std::ostringstream m_stream;
-    };
-
-    class ScopedMessage {
-    public:
-        ScopedMessage( MessageBuilder const& builder );
-        ScopedMessage( ScopedMessage const& other );
-        ~ScopedMessage();
-
-        MessageInfo m_info;
-    };
-
-} // end namespace Catch
-
-// #included from: catch_interfaces_capture.h
-#define TWOBLUECUBES_CATCH_INTERFACES_CAPTURE_H_INCLUDED
-
-#include <string>
-
-namespace Catch {
-
-    class TestCase;
-    class AssertionResult;
-    struct AssertionInfo;
-    struct SectionInfo;
-    struct SectionEndInfo;
-    struct MessageInfo;
-    class ScopedMessageBuilder;
-    struct Counts;
-
-    struct IResultCapture {
-
-        virtual ~IResultCapture();
-
-        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 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( std::string const& message ) = 0;
-
-        virtual bool lastAssertionPassed() = 0;
-        virtual void assertionPassed() = 0;
-        virtual void assertionRun() = 0;
-    };
-
-    IResultCapture& getResultCapture();
-}
-
-// #included from: catch_debugger.h
-#define TWOBLUECUBES_CATCH_DEBUGGER_H_INCLUDED
-
-// #included from: catch_platform.h
-#define TWOBLUECUBES_CATCH_PLATFORM_H_INCLUDED
-
-#if defined(__MAC_OS_X_VERSION_MIN_REQUIRED)
-#  define CATCH_PLATFORM_MAC
-#elif  defined(__IPHONE_OS_VERSION_MIN_REQUIRED)
-#  define CATCH_PLATFORM_IPHONE
-#elif defined(linux) || defined(__linux) || defined(__linux__)
-#  define CATCH_PLATFORM_LINUX
-#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER)
-#  define CATCH_PLATFORM_WINDOWS
-#  if !defined(NOMINMAX) && !defined(CATCH_CONFIG_NO_NOMINMAX)
-#    define CATCH_DEFINES_NOMINMAX
-#  endif
-#  if !defined(WIN32_LEAN_AND_MEAN) && !defined(CATCH_CONFIG_NO_WIN32_LEAN_AND_MEAN)
-#    define CATCH_DEFINES_WIN32_LEAN_AND_MEAN
-#  endif
-#endif
-
-#include <string>
-
-namespace Catch{
-
-    bool isDebuggerActive();
-    void writeToDebugConsole( std::string const& text );
-}
-
-#ifdef CATCH_PLATFORM_MAC
-
-    // The following code snippet based on:
-    // http://cocoawithlove.com/2008/03/break-into-debugger.html
-    #if defined(__ppc64__) || defined(__ppc__)
-        #define CATCH_TRAP() \
-                __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n" \
-                : : : "memory","r0","r3","r4" ) /* NOLINT */
-    #else
-        #define CATCH_TRAP() __asm__("int $3\n" : : /* NOLINT */ )
-    #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>
-
-        #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
-
-// #included from: catch_interfaces_runner.h
-#define TWOBLUECUBES_CATCH_INTERFACES_RUNNER_H_INCLUDED
-
-namespace Catch {
-    class TestCase;
-
-    struct IRunner {
-        virtual ~IRunner();
-        virtual bool aborting() const = 0;
-    };
-}
-
-#if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION)
-# define CATCH_INTERNAL_STRINGIFY(expr) #expr
-#else
-# define CATCH_INTERNAL_STRINGIFY(expr) "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( resultBuilder ) \
-    resultBuilder.react();
-
-///////////////////////////////////////////////////////////////////////////////
-// 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_TEST_NO_TRY( macroName, resultDisposition, expr ) \
-    do { \
-        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr), resultDisposition ); \
-        __catchResult.setExceptionGuard(); \
-        CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
-        ( __catchResult <= expr ).endExpression(); \
-        CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
-        __catchResult.unsetExceptionGuard(); \
-        INTERNAL_CATCH_REACT( __catchResult ) \
-    } while( Catch::isTrue( false && static_cast<bool>( !!(expr) ) ) ) // expr 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_CHECK_THAT_NO_TRY( macroName, matcher, resultDisposition, arg ) \
-    do { \
-        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
-        __catchResult.setExceptionGuard(); \
-        __catchResult.captureMatch( arg, matcher, CATCH_INTERNAL_STRINGIFY(matcher) ); \
-        __catchResult.unsetExceptionGuard(); \
-        INTERNAL_CATCH_REACT( __catchResult ) \
-    } while( Catch::alwaysFalse() )
-
-#else
-///////////////////////////////////////////////////////////////////////////////
-// 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( resultBuilder ) \
-    if( resultBuilder.shouldDebugBreak() ) CATCH_BREAK_INTO_DEBUGGER(); \
-    resultBuilder.react();
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_TEST( macroName, resultDisposition, expr ) \
-    do { \
-        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr), resultDisposition ); \
-        try { \
-            CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
-            ( __catchResult <= expr ).endExpression(); \
-            CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
-        } \
-        catch( ... ) { \
-            __catchResult.useActiveException( resultDisposition ); \
-        } \
-        INTERNAL_CATCH_REACT( __catchResult ) \
-    } while( Catch::isTrue( false && static_cast<bool>( !!(expr) ) ) ) // expr 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, expr ) \
-    INTERNAL_CATCH_TEST( macroName, resultDisposition, expr ); \
-    if( Catch::getResultCapture().lastAssertionPassed() )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_ELSE( macroName, resultDisposition, expr ) \
-    INTERNAL_CATCH_TEST( macroName, resultDisposition, expr ); \
-    if( !Catch::getResultCapture().lastAssertionPassed() )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, expr ) \
-    do { \
-        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr), resultDisposition ); \
-        try { \
-            static_cast<void>(expr); \
-            __catchResult.captureResult( Catch::ResultWas::Ok ); \
-        } \
-        catch( ... ) { \
-            __catchResult.useActiveException( resultDisposition ); \
-        } \
-        INTERNAL_CATCH_REACT( __catchResult ) \
-    } while( Catch::alwaysFalse() )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_THROWS( macroName, resultDisposition, matcher, expr ) \
-    do { \
-        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr), resultDisposition, CATCH_INTERNAL_STRINGIFY(matcher) ); \
-        if( __catchResult.allowThrows() ) \
-            try { \
-                static_cast<void>(expr); \
-                __catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \
-            } \
-            catch( ... ) { \
-                __catchResult.captureExpectedException( matcher ); \
-            } \
-        else \
-            __catchResult.captureResult( Catch::ResultWas::Ok ); \
-        INTERNAL_CATCH_REACT( __catchResult ) \
-    } while( Catch::alwaysFalse() )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \
-    do { \
-        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
-        if( __catchResult.allowThrows() ) \
-            try { \
-                static_cast<void>(expr); \
-                __catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \
-            } \
-            catch( exceptionType ) { \
-                __catchResult.captureResult( Catch::ResultWas::Ok ); \
-            } \
-            catch( ... ) { \
-                __catchResult.useActiveException( resultDisposition ); \
-            } \
-        else \
-            __catchResult.captureResult( Catch::ResultWas::Ok ); \
-        INTERNAL_CATCH_REACT( __catchResult ) \
-    } while( Catch::alwaysFalse() )
-
-///////////////////////////////////////////////////////////////////////////////
-#ifdef CATCH_CONFIG_VARIADIC_MACROS
-    #define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \
-        do { \
-            Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \
-            __catchResult << __VA_ARGS__ + ::Catch::StreamEndStop(); \
-            __catchResult.captureResult( messageType ); \
-            INTERNAL_CATCH_REACT( __catchResult ) \
-        } while( Catch::alwaysFalse() )
-#else
-    #define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, log ) \
-        do { \
-            Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \
-            __catchResult << log + ::Catch::StreamEndStop(); \
-            __catchResult.captureResult( messageType ); \
-            INTERNAL_CATCH_REACT( __catchResult ) \
-        } while( Catch::alwaysFalse() )
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_INFO( macroName, log ) \
-    Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage ) = Catch::MessageBuilder( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log;
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
-    do { \
-        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
-        try { \
-            __catchResult.captureMatch( arg, matcher, CATCH_INTERNAL_STRINGIFY(matcher) ); \
-        } catch( ... ) { \
-            __catchResult.useActiveException( resultDisposition | Catch::ResultDisposition::ContinueOnFailure ); \
-        } \
-        INTERNAL_CATCH_REACT( __catchResult ) \
-    } while( Catch::alwaysFalse() )
-
-// #included from: internal/catch_section.h
-#define TWOBLUECUBES_CATCH_SECTION_H_INCLUDED
-
-// #included from: catch_section_info.h
-#define TWOBLUECUBES_CATCH_SECTION_INFO_H_INCLUDED
-
-// #included from: catch_totals.hpp
-#define TWOBLUECUBES_CATCH_TOTALS_HPP_INCLUDED
-
-#include <cstddef>
-
-namespace Catch {
-
-    struct Counts {
-        Counts() : passed( 0 ), failed( 0 ), failedButOk( 0 ) {}
-
-        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& operator += ( Counts const& other ) {
-            passed += other.passed;
-            failed += other.failed;
-            failedButOk += other.failedButOk;
-            return *this;
-        }
-
-        std::size_t total() const {
-            return passed + failed + failedButOk;
-        }
-        bool allPassed() const {
-            return failed == 0 && failedButOk == 0;
-        }
-        bool allOk() const {
-            return failed == 0;
-        }
-
-        std::size_t passed;
-        std::size_t failed;
-        std::size_t failedButOk;
-    };
-
-    struct Totals {
-
-        Totals operator - ( Totals const& other ) const {
-            Totals diff;
-            diff.assertions = assertions - other.assertions;
-            diff.testCases = testCases - other.testCases;
-            return diff;
-        }
-
-        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;
-        }
-
-        Totals& operator += ( Totals const& other ) {
-            assertions += other.assertions;
-            testCases += other.testCases;
-            return *this;
-        }
-
-        Counts assertions;
-        Counts testCases;
-    };
-}
-
-#include <string>
-
-namespace Catch {
-
-    struct SectionInfo {
-        SectionInfo
-            (   SourceLineInfo const& _lineInfo,
-                std::string const& _name,
-                std::string const& _description = std::string() );
-
-        std::string name;
-        std::string description;
-        SourceLineInfo lineInfo;
-    };
-
-    struct SectionEndInfo {
-        SectionEndInfo( SectionInfo const& _sectionInfo, Counts const& _prevAssertions, double _durationInSeconds )
-        : sectionInfo( _sectionInfo ), prevAssertions( _prevAssertions ), durationInSeconds( _durationInSeconds )
-        {}
-
-        SectionInfo sectionInfo;
-        Counts prevAssertions;
-        double durationInSeconds;
-    };
-
-} // end namespace Catch
-
-// #included from: catch_timer.h
-#define TWOBLUECUBES_CATCH_TIMER_H_INCLUDED
-
-#ifdef _MSC_VER
-
-namespace Catch {
-    typedef unsigned long long UInt64;
-}
-#else
-#include <stdint.h>
-namespace Catch {
-    typedef uint64_t UInt64;
-}
-#endif
-
-namespace Catch {
-    class Timer {
-    public:
-        Timer() : m_ticks( 0 ) {}
-        void start();
-        unsigned int getElapsedMicroseconds() const;
-        unsigned int getElapsedMilliseconds() const;
-        double getElapsedSeconds() const;
-
-    private:
-        UInt64 m_ticks;
-    };
-
-} // namespace Catch
-
-#include <string>
-
-namespace Catch {
-
-    class Section : NonCopyable {
-    public:
-        Section( SectionInfo const& info );
-        ~Section();
-
-        // This indicates whether the section should be executed or not
-        operator bool() const;
-
-    private:
-        SectionInfo m_info;
-
-        std::string m_name;
-        Counts m_assertions;
-        bool m_sectionIncluded;
-        Timer m_timer;
-    };
-
-} // end namespace Catch
-
-#ifdef CATCH_CONFIG_VARIADIC_MACROS
-    #define INTERNAL_CATCH_SECTION( ... ) \
-        if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) )
-#else
-    #define INTERNAL_CATCH_SECTION( name, desc ) \
-        if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, name, desc ) )
-#endif
-
-// #included from: internal/catch_generators.hpp
-#define TWOBLUECUBES_CATCH_GENERATORS_HPP_INCLUDED
-
-#include <vector>
-#include <string>
-#include <stdlib.h>
-
-namespace Catch {
-
-template<typename T>
-struct IGenerator {
-    virtual ~IGenerator() {}
-    virtual T getValue( std::size_t index ) const = 0;
-    virtual std::size_t size () const = 0;
-};
-
-template<typename T>
-class BetweenGenerator : public IGenerator<T> {
-public:
-    BetweenGenerator( T from, T to ) : m_from( from ), m_to( to ){}
-
-    virtual T getValue( std::size_t index ) const {
-        return m_from+static_cast<int>( index );
-    }
-
-    virtual std::size_t size() const {
-        return static_cast<std::size_t>( 1+m_to-m_from );
-    }
-
-private:
-
-    T m_from;
-    T m_to;
-};
-
-template<typename T>
-class ValuesGenerator : public IGenerator<T> {
-public:
-    ValuesGenerator(){}
-
-    void add( T value ) {
-        m_values.push_back( value );
-    }
-
-    virtual T getValue( std::size_t index ) const {
-        return m_values[index];
-    }
-
-    virtual std::size_t size() const {
-        return m_values.size();
-    }
-
-private:
-    std::vector<T> m_values;
-};
-
-template<typename T>
-class CompositeGenerator {
-public:
-    CompositeGenerator() : m_totalSize( 0 ) {}
-
-    // *** Move semantics, similar to auto_ptr ***
-    CompositeGenerator( CompositeGenerator& other )
-    :   m_fileInfo( other.m_fileInfo ),
-        m_totalSize( 0 )
-    {
-        move( other );
-    }
-
-    CompositeGenerator& setFileInfo( const char* fileInfo ) {
-        m_fileInfo = fileInfo;
-        return *this;
-    }
-
-    ~CompositeGenerator() {
-        deleteAll( m_composed );
-    }
-
-    operator T () const {
-        size_t overallIndex = getCurrentContext().getGeneratorIndex( m_fileInfo, m_totalSize );
-
-        typename std::vector<const IGenerator<T>*>::const_iterator it = m_composed.begin();
-        typename std::vector<const IGenerator<T>*>::const_iterator itEnd = m_composed.end();
-        for( size_t index = 0; it != itEnd; ++it )
-        {
-            const IGenerator<T>* generator = *it;
-            if( overallIndex >= index && overallIndex < index + generator->size() )
-            {
-                return generator->getValue( overallIndex-index );
-            }
-            index += generator->size();
-        }
-        CATCH_INTERNAL_ERROR( "Indexed past end of generated range" );
-        return T(); // Suppress spurious "not all control paths return a value" warning in Visual Studio - if you know how to fix this please do so
-    }
-
-    void add( const IGenerator<T>* generator ) {
-        m_totalSize += generator->size();
-        m_composed.push_back( generator );
-    }
-
-    CompositeGenerator& then( CompositeGenerator& other ) {
-        move( other );
-        return *this;
-    }
-
-    CompositeGenerator& then( T value ) {
-        ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
-        valuesGen->add( value );
-        add( valuesGen );
-        return *this;
-    }
-
-private:
-
-    void move( CompositeGenerator& other ) {
-        m_composed.insert( m_composed.end(), other.m_composed.begin(), other.m_composed.end() );
-        m_totalSize += other.m_totalSize;
-        other.m_composed.clear();
-    }
-
-    std::vector<const IGenerator<T>*> m_composed;
-    std::string m_fileInfo;
-    size_t m_totalSize;
-};
-
-namespace Generators
-{
-    template<typename T>
-    CompositeGenerator<T> between( T from, T to ) {
-        CompositeGenerator<T> generators;
-        generators.add( new BetweenGenerator<T>( from, to ) );
-        return generators;
-    }
-
-    template<typename T>
-    CompositeGenerator<T> values( T val1, T val2 ) {
-        CompositeGenerator<T> generators;
-        ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
-        valuesGen->add( val1 );
-        valuesGen->add( val2 );
-        generators.add( valuesGen );
-        return generators;
-    }
-
-    template<typename T>
-    CompositeGenerator<T> values( T val1, T val2, T val3 ){
-        CompositeGenerator<T> generators;
-        ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
-        valuesGen->add( val1 );
-        valuesGen->add( val2 );
-        valuesGen->add( val3 );
-        generators.add( valuesGen );
-        return generators;
-    }
-
-    template<typename T>
-    CompositeGenerator<T> values( T val1, T val2, T val3, T val4 ) {
-        CompositeGenerator<T> generators;
-        ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
-        valuesGen->add( val1 );
-        valuesGen->add( val2 );
-        valuesGen->add( val3 );
-        valuesGen->add( val4 );
-        generators.add( valuesGen );
-        return generators;
-    }
-
-} // end namespace Generators
-
-using namespace Generators;
-
-} // end namespace Catch
-
-#define INTERNAL_CATCH_LINESTR2( line ) #line
-#define INTERNAL_CATCH_LINESTR( line ) INTERNAL_CATCH_LINESTR2( line )
-
-#define INTERNAL_CATCH_GENERATE( expr ) expr.setFileInfo( __FILE__ "(" INTERNAL_CATCH_LINESTR( __LINE__ ) ")" )
-
-// #included from: internal/catch_interfaces_exception.h
-#define TWOBLUECUBES_CATCH_INTERFACES_EXCEPTION_H_INCLUDED
-
-#include <string>
-#include <vector>
-
-// #included from: catch_interfaces_registry_hub.h
-#define TWOBLUECUBES_CATCH_INTERFACES_REGISTRY_HUB_H_INCLUDED
-
-#include <string>
-
-namespace Catch {
-
-    class TestCase;
-    struct ITestCaseRegistry;
-    struct IExceptionTranslatorRegistry;
-    struct IExceptionTranslator;
-    struct IReporterRegistry;
-    struct IReporterFactory;
-    struct ITagAliasRegistry;
-
-    struct IRegistryHub {
-        virtual ~IRegistryHub();
-
-        virtual IReporterRegistry const& getReporterRegistry() const = 0;
-        virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
-        virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0;
-
-        virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() = 0;
-    };
-
-    struct IMutableRegistryHub {
-        virtual ~IMutableRegistryHub();
-        virtual void registerReporter( std::string const& name, Ptr<IReporterFactory> const& factory ) = 0;
-        virtual void registerListener( Ptr<IReporterFactory> 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;
-    };
-
-    IRegistryHub& getRegistryHub();
-    IMutableRegistryHub& getMutableRegistryHub();
-    void cleanUp();
-    std::string translateActiveException();
-
-}
-
-namespace Catch {
-
-    typedef std::string(*exceptionTranslateFunction)();
-
-    struct IExceptionTranslator;
-    typedef std::vector<const IExceptionTranslator*> ExceptionTranslators;
-
-    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 )
-            {}
-
-            virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const CATCH_OVERRIDE {
-                try {
-                    if( it == itEnd )
-                        throw;
-                    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 ); }\
-    static std::string translatorName( signature )
-
-#define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION2( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
-
-// #included from: internal/catch_approx.hpp
-#define TWOBLUECUBES_CATCH_APPROX_HPP_INCLUDED
-
-#include <cmath>
-#include <limits>
-
-#if defined(CATCH_CONFIG_CPP11_TYPE_TRAITS)
-#include <type_traits>
-#endif
-
-namespace Catch {
-namespace Detail {
-
-    class Approx {
-    public:
-        explicit Approx ( double value )
-        :   m_epsilon( std::numeric_limits<float>::epsilon()*100 ),
-            m_margin( 0.0 ),
-            m_scale( 1.0 ),
-            m_value( value )
-        {}
-
-        static Approx custom() {
-            return Approx( 0 );
-        }
-
-#if defined(CATCH_CONFIG_CPP11_TYPE_TRAITS)
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx operator()( T 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 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 ) {
-            // Thanks to Richard Harris for his help refining this formula
-            auto lhs_v = double(lhs);
-            bool relativeOK = std::fabs(lhs_v - rhs.m_value) < rhs.m_epsilon * (rhs.m_scale + (std::max)(std::fabs(lhs_v), std::fabs(rhs.m_value)));
-            if (relativeOK) {
-                return true;
-            }
-
-            return std::fabs(lhs_v - rhs.m_value) <= rhs.m_margin;
-        }
-
-        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 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 rhs ) {
-            return !operator==( rhs, lhs );
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator <= ( T lhs, Approx const& rhs ) {
-            return 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 rhs ) {
-            return lhs.m_value < double(rhs) || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator >= ( T lhs, Approx const& rhs ) {
-            return 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 rhs ) {
-            return lhs.m_value > double(rhs) || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx& epsilon( T newEpsilon ) {
-            m_epsilon = double(newEpsilon);
-            return *this;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx& margin( T newMargin ) {
-            m_margin = double(newMargin);
-            return *this;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx& scale( T newScale ) {
-            m_scale = double(newScale);
-            return *this;
-        }
-
-#else
-
-        Approx operator()( double value ) {
-            Approx approx( value );
-            approx.epsilon( m_epsilon );
-            approx.margin( m_margin );
-            approx.scale( m_scale );
-            return approx;
-        }
-
-        friend bool operator == ( double lhs, Approx const& rhs ) {
-            // Thanks to Richard Harris for his help refining this formula
-            bool relativeOK = std::fabs( lhs - rhs.m_value ) < rhs.m_epsilon * (rhs.m_scale + (std::max)( std::fabs(lhs), std::fabs(rhs.m_value) ) );
-            if (relativeOK) {
-                return true;
-            }
-            return std::fabs(lhs - rhs.m_value) <= rhs.m_margin;
-        }
-
-        friend bool operator == ( Approx const& lhs, double rhs ) {
-            return operator==( rhs, lhs );
-        }
-
-        friend bool operator != ( double lhs, Approx const& rhs ) {
-            return !operator==( lhs, rhs );
-        }
-
-        friend bool operator != ( Approx const& lhs, double rhs ) {
-            return !operator==( rhs, lhs );
-        }
-
-        friend bool operator <= ( double lhs, Approx const& rhs ) {
-            return lhs < rhs.m_value || lhs == rhs;
-        }
-
-        friend bool operator <= ( Approx const& lhs, double rhs ) {
-            return lhs.m_value < rhs || lhs == rhs;
-        }
-
-        friend bool operator >= ( double lhs, Approx const& rhs ) {
-            return lhs > rhs.m_value || lhs == rhs;
-        }
-
-        friend bool operator >= ( Approx const& lhs, double rhs ) {
-            return lhs.m_value > rhs || lhs == rhs;
-        }
-
-        Approx& epsilon( double newEpsilon ) {
-            m_epsilon = newEpsilon;
-            return *this;
-        }
-
-        Approx& margin( double newMargin ) {
-            m_margin = newMargin;
-            return *this;
-        }
-
-        Approx& scale( double newScale ) {
-            m_scale = newScale;
-            return *this;
-        }
-#endif
-
-        std::string toString() const {
-            std::ostringstream oss;
-            oss << "Approx( " << Catch::toString( m_value ) << " )";
-            return oss.str();
-        }
-
-    private:
-        double m_epsilon;
-        double m_margin;
-        double m_scale;
-        double m_value;
-    };
-}
-
-template<>
-inline std::string toString<Detail::Approx>( Detail::Approx const& value ) {
-    return value.toString();
-}
-
-} // end namespace Catch
-
-// #included from: internal/catch_matchers_string.h
-#define TWOBLUECUBES_CATCH_MATCHERS_STRING_H_INCLUDED
-
-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 );
-            virtual std::string describe() const CATCH_OVERRIDE;
-
-            CasedString m_comparator;
-            std::string m_operation;
-        };
-
-        struct EqualsMatcher : StringMatcherBase {
-            EqualsMatcher( CasedString const& comparator );
-            virtual bool match( std::string const& source ) const CATCH_OVERRIDE;
-        };
-        struct ContainsMatcher : StringMatcherBase {
-            ContainsMatcher( CasedString const& comparator );
-            virtual bool match( std::string const& source ) const CATCH_OVERRIDE;
-        };
-        struct StartsWithMatcher : StringMatcherBase {
-            StartsWithMatcher( CasedString const& comparator );
-            virtual bool match( std::string const& source ) const CATCH_OVERRIDE;
-        };
-        struct EndsWithMatcher : StringMatcherBase {
-            EndsWithMatcher( CasedString const& comparator );
-            virtual bool match( std::string const& source ) const CATCH_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 Catch
-
-// #included from: internal/catch_matchers_vector.h
-#define TWOBLUECUBES_CATCH_MATCHERS_VECTOR_H_INCLUDED
-
-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 CATCH_OVERRIDE {
-                return std::find(v.begin(), v.end(), m_comparator) != v.end();
-            }
-
-            virtual std::string describe() const CATCH_OVERRIDE {
-                return "Contains: " + Catch::toString( 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 CATCH_OVERRIDE {
-                // !TBD: see note in EqualsMatcher
-                if (m_comparator.size() > v.size())
-                    return false;
-                for (size_t i = 0; i < m_comparator.size(); ++i)
-                    if (std::find(v.begin(), v.end(), m_comparator[i]) == v.end())
-                        return false;
-                return true;
-            }
-            virtual std::string describe() const CATCH_OVERRIDE {
-                return "Contains: " + Catch::toString( 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 CATCH_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 (size_t i = 0; i < v.size(); ++i)
-                    if (m_comparator[i] != v[i])
-                        return false;
-                return true;
-            }
-            virtual std::string describe() const CATCH_OVERRIDE {
-                return "Equals: " + Catch::toString( 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
-} // namespace Catch
-
-// #included from: internal/catch_interfaces_tag_alias_registry.h
-#define TWOBLUECUBES_CATCH_INTERFACES_TAG_ALIAS_REGISTRY_H_INCLUDED
-
-// #included from: catch_tag_alias.h
-#define TWOBLUECUBES_CATCH_TAG_ALIAS_H_INCLUDED
-
-#include <string>
-
-namespace Catch {
-
-    struct TagAlias {
-        TagAlias( std::string const& _tag, SourceLineInfo _lineInfo ) : tag( _tag ), lineInfo( _lineInfo ) {}
-
-        std::string tag;
-        SourceLineInfo 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 ); }
-// #included from: catch_option.hpp
-#define TWOBLUECUBES_CATCH_OPTION_HPP_INCLUDED
-
-namespace Catch {
-
-    // An optional type
-    template<typename T>
-    class Option {
-    public:
-        Option() : nullableValue( CATCH_NULL ) {}
-        Option( T const& _value )
-        : nullableValue( new( storage ) T( _value ) )
-        {}
-        Option( Option const& _other )
-        : nullableValue( _other ? new( storage ) T( *_other ) : CATCH_NULL )
-        {}
-
-        ~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 = CATCH_NULL;
-        }
-
-        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 != CATCH_NULL; }
-        bool none() const { return nullableValue == CATCH_NULL; }
-
-        bool operator !() const { return nullableValue == CATCH_NULL; }
-        operator SafeBool::type() const {
-            return SafeBool::makeSafe( some() );
-        }
-
-    private:
-        T *nullableValue;
-        union {
-            char storage[sizeof(T)];
-
-            // These are here to force alignment for the storage
-            long double dummy1;
-            void (*dummy2)();
-            long double dummy3;
-#ifdef CATCH_CONFIG_CPP11_LONG_LONG
-            long long dummy4;
-#endif
-        };
-    };
-
-} // end namespace Catch
-
-namespace Catch {
-
-    struct ITagAliasRegistry {
-        virtual ~ITagAliasRegistry();
-        virtual Option<TagAlias> find( std::string const& alias ) const = 0;
-        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;
-
-        static ITagAliasRegistry const& get();
-    };
-
-} // end namespace Catch
-
-// These files are included here so the single_include script doesn't put them
-// in the conditionally compiled sections
-// #included from: internal/catch_test_case_info.h
-#define TWOBLUECUBES_CATCH_TEST_CASE_INFO_H_INCLUDED
-
-#include <string>
-#include <set>
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-namespace Catch {
-
-    struct ITestCase;
-
-    struct TestCaseInfo {
-        enum SpecialProperties{
-            None = 0,
-            IsHidden = 1 << 1,
-            ShouldFail = 1 << 2,
-            MayFail = 1 << 3,
-            Throws = 1 << 4,
-            NonPortable = 1 << 5
-        };
-
-        TestCaseInfo(   std::string const& _name,
-                        std::string const& _className,
-                        std::string const& _description,
-                        std::set<std::string> const& _tags,
-                        SourceLineInfo const& _lineInfo );
-
-        TestCaseInfo( TestCaseInfo const& other );
-
-        friend void setTags( TestCaseInfo& testCaseInfo, std::set<std::string> const& tags );
-
-        bool isHidden() const;
-        bool throws() const;
-        bool okToFail() const;
-        bool expectedToFail() const;
-
-        std::string name;
-        std::string className;
-        std::string description;
-        std::set<std::string> tags;
-        std::set<std::string> lcaseTags;
-        std::string tagsAsString;
-        SourceLineInfo lineInfo;
-        SpecialProperties properties;
-    };
-
-    class TestCase : public TestCaseInfo {
-    public:
-
-        TestCase( ITestCase* testCase, TestCaseInfo const& info );
-        TestCase( TestCase const& other );
-
-        TestCase withName( std::string const& _newName ) const;
-
-        void invoke() const;
-
-        TestCaseInfo const& getTestCaseInfo() const;
-
-        void swap( TestCase& other );
-        bool operator == ( TestCase const& other ) const;
-        bool operator < ( TestCase const& other ) const;
-        TestCase& operator = ( TestCase const& other );
-
-    private:
-        Ptr<ITestCase> test;
-    };
-
-    TestCase makeTestCase(  ITestCase* testCase,
-                            std::string const& className,
-                            std::string const& name,
-                            std::string const& description,
-                            SourceLineInfo const& lineInfo );
-}
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-
-#ifdef __OBJC__
-// #included from: internal/catch_objc.hpp
-#define TWOBLUECUBES_CATCH_OBJC_HPP_INCLUDED
-
-#import <objc/runtime.h>
-
-#include <string>
-
-// NB. Any general catch headers included here must be included
-// in catch.hpp first to make sure they are included by the single
-// header for non obj-usage
-
-///////////////////////////////////////////////////////////////////////////////
-// This protocol is really only here for (self) documenting purposes, since
-// all its methods are optional.
-@protocol OcFixture
-
-@optional
-
--(void) setUp;
--(void) tearDown;
-
-@end
-
-namespace Catch {
-
-    class OcMethod : public SharedImpl<ITestCase> {
-
-    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 size_t registerTestMethods() {
-        size_t noTestMethods = 0;
-        int noClasses = objc_getClassList( CATCH_NULL, 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() ) );
-                        noTestMethods++;
-                    }
-                }
-                free(methods);
-            }
-        }
-        return noTestMethods;
-    }
-
-    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 );
-                }
-
-                virtual bool match( NSString* arg ) const CATCH_OVERRIDE {
-                    return false;
-                }
-
-                NSString* m_substr;
-            };
-
-            struct Equals : StringHolder {
-                Equals( NSString* substr ) : StringHolder( substr ){}
-
-                virtual bool match( NSString* str ) const CATCH_OVERRIDE {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str isEqualToString:m_substr];
-                }
-
-                virtual std::string describe() const CATCH_OVERRIDE {
-                    return "equals string: " + Catch::toString( m_substr );
-                }
-            };
-
-            struct Contains : StringHolder {
-                Contains( NSString* substr ) : StringHolder( substr ){}
-
-                virtual bool match( NSString* str ) const {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location != NSNotFound;
-                }
-
-                virtual std::string describe() const CATCH_OVERRIDE {
-                    return "contains string: " + Catch::toString( m_substr );
-                }
-            };
-
-            struct StartsWith : StringHolder {
-                StartsWith( NSString* substr ) : StringHolder( substr ){}
-
-                virtual bool match( NSString* str ) const {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location == 0;
-                }
-
-                virtual std::string describe() const CATCH_OVERRIDE {
-                    return "starts with: " + Catch::toString( m_substr );
-                }
-            };
-            struct EndsWith : StringHolder {
-                EndsWith( NSString* substr ) : StringHolder( substr ){}
-
-                virtual bool match( NSString* str ) const {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location == [str length] - [m_substr length];
-                }
-
-                virtual std::string describe() const CATCH_OVERRIDE {
-                    return "ends with: " + Catch::toString( m_substr );
-                }
-            };
-
-        } // namespace NSStringMatchers
-        } // namespace Impl
-
-        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::StartsWith
-            StartsWith( NSString* substr ){ return Impl::NSStringMatchers::StartsWith( substr ); }
-
-        inline Impl::NSStringMatchers::EndsWith
-            EndsWith( NSString* substr ){ return Impl::NSStringMatchers::EndsWith( substr ); }
-
-    } // namespace Matchers
-
-    using namespace Matchers;
-
-} // namespace Catch
-
-///////////////////////////////////////////////////////////////////////////////
-#define OC_TEST_CASE( name, desc )\
-+(NSString*) INTERNAL_CATCH_UNIQUE_NAME( Catch_Name_test ) \
-{\
-return @ name; \
-}\
-+(NSString*) INTERNAL_CATCH_UNIQUE_NAME( Catch_Description_test ) \
-{ \
-return @ desc; \
-} \
--(void) INTERNAL_CATCH_UNIQUE_NAME( Catch_TestCase_test )
-
-#endif
-
-#ifdef CATCH_IMPL
-
-// !TBD: Move the leak detector code into a separate header
-#ifdef CATCH_CONFIG_WINDOWS_CRTDBG
-#include <crtdbg.h>
-class LeakDetector {
-public:
-    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);
-    }
-};
-#else
-class LeakDetector {};
-#endif
-
-LeakDetector leakDetector;
-
-// #included from: internal/catch_impl.hpp
-#define TWOBLUECUBES_CATCH_IMPL_HPP_INCLUDED
-
-// Collect all the implementation files together here
-// These are the equivalent of what would usually be cpp files
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wweak-vtables"
-#endif
-
-// #included from: ../catch_session.hpp
-#define TWOBLUECUBES_CATCH_RUNNER_HPP_INCLUDED
-
-// #included from: internal/catch_commandline.hpp
-#define TWOBLUECUBES_CATCH_COMMANDLINE_HPP_INCLUDED
-
-// #included from: catch_config.hpp
-#define TWOBLUECUBES_CATCH_CONFIG_HPP_INCLUDED
-
-// #included from: catch_test_spec_parser.hpp
-#define TWOBLUECUBES_CATCH_TEST_SPEC_PARSER_HPP_INCLUDED
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-// #included from: catch_test_spec.hpp
-#define TWOBLUECUBES_CATCH_TEST_SPEC_HPP_INCLUDED
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-// #included from: catch_wildcard_pattern.hpp
-#define TWOBLUECUBES_CATCH_WILDCARD_PATTERN_HPP_INCLUDED
-
-#include <stdexcept>
-
-namespace Catch
-{
-    class WildcardPattern {
-        enum WildcardPosition {
-            NoWildcard = 0,
-            WildcardAtStart = 1,
-            WildcardAtEnd = 2,
-            WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
-        };
-
-    public:
-
-        WildcardPattern( std::string const& pattern, CaseSensitive::Choice caseSensitivity )
-        :   m_caseSensitivity( caseSensitivity ),
-            m_wildcard( NoWildcard ),
-            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 );
-            }
-        }
-        virtual ~WildcardPattern();
-        virtual bool 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 );
-            }
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wunreachable-code"
-#endif
-            throw std::logic_error( "Unknown enum" );
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-        }
-    private:
-        std::string adjustCase( std::string const& str ) const {
-            return m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str;
-        }
-        CaseSensitive::Choice m_caseSensitivity;
-        WildcardPosition m_wildcard;
-        std::string m_pattern;
-    };
-}
-
-#include <string>
-#include <vector>
-
-namespace Catch {
-
-    class TestSpec {
-        struct Pattern : SharedImpl<> {
-            virtual ~Pattern();
-            virtual bool matches( TestCaseInfo const& testCase ) const = 0;
-        };
-        class NamePattern : public Pattern {
-        public:
-            NamePattern( std::string const& name )
-            : m_wildcardPattern( toLower( name ), CaseSensitive::No )
-            {}
-            virtual ~NamePattern();
-            virtual bool matches( TestCaseInfo const& testCase ) const {
-                return m_wildcardPattern.matches( toLower( testCase.name ) );
-            }
-        private:
-            WildcardPattern m_wildcardPattern;
-        };
-
-        class TagPattern : public Pattern {
-        public:
-            TagPattern( std::string const& tag ) : m_tag( toLower( tag ) ) {}
-            virtual ~TagPattern();
-            virtual bool matches( TestCaseInfo const& testCase ) const {
-                return testCase.lcaseTags.find( m_tag ) != testCase.lcaseTags.end();
-            }
-        private:
-            std::string m_tag;
-        };
-
-        class ExcludedPattern : public Pattern {
-        public:
-            ExcludedPattern( Ptr<Pattern> const& underlyingPattern ) : m_underlyingPattern( underlyingPattern ) {}
-            virtual ~ExcludedPattern();
-            virtual bool matches( TestCaseInfo const& testCase ) const { return !m_underlyingPattern->matches( testCase ); }
-        private:
-            Ptr<Pattern> m_underlyingPattern;
-        };
-
-        struct Filter {
-            std::vector<Ptr<Pattern> > m_patterns;
-
-            bool matches( TestCaseInfo const& testCase ) const {
-                // All patterns in a filter must match for the filter to be a match
-                for( std::vector<Ptr<Pattern> >::const_iterator it = m_patterns.begin(), itEnd = m_patterns.end(); it != itEnd; ++it ) {
-                    if( !(*it)->matches( testCase ) )
-                        return false;
-                }
-                return true;
-            }
-        };
-
-    public:
-        bool hasFilters() const {
-            return !m_filters.empty();
-        }
-        bool matches( TestCaseInfo const& testCase ) const {
-            // A TestSpec matches if any filter matches
-            for( std::vector<Filter>::const_iterator it = m_filters.begin(), itEnd = m_filters.end(); it != itEnd; ++it )
-                if( it->matches( testCase ) )
-                    return true;
-            return false;
-        }
-
-    private:
-        std::vector<Filter> m_filters;
-
-        friend class TestSpecParser;
-    };
-}
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-namespace Catch {
-
-    class TestSpecParser {
-        enum Mode{ None, Name, QuotedName, Tag, EscapedName };
-        Mode m_mode;
-        bool m_exclusion;
-        std::size_t m_start, m_pos;
-        std::string m_arg;
-        std::vector<std::size_t> m_escapeChars;
-        TestSpec::Filter m_currentFilter;
-        TestSpec m_testSpec;
-        ITagAliasRegistry const* m_tagAliases;
-
-    public:
-        TestSpecParser( ITagAliasRegistry const& tagAliases ) :m_mode(None), m_exclusion(false), m_start(0), m_pos(0), m_tagAliases( &tagAliases ) {}
-
-        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 testSpec() {
-            addFilter();
-            return m_testSpec;
-        }
-    private:
-        void 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 startNewMode( Mode mode, std::size_t start ) {
-            m_mode = mode;
-            m_start = start;
-        }
-        void escape() {
-            if( m_mode == None )
-                m_start = m_pos;
-            m_mode = EscapedName;
-            m_escapeChars.push_back( m_pos );
-        }
-        std::string subString() const { return m_arg.substr( m_start, m_pos - m_start ); }
-        template<typename T>
-        void addPattern() {
-            std::string token = subString();
-            for( 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() ) {
-                Ptr<TestSpec::Pattern> pattern = new T( token );
-                if( m_exclusion )
-                    pattern = new TestSpec::ExcludedPattern( pattern );
-                m_currentFilter.m_patterns.push_back( pattern );
-            }
-            m_exclusion = false;
-            m_mode = None;
-        }
-        void addFilter() {
-            if( !m_currentFilter.m_patterns.empty() ) {
-                m_testSpec.m_filters.push_back( m_currentFilter );
-                m_currentFilter = TestSpec::Filter();
-            }
-        }
-    };
-    inline TestSpec parseTestSpec( std::string const& arg ) {
-        return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec();
-    }
-
-} // namespace Catch
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-// #included from: catch_interfaces_config.h
-#define TWOBLUECUBES_CATCH_INTERFACES_CONFIG_H_INCLUDED
-
-#include <iosfwd>
-#include <string>
-#include <vector>
-
-namespace Catch {
-
-    struct Verbosity { enum Level {
-        NoOutput = 0,
-        Quiet,
-        Normal
-    }; };
-
-    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 : IShared {
-
-        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 UseColour::YesOrNo useColour() const = 0;
-        virtual std::vector<std::string> const& getSectionsToRun() const = 0;
-
-    };
-}
-
-// #included from: catch_stream.h
-#define TWOBLUECUBES_CATCH_STREAM_H_INCLUDED
-
-// #included from: catch_streambuf.h
-#define TWOBLUECUBES_CATCH_STREAMBUF_H_INCLUDED
-
-#include <streambuf>
-
-namespace Catch {
-
-    class StreamBufBase : public std::streambuf {
-    public:
-        virtual ~StreamBufBase() CATCH_NOEXCEPT;
-    };
-}
-
-#include <streambuf>
-#include <ostream>
-#include <fstream>
-#include <memory>
-
-namespace Catch {
-
-    std::ostream& cout();
-    std::ostream& cerr();
-    std::ostream& clog();
-
-    struct IStream {
-        virtual ~IStream() CATCH_NOEXCEPT;
-        virtual std::ostream& stream() const = 0;
-    };
-
-    class FileStream : public IStream {
-        mutable std::ofstream m_ofs;
-    public:
-        FileStream( std::string const& filename );
-        virtual ~FileStream() CATCH_NOEXCEPT;
-    public: // IStream
-        virtual std::ostream& stream() const CATCH_OVERRIDE;
-    };
-
-    class CoutStream : public IStream {
-        mutable std::ostream m_os;
-    public:
-        CoutStream();
-        virtual ~CoutStream() CATCH_NOEXCEPT;
-
-    public: // IStream
-        virtual std::ostream& stream() const CATCH_OVERRIDE;
-    };
-
-    class DebugOutStream : public IStream {
-        CATCH_AUTO_PTR( StreamBufBase ) m_streamBuf;
-        mutable std::ostream m_os;
-    public:
-        DebugOutStream();
-        virtual ~DebugOutStream() CATCH_NOEXCEPT;
-
-    public: // IStream
-        virtual std::ostream& stream() const CATCH_OVERRIDE;
-    };
-}
-
-#include <memory>
-#include <vector>
-#include <string>
-#include <stdexcept>
-
-#ifndef CATCH_CONFIG_CONSOLE_WIDTH
-#define CATCH_CONFIG_CONSOLE_WIDTH 80
-#endif
-
-namespace Catch {
-
-    struct ConfigData {
-
-        ConfigData()
-        :   listTests( false ),
-            listTags( false ),
-            listReporters( false ),
-            listTestNamesOnly( false ),
-            listExtraInfo( false ),
-            showSuccessfulTests( false ),
-            shouldDebugBreak( false ),
-            noThrow( false ),
-            showHelp( false ),
-            showInvisibles( false ),
-            filenamesAsTags( false ),
-            libIdentify( false ),
-            abortAfter( -1 ),
-            rngSeed( 0 ),
-            verbosity( Verbosity::Normal ),
-            warnings( WarnAbout::Nothing ),
-            showDurations( ShowDurations::DefaultForReporter ),
-            runOrder( RunTests::InDeclarationOrder ),
-            useColour( UseColour::Auto ),
-            waitForKeypress( WaitForKeypress::Never )
-        {}
-
-        bool listTests;
-        bool listTags;
-        bool listReporters;
-        bool listTestNamesOnly;
-        bool listExtraInfo;
-
-        bool showSuccessfulTests;
-        bool shouldDebugBreak;
-        bool noThrow;
-        bool showHelp;
-        bool showInvisibles;
-        bool filenamesAsTags;
-        bool libIdentify;
-
-        int abortAfter;
-        unsigned int rngSeed;
-
-        Verbosity::Level verbosity;
-        WarnAbout::What warnings;
-        ShowDurations::OrNot showDurations;
-        RunTests::InWhatOrder runOrder;
-        UseColour::YesOrNo useColour;
-        WaitForKeypress::When waitForKeypress;
-
-        std::string outputFilename;
-        std::string name;
-        std::string processName;
-
-        std::vector<std::string> reporterNames;
-        std::vector<std::string> testsOrTags;
-        std::vector<std::string> sectionsToRun;
-    };
-
-    class Config : public SharedImpl<IConfig> {
-    private:
-        Config( Config const& other );
-        Config& operator = ( Config const& other );
-        virtual void dummy();
-    public:
-
-        Config()
-        {}
-
-        Config( ConfigData const& data )
-        :   m_data( data ),
-            m_stream( openStream() )
-        {
-            if( !data.testsOrTags.empty() ) {
-                TestSpecParser parser( ITagAliasRegistry::get() );
-                for( std::size_t i = 0; i < data.testsOrTags.size(); ++i )
-                    parser.parse( data.testsOrTags[i] );
-                m_testSpec = parser.testSpec();
-            }
-        }
-
-        virtual ~Config() {}
-
-        std::string const& getFilename() const {
-            return m_data.outputFilename ;
-        }
-
-        bool listTests() const { return m_data.listTests; }
-        bool listTestNamesOnly() const { return m_data.listTestNamesOnly; }
-        bool listTags() const { return m_data.listTags; }
-        bool listReporters() const { return m_data.listReporters; }
-        bool listExtraInfo() const { return m_data.listExtraInfo; }
-
-        std::string getProcessName() const { return m_data.processName; }
-
-        std::vector<std::string> const& getReporterNames() const { return m_data.reporterNames; }
-        std::vector<std::string> const& getSectionsToRun() const CATCH_OVERRIDE { return m_data.sectionsToRun; }
-
-        virtual TestSpec const& testSpec() const CATCH_OVERRIDE { return m_testSpec; }
-
-        bool showHelp() const { return m_data.showHelp; }
-
-        // IConfig interface
-        virtual bool allowThrows() const CATCH_OVERRIDE                 { return !m_data.noThrow; }
-        virtual std::ostream& stream() const CATCH_OVERRIDE             { return m_stream->stream(); }
-        virtual std::string name() const CATCH_OVERRIDE                 { return m_data.name.empty() ? m_data.processName : m_data.name; }
-        virtual bool includeSuccessfulResults() const CATCH_OVERRIDE    { return m_data.showSuccessfulTests; }
-        virtual bool warnAboutMissingAssertions() const CATCH_OVERRIDE  { return m_data.warnings & WarnAbout::NoAssertions; }
-        virtual ShowDurations::OrNot showDurations() const CATCH_OVERRIDE { return m_data.showDurations; }
-        virtual RunTests::InWhatOrder runOrder() const CATCH_OVERRIDE   { return m_data.runOrder; }
-        virtual unsigned int rngSeed() const CATCH_OVERRIDE             { return m_data.rngSeed; }
-        virtual UseColour::YesOrNo useColour() const CATCH_OVERRIDE     { return m_data.useColour; }
-        virtual bool shouldDebugBreak() const CATCH_OVERRIDE { return m_data.shouldDebugBreak; }
-        virtual int abortAfter() const CATCH_OVERRIDE { return m_data.abortAfter; }
-        virtual bool showInvisibles() const CATCH_OVERRIDE { return m_data.showInvisibles; }
-
-    private:
-
-        IStream const* openStream() {
-            if( m_data.outputFilename.empty() )
-                return new CoutStream();
-            else if( m_data.outputFilename[0] == '%' ) {
-                if( m_data.outputFilename == "%debug" )
-                    return new DebugOutStream();
-                else
-                    throw std::domain_error( "Unrecognised stream: " + m_data.outputFilename );
-            }
-            else
-                return new FileStream( m_data.outputFilename );
-        }
-        ConfigData m_data;
-
-        CATCH_AUTO_PTR( IStream const ) m_stream;
-        TestSpec m_testSpec;
-    };
-
-} // end namespace Catch
-
-// #included from: catch_clara.h
-#define TWOBLUECUBES_CATCH_CLARA_H_INCLUDED
-
-// 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 CLARA_CONFIG_CONSOLE_WIDTH
-#undef CLARA_CONFIG_CONSOLE_WIDTH
-#endif
-#define CLARA_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH
-
-// Declare Clara inside the Catch namespace
-#define STITCH_CLARA_OPEN_NAMESPACE namespace Catch {
-// #included from: ../external/clara.h
-
-// Version 0.0.2.4
-
-// Only use header guard if we are not using an outer namespace
-#if !defined(TWOBLUECUBES_CLARA_H_INCLUDED) || defined(STITCH_CLARA_OPEN_NAMESPACE)
-
-#ifndef STITCH_CLARA_OPEN_NAMESPACE
-#define TWOBLUECUBES_CLARA_H_INCLUDED
-#define STITCH_CLARA_OPEN_NAMESPACE
-#define STITCH_CLARA_CLOSE_NAMESPACE
-#else
-#define STITCH_CLARA_CLOSE_NAMESPACE }
-#endif
-
-#define STITCH_TBC_TEXT_FORMAT_OPEN_NAMESPACE STITCH_CLARA_OPEN_NAMESPACE
-
-// ----------- #included from tbc_text_format.h -----------
-
-// Only use header guard if we are not using an outer namespace
-#if !defined(TBC_TEXT_FORMAT_H_INCLUDED) || defined(STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE)
-#ifndef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE
-#define TBC_TEXT_FORMAT_H_INCLUDED
-#endif
-
-#include <string>
-#include <vector>
-#include <sstream>
-#include <algorithm>
-#include <cctype>
-
-// Use optional outer namespace
-#ifdef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE
-namespace STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE {
-#endif
-
-namespace Tbc {
-
-#ifdef TBC_TEXT_FORMAT_CONSOLE_WIDTH
-    const unsigned int consoleWidth = TBC_TEXT_FORMAT_CONSOLE_WIDTH;
-#else
-    const unsigned int consoleWidth = 80;
-#endif
-
-    struct TextAttributes {
-        TextAttributes()
-        :   initialIndent( std::string::npos ),
-            indent( 0 ),
-            width( consoleWidth-1 ),
-            tabChar( '\t' )
-        {}
-
-        TextAttributes& setInitialIndent( std::size_t _value )  { initialIndent = _value; return *this; }
-        TextAttributes& setIndent( std::size_t _value )         { indent = _value; return *this; }
-        TextAttributes& setWidth( std::size_t _value )          { width = _value; return *this; }
-        TextAttributes& setTabChar( char _value )               { tabChar = _value; return *this; }
-
-        std::size_t initialIndent;  // indent of first line, or npos
-        std::size_t indent;         // indent of subsequent lines, or all if initialIndent is npos
-        std::size_t width;          // maximum width of text, including indent. Longer text will wrap
-        char tabChar;               // If this char is seen the indent is changed to current pos
-    };
-
-    class Text {
-    public:
-        Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() )
-        : attr( _attr )
-        {
-            std::string wrappableChars = " [({.,/|\\-";
-            std::size_t indent = _attr.initialIndent != std::string::npos
-                ? _attr.initialIndent
-                : _attr.indent;
-            std::string remainder = _str;
-
-            while( !remainder.empty() ) {
-                if( lines.size() >= 1000 ) {
-                    lines.push_back( "... message truncated due to excessive size" );
-                    return;
-                }
-                std::size_t tabPos = std::string::npos;
-                std::size_t width = (std::min)( remainder.size(), _attr.width - indent );
-                std::size_t pos = remainder.find_first_of( '\n' );
-                if( pos <= width ) {
-                    width = pos;
-                }
-                pos = remainder.find_last_of( _attr.tabChar, width );
-                if( pos != std::string::npos ) {
-                    tabPos = pos;
-                    if( remainder[width] == '\n' )
-                        width--;
-                    remainder = remainder.substr( 0, tabPos ) + remainder.substr( tabPos+1 );
-                }
-
-                if( width == remainder.size() ) {
-                    spliceLine( indent, remainder, width );
-                }
-                else if( remainder[width] == '\n' ) {
-                    spliceLine( indent, remainder, width );
-                    if( width <= 1 || remainder.size() != 1 )
-                        remainder = remainder.substr( 1 );
-                    indent = _attr.indent;
-                }
-                else {
-                    pos = remainder.find_last_of( wrappableChars, width );
-                    if( pos != std::string::npos && pos > 0 ) {
-                        spliceLine( indent, remainder, pos );
-                        if( remainder[0] == ' ' )
-                            remainder = remainder.substr( 1 );
-                    }
-                    else {
-                        spliceLine( indent, remainder, width-1 );
-                        lines.back() += "-";
-                    }
-                    if( lines.size() == 1 )
-                        indent = _attr.indent;
-                    if( tabPos != std::string::npos )
-                        indent += tabPos;
-                }
-            }
-        }
-
-        void spliceLine( std::size_t _indent, std::string& _remainder, std::size_t _pos ) {
-            lines.push_back( std::string( _indent, ' ' ) + _remainder.substr( 0, _pos ) );
-            _remainder = _remainder.substr( _pos );
-        }
-
-        typedef std::vector<std::string>::const_iterator const_iterator;
-
-        const_iterator begin() const { return lines.begin(); }
-        const_iterator end() const { return lines.end(); }
-        std::string const& last() const { return lines.back(); }
-        std::size_t size() const { return lines.size(); }
-        std::string const& operator[]( std::size_t _index ) const { return lines[_index]; }
-        std::string toString() const {
-            std::ostringstream oss;
-            oss << *this;
-            return oss.str();
-        }
-
-        friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) {
-            for( Text::const_iterator it = _text.begin(), itEnd = _text.end();
-                it != itEnd; ++it ) {
-                if( it != _text.begin() )
-                    _stream << "\n";
-                _stream << *it;
-            }
-            return _stream;
-        }
-
-    private:
-        std::string str;
-        TextAttributes attr;
-        std::vector<std::string> lines;
-    };
-
-} // end namespace Tbc
-
-#ifdef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE
-} // end outer namespace
-#endif
-
-#endif // TBC_TEXT_FORMAT_H_INCLUDED
-
-// ----------- end of #include from tbc_text_format.h -----------
-// ........... back in clara.h
-
-#undef STITCH_TBC_TEXT_FORMAT_OPEN_NAMESPACE
-
-// ----------- #included from clara_compilers.h -----------
-
-#ifndef TWOBLUECUBES_CLARA_COMPILERS_H_INCLUDED
-#define TWOBLUECUBES_CLARA_COMPILERS_H_INCLUDED
-
-// Detect a number of compiler features - mostly C++11/14 conformance - by compiler
-// The following features are defined:
-//
-// CLARA_CONFIG_CPP11_NULLPTR : is nullptr supported?
-// CLARA_CONFIG_CPP11_NOEXCEPT : is noexcept supported?
-// CLARA_CONFIG_CPP11_GENERATED_METHODS : The delete and default keywords for compiler generated methods
-// CLARA_CONFIG_CPP11_OVERRIDE : is override supported?
-// CLARA_CONFIG_CPP11_UNIQUE_PTR : is unique_ptr supported (otherwise use auto_ptr)
-
-// CLARA_CONFIG_CPP11_OR_GREATER : Is C++11 supported?
-
-// CLARA_CONFIG_VARIADIC_MACROS : are variadic macros supported?
-
-// In general each macro has a _NO_<feature name> form
-// (e.g. CLARA_CONFIG_CPP11_NO_NULLPTR) which disables the feature.
-// Many features, at point of detection, define an _INTERNAL_ macro, so they
-// can be combined, en-mass, with the _NO_ forms later.
-
-// All the C++11 features can be disabled with CLARA_CONFIG_NO_CPP11
-
-#ifdef __clang__
-
-#if __has_feature(cxx_nullptr)
-#define CLARA_INTERNAL_CONFIG_CPP11_NULLPTR
-#endif
-
-#if __has_feature(cxx_noexcept)
-#define CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT
-#endif
-
-#endif // __clang__
-
-////////////////////////////////////////////////////////////////////////////////
-// GCC
-#ifdef __GNUC__
-
-#if __GNUC__ == 4 && __GNUC_MINOR__ >= 6 && defined(__GXX_EXPERIMENTAL_CXX0X__)
-#define CLARA_INTERNAL_CONFIG_CPP11_NULLPTR
-#endif
-
-// - otherwise more recent versions define __cplusplus >= 201103L
-// and will get picked up below
-
-#endif // __GNUC__
-
-////////////////////////////////////////////////////////////////////////////////
-// Visual C++
-#ifdef _MSC_VER
-
-#if (_MSC_VER >= 1600)
-#define CLARA_INTERNAL_CONFIG_CPP11_NULLPTR
-#define CLARA_INTERNAL_CONFIG_CPP11_UNIQUE_PTR
-#endif
-
-#if (_MSC_VER >= 1900 ) // (VC++ 13 (VS2015))
-#define CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT
-#define CLARA_INTERNAL_CONFIG_CPP11_GENERATED_METHODS
-#endif
-
-#endif // _MSC_VER
-
-////////////////////////////////////////////////////////////////////////////////
-// C++ language feature support
-
-// catch all support for C++11
-#if defined(__cplusplus) && __cplusplus >= 201103L
-
-#define CLARA_CPP11_OR_GREATER
-
-#if !defined(CLARA_INTERNAL_CONFIG_CPP11_NULLPTR)
-#define CLARA_INTERNAL_CONFIG_CPP11_NULLPTR
-#endif
-
-#ifndef CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT
-#define CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT
-#endif
-
-#ifndef CLARA_INTERNAL_CONFIG_CPP11_GENERATED_METHODS
-#define CLARA_INTERNAL_CONFIG_CPP11_GENERATED_METHODS
-#endif
-
-#if !defined(CLARA_INTERNAL_CONFIG_CPP11_OVERRIDE)
-#define CLARA_INTERNAL_CONFIG_CPP11_OVERRIDE
-#endif
-#if !defined(CLARA_INTERNAL_CONFIG_CPP11_UNIQUE_PTR)
-#define CLARA_INTERNAL_CONFIG_CPP11_UNIQUE_PTR
-#endif
-
-#endif // __cplusplus >= 201103L
-
-// Now set the actual defines based on the above + anything the user has configured
-#if defined(CLARA_INTERNAL_CONFIG_CPP11_NULLPTR) && !defined(CLARA_CONFIG_CPP11_NO_NULLPTR) && !defined(CLARA_CONFIG_CPP11_NULLPTR) && !defined(CLARA_CONFIG_NO_CPP11)
-#define CLARA_CONFIG_CPP11_NULLPTR
-#endif
-#if defined(CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT) && !defined(CLARA_CONFIG_CPP11_NO_NOEXCEPT) && !defined(CLARA_CONFIG_CPP11_NOEXCEPT) && !defined(CLARA_CONFIG_NO_CPP11)
-#define CLARA_CONFIG_CPP11_NOEXCEPT
-#endif
-#if defined(CLARA_INTERNAL_CONFIG_CPP11_GENERATED_METHODS) && !defined(CLARA_CONFIG_CPP11_NO_GENERATED_METHODS) && !defined(CLARA_CONFIG_CPP11_GENERATED_METHODS) && !defined(CLARA_CONFIG_NO_CPP11)
-#define CLARA_CONFIG_CPP11_GENERATED_METHODS
-#endif
-#if defined(CLARA_INTERNAL_CONFIG_CPP11_OVERRIDE) && !defined(CLARA_CONFIG_NO_OVERRIDE) && !defined(CLARA_CONFIG_CPP11_OVERRIDE) && !defined(CLARA_CONFIG_NO_CPP11)
-#define CLARA_CONFIG_CPP11_OVERRIDE
-#endif
-#if defined(CLARA_INTERNAL_CONFIG_CPP11_UNIQUE_PTR) && !defined(CLARA_CONFIG_NO_UNIQUE_PTR) && !defined(CLARA_CONFIG_CPP11_UNIQUE_PTR) && !defined(CLARA_CONFIG_NO_CPP11)
-#define CLARA_CONFIG_CPP11_UNIQUE_PTR
-#endif
-
-// noexcept support:
-#if defined(CLARA_CONFIG_CPP11_NOEXCEPT) && !defined(CLARA_NOEXCEPT)
-#define CLARA_NOEXCEPT noexcept
-#  define CLARA_NOEXCEPT_IS(x) noexcept(x)
-#else
-#define CLARA_NOEXCEPT throw()
-#  define CLARA_NOEXCEPT_IS(x)
-#endif
-
-// nullptr support
-#ifdef CLARA_CONFIG_CPP11_NULLPTR
-#define CLARA_NULL nullptr
-#else
-#define CLARA_NULL NULL
-#endif
-
-// override support
-#ifdef CLARA_CONFIG_CPP11_OVERRIDE
-#define CLARA_OVERRIDE override
-#else
-#define CLARA_OVERRIDE
-#endif
-
-// unique_ptr support
-#ifdef CLARA_CONFIG_CPP11_UNIQUE_PTR
-#   define CLARA_AUTO_PTR( T ) std::unique_ptr<T>
-#else
-#   define CLARA_AUTO_PTR( T ) std::auto_ptr<T>
-#endif
-
-#endif // TWOBLUECUBES_CLARA_COMPILERS_H_INCLUDED
-
-// ----------- end of #include from clara_compilers.h -----------
-// ........... back in clara.h
-
-#include <map>
-#include <stdexcept>
-#include <memory>
-
-#if defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER)
-#define CLARA_PLATFORM_WINDOWS
-#endif
-
-// Use optional outer namespace
-#ifdef STITCH_CLARA_OPEN_NAMESPACE
-STITCH_CLARA_OPEN_NAMESPACE
-#endif
-
-namespace Clara {
-
-    struct UnpositionalTag {};
-
-    extern UnpositionalTag _;
-
-#ifdef CLARA_CONFIG_MAIN
-    UnpositionalTag _;
-#endif
-
-    namespace Detail {
-
-#ifdef CLARA_CONSOLE_WIDTH
-    const unsigned int consoleWidth = CLARA_CONFIG_CONSOLE_WIDTH;
-#else
-    const unsigned int consoleWidth = 80;
-#endif
-
-        using namespace Tbc;
-
-        inline bool startsWith( std::string const& str, std::string const& prefix ) {
-            return str.size() >= prefix.size() && str.substr( 0, prefix.size() ) == prefix;
-        }
-
-        template<typename T> struct RemoveConstRef{ typedef T type; };
-        template<typename T> struct RemoveConstRef<T&>{ typedef T type; };
-        template<typename T> struct RemoveConstRef<T const&>{ typedef T type; };
-        template<typename T> struct RemoveConstRef<T const>{ typedef T type; };
-
-        template<typename T>    struct IsBool       { static const bool value = false; };
-        template<>              struct IsBool<bool> { static const bool value = true; };
-
-        template<typename T>
-        void convertInto( std::string const& _source, T& _dest ) {
-            std::stringstream ss;
-            ss << _source;
-            ss >> _dest;
-            if( ss.fail() )
-                throw std::runtime_error( "Unable to convert " + _source + " to destination type" );
-        }
-        inline void convertInto( std::string const& _source, std::string& _dest ) {
-            _dest = _source;
-        }
-        char toLowerCh(char c) {
-            return static_cast<char>( std::tolower( c ) );
-        }
-        inline void convertInto( std::string const& _source, bool& _dest ) {
-            std::string sourceLC = _source;
-            std::transform( sourceLC.begin(), sourceLC.end(), sourceLC.begin(), toLowerCh );
-            if( sourceLC == "y" || sourceLC == "1" || sourceLC == "true" || sourceLC == "yes" || sourceLC == "on" )
-                _dest = true;
-            else if( sourceLC == "n" || sourceLC == "0" || sourceLC == "false" || sourceLC == "no" || sourceLC == "off" )
-                _dest = false;
-            else
-                throw std::runtime_error( "Expected a boolean value but did not recognise:\n  '" + _source + "'" );
-        }
-
-        template<typename ConfigT>
-        struct IArgFunction {
-            virtual ~IArgFunction() {}
-#ifdef CLARA_CONFIG_CPP11_GENERATED_METHODS
-            IArgFunction()                      = default;
-            IArgFunction( IArgFunction const& ) = default;
-#endif
-            virtual void set( ConfigT& config, std::string const& value ) const = 0;
-            virtual bool takesArg() const = 0;
-            virtual IArgFunction* clone() const = 0;
-        };
-
-        template<typename ConfigT>
-        class BoundArgFunction {
-        public:
-            BoundArgFunction() : functionObj( CLARA_NULL ) {}
-            BoundArgFunction( IArgFunction<ConfigT>* _functionObj ) : functionObj( _functionObj ) {}
-            BoundArgFunction( BoundArgFunction const& other ) : functionObj( other.functionObj ? other.functionObj->clone() : CLARA_NULL ) {}
-            BoundArgFunction& operator = ( BoundArgFunction const& other ) {
-                IArgFunction<ConfigT>* newFunctionObj = other.functionObj ? other.functionObj->clone() : CLARA_NULL;
-                delete functionObj;
-                functionObj = newFunctionObj;
-                return *this;
-            }
-            ~BoundArgFunction() { delete functionObj; }
-
-            void set( ConfigT& config, std::string const& value ) const {
-                functionObj->set( config, value );
-            }
-            bool takesArg() const { return functionObj->takesArg(); }
-
-            bool isSet() const {
-                return functionObj != CLARA_NULL;
-            }
-        private:
-            IArgFunction<ConfigT>* functionObj;
-        };
-
-        template<typename C>
-        struct NullBinder : IArgFunction<C>{
-            virtual void set( C&, std::string const& ) const {}
-            virtual bool takesArg() const { return true; }
-            virtual IArgFunction<C>* clone() const { return new NullBinder( *this ); }
-        };
-
-        template<typename C, typename M>
-        struct BoundDataMember : IArgFunction<C>{
-            BoundDataMember( M C::* _member ) : member( _member ) {}
-            virtual void set( C& p, std::string const& stringValue ) const {
-                convertInto( stringValue, p.*member );
-            }
-            virtual bool takesArg() const { return !IsBool<M>::value; }
-            virtual IArgFunction<C>* clone() const { return new BoundDataMember( *this ); }
-            M C::* member;
-        };
-        template<typename C, typename M>
-        struct BoundUnaryMethod : IArgFunction<C>{
-            BoundUnaryMethod( void (C::*_member)( M ) ) : member( _member ) {}
-            virtual void set( C& p, std::string const& stringValue ) const {
-                typename RemoveConstRef<M>::type value;
-                convertInto( stringValue, value );
-                (p.*member)( value );
-            }
-            virtual bool takesArg() const { return !IsBool<M>::value; }
-            virtual IArgFunction<C>* clone() const { return new BoundUnaryMethod( *this ); }
-            void (C::*member)( M );
-        };
-        template<typename C>
-        struct BoundNullaryMethod : IArgFunction<C>{
-            BoundNullaryMethod( void (C::*_member)() ) : member( _member ) {}
-            virtual void set( C& p, std::string const& stringValue ) const {
-                bool value;
-                convertInto( stringValue, value );
-                if( value )
-                    (p.*member)();
-            }
-            virtual bool takesArg() const { return false; }
-            virtual IArgFunction<C>* clone() const { return new BoundNullaryMethod( *this ); }
-            void (C::*member)();
-        };
-
-        template<typename C>
-        struct BoundUnaryFunction : IArgFunction<C>{
-            BoundUnaryFunction( void (*_function)( C& ) ) : function( _function ) {}
-            virtual void set( C& obj, std::string const& stringValue ) const {
-                bool value;
-                convertInto( stringValue, value );
-                if( value )
-                    function( obj );
-            }
-            virtual bool takesArg() const { return false; }
-            virtual IArgFunction<C>* clone() const { return new BoundUnaryFunction( *this ); }
-            void (*function)( C& );
-        };
-
-        template<typename C, typename T>
-        struct BoundBinaryFunction : IArgFunction<C>{
-            BoundBinaryFunction( void (*_function)( C&, T ) ) : function( _function ) {}
-            virtual void set( C& obj, std::string const& stringValue ) const {
-                typename RemoveConstRef<T>::type value;
-                convertInto( stringValue, value );
-                function( obj, value );
-            }
-            virtual bool takesArg() const { return !IsBool<T>::value; }
-            virtual IArgFunction<C>* clone() const { return new BoundBinaryFunction( *this ); }
-            void (*function)( C&, T );
-        };
-
-    } // namespace Detail
-
-    inline std::vector<std::string> argsToVector( int argc, char const* const* const argv ) {
-        std::vector<std::string> args( static_cast<std::size_t>( argc ) );
-        for( std::size_t i = 0; i < static_cast<std::size_t>( argc ); ++i )
-            args[i] = argv[i];
-
-        return args;
-    }
-
-    class Parser {
-        enum Mode { None, MaybeShortOpt, SlashOpt, ShortOpt, LongOpt, Positional };
-        Mode mode;
-        std::size_t from;
-        bool inQuotes;
-    public:
-
-        struct Token {
-            enum Type { Positional, ShortOpt, LongOpt };
-            Token( Type _type, std::string const& _data ) : type( _type ), data( _data ) {}
-            Type type;
-            std::string data;
-        };
-
-        Parser() : mode( None ), from( 0 ), inQuotes( false ){}
-
-        void parseIntoTokens( std::vector<std::string> const& args, std::vector<Token>& tokens ) {
-            const std::string doubleDash = "--";
-            for( std::size_t i = 1; i < args.size() && args[i] != doubleDash; ++i )
-                parseIntoTokens( args[i], tokens);
-        }
-
-        void parseIntoTokens( std::string const& arg, std::vector<Token>& tokens ) {
-            for( std::size_t i = 0; i < arg.size(); ++i ) {
-                char c = arg[i];
-                if( c == '"' )
-                    inQuotes = !inQuotes;
-                mode = handleMode( i, c, arg, tokens );
-            }
-            mode = handleMode( arg.size(), '\0', arg, tokens );
-        }
-        Mode handleMode( std::size_t i, char c, std::string const& arg, std::vector<Token>& tokens ) {
-            switch( mode ) {
-                case None: return handleNone( i, c );
-                case MaybeShortOpt: return handleMaybeShortOpt( i, c );
-                case ShortOpt:
-                case LongOpt:
-                case SlashOpt: return handleOpt( i, c, arg, tokens );
-                case Positional: return handlePositional( i, c, arg, tokens );
-                default: throw std::logic_error( "Unknown mode" );
-            }
-        }
-
-        Mode handleNone( std::size_t i, char c ) {
-            if( inQuotes ) {
-                from = i;
-                return Positional;
-            }
-            switch( c ) {
-                case '-': return MaybeShortOpt;
-#ifdef CLARA_PLATFORM_WINDOWS
-                case '/': from = i+1; return SlashOpt;
-#endif
-                default: from = i; return Positional;
-            }
-        }
-        Mode handleMaybeShortOpt( std::size_t i, char c ) {
-            switch( c ) {
-                case '-': from = i+1; return LongOpt;
-                default: from = i; return ShortOpt;
-            }
-        }
-
-        Mode handleOpt( std::size_t i, char c, std::string const& arg, std::vector<Token>& tokens ) {
-            if( std::string( ":=\0", 3 ).find( c ) == std::string::npos )
-                return mode;
-
-            std::string optName = arg.substr( from, i-from );
-            if( mode == ShortOpt )
-                for( std::size_t j = 0; j < optName.size(); ++j )
-                    tokens.push_back( Token( Token::ShortOpt, optName.substr( j, 1 ) ) );
-            else if( mode == SlashOpt && optName.size() == 1 )
-                tokens.push_back( Token( Token::ShortOpt, optName ) );
-            else
-                tokens.push_back( Token( Token::LongOpt, optName ) );
-            return None;
-        }
-        Mode handlePositional( std::size_t i, char c, std::string const& arg, std::vector<Token>& tokens ) {
-            if( inQuotes || std::string( "\0", 1 ).find( c ) == std::string::npos )
-                return mode;
-
-            std::string data = arg.substr( from, i-from );
-            tokens.push_back( Token( Token::Positional, data ) );
-            return None;
-        }
-    };
-
-    template<typename ConfigT>
-    struct CommonArgProperties {
-        CommonArgProperties() {}
-        CommonArgProperties( Detail::BoundArgFunction<ConfigT> const& _boundField ) : boundField( _boundField ) {}
-
-        Detail::BoundArgFunction<ConfigT> boundField;
-        std::string description;
-        std::string detail;
-        std::string placeholder; // Only value if boundField takes an arg
-
-        bool takesArg() const {
-            return !placeholder.empty();
-        }
-        void validate() const {
-            if( !boundField.isSet() )
-                throw std::logic_error( "option not bound" );
-        }
-    };
-    struct OptionArgProperties {
-        std::vector<std::string> shortNames;
-        std::string longName;
-
-        bool hasShortName( std::string const& shortName ) const {
-            return std::find( shortNames.begin(), shortNames.end(), shortName ) != shortNames.end();
-        }
-        bool hasLongName( std::string const& _longName ) const {
-            return _longName == longName;
-        }
-    };
-    struct PositionalArgProperties {
-        PositionalArgProperties() : position( -1 ) {}
-        int position; // -1 means non-positional (floating)
-
-        bool isFixedPositional() const {
-            return position != -1;
-        }
-    };
-
-    template<typename ConfigT>
-    class CommandLine {
-
-        struct Arg : CommonArgProperties<ConfigT>, OptionArgProperties, PositionalArgProperties {
-            Arg() {}
-            Arg( Detail::BoundArgFunction<ConfigT> const& _boundField ) : CommonArgProperties<ConfigT>( _boundField ) {}
-
-            using CommonArgProperties<ConfigT>::placeholder; // !TBD
-
-            std::string dbgName() const {
-                if( !longName.empty() )
-                    return "--" + longName;
-                if( !shortNames.empty() )
-                    return "-" + shortNames[0];
-                return "positional args";
-            }
-            std::string commands() const {
-                std::ostringstream oss;
-                bool first = true;
-                std::vector<std::string>::const_iterator it = shortNames.begin(), itEnd = shortNames.end();
-                for(; it != itEnd; ++it ) {
-                    if( first )
-                        first = false;
-                    else
-                        oss << ", ";
-                    oss << "-" << *it;
-                }
-                if( !longName.empty() ) {
-                    if( !first )
-                        oss << ", ";
-                    oss << "--" << longName;
-                }
-                if( !placeholder.empty() )
-                    oss << " <" << placeholder << ">";
-                return oss.str();
-            }
-        };
-
-        typedef CLARA_AUTO_PTR( Arg ) ArgAutoPtr;
-
-        friend void addOptName( Arg& arg, std::string const& optName )
-        {
-            if( optName.empty() )
-                return;
-            if( Detail::startsWith( optName, "--" ) ) {
-                if( !arg.longName.empty() )
-                    throw std::logic_error( "Only one long opt may be specified. '"
-                        + arg.longName
-                        + "' already specified, now attempting to add '"
-                        + optName + "'" );
-                arg.longName = optName.substr( 2 );
-            }
-            else if( Detail::startsWith( optName, "-" ) )
-                arg.shortNames.push_back( optName.substr( 1 ) );
-            else
-                throw std::logic_error( "option must begin with - or --. Option was: '" + optName + "'" );
-        }
-        friend void setPositionalArg( Arg& arg, int position )
-        {
-            arg.position = position;
-        }
-
-        class ArgBuilder {
-        public:
-            ArgBuilder( Arg* arg ) : m_arg( arg ) {}
-
-            // Bind a non-boolean data member (requires placeholder string)
-            template<typename C, typename M>
-            void bind( M C::* field, std::string const& placeholder ) {
-                m_arg->boundField = new Detail::BoundDataMember<C,M>( field );
-                m_arg->placeholder = placeholder;
-            }
-            // Bind a boolean data member (no placeholder required)
-            template<typename C>
-            void bind( bool C::* field ) {
-                m_arg->boundField = new Detail::BoundDataMember<C,bool>( field );
-            }
-
-            // Bind a method taking a single, non-boolean argument (requires a placeholder string)
-            template<typename C, typename M>
-            void bind( void (C::* unaryMethod)( M ), std::string const& placeholder ) {
-                m_arg->boundField = new Detail::BoundUnaryMethod<C,M>( unaryMethod );
-                m_arg->placeholder = placeholder;
-            }
-
-            // Bind a method taking a single, boolean argument (no placeholder string required)
-            template<typename C>
-            void bind( void (C::* unaryMethod)( bool ) ) {
-                m_arg->boundField = new Detail::BoundUnaryMethod<C,bool>( unaryMethod );
-            }
-
-            // Bind a method that takes no arguments (will be called if opt is present)
-            template<typename C>
-            void bind( void (C::* nullaryMethod)() ) {
-                m_arg->boundField = new Detail::BoundNullaryMethod<C>( nullaryMethod );
-            }
-
-            // Bind a free function taking a single argument - the object to operate on (no placeholder string required)
-            template<typename C>
-            void bind( void (* unaryFunction)( C& ) ) {
-                m_arg->boundField = new Detail::BoundUnaryFunction<C>( unaryFunction );
-            }
-
-            // Bind a free function taking a single argument - the object to operate on (requires a placeholder string)
-            template<typename C, typename T>
-            void bind( void (* binaryFunction)( C&, T ), std::string const& placeholder ) {
-                m_arg->boundField = new Detail::BoundBinaryFunction<C, T>( binaryFunction );
-                m_arg->placeholder = placeholder;
-            }
-
-            ArgBuilder& describe( std::string const& description ) {
-                m_arg->description = description;
-                return *this;
-            }
-            ArgBuilder& detail( std::string const& detail ) {
-                m_arg->detail = detail;
-                return *this;
-            }
-
-        protected:
-            Arg* m_arg;
-        };
-
-        class OptBuilder : public ArgBuilder {
-        public:
-            OptBuilder( Arg* arg ) : ArgBuilder( arg ) {}
-            OptBuilder( OptBuilder& other ) : ArgBuilder( other ) {}
-
-            OptBuilder& operator[]( std::string const& optName ) {
-                addOptName( *ArgBuilder::m_arg, optName );
-                return *this;
-            }
-        };
-
-    public:
-
-        CommandLine()
-        :   m_boundProcessName( new Detail::NullBinder<ConfigT>() ),
-            m_highestSpecifiedArgPosition( 0 ),
-            m_throwOnUnrecognisedTokens( false )
-        {}
-        CommandLine( CommandLine const& other )
-        :   m_boundProcessName( other.m_boundProcessName ),
-            m_options ( other.m_options ),
-            m_positionalArgs( other.m_positionalArgs ),
-            m_highestSpecifiedArgPosition( other.m_highestSpecifiedArgPosition ),
-            m_throwOnUnrecognisedTokens( other.m_throwOnUnrecognisedTokens )
-        {
-            if( other.m_floatingArg.get() )
-                m_floatingArg.reset( new Arg( *other.m_floatingArg ) );
-        }
-
-        CommandLine& setThrowOnUnrecognisedTokens( bool shouldThrow = true ) {
-            m_throwOnUnrecognisedTokens = shouldThrow;
-            return *this;
-        }
-
-        OptBuilder operator[]( std::string const& optName ) {
-            m_options.push_back( Arg() );
-            addOptName( m_options.back(), optName );
-            OptBuilder builder( &m_options.back() );
-            return builder;
-        }
-
-        ArgBuilder operator[]( int position ) {
-            m_positionalArgs.insert( std::make_pair( position, Arg() ) );
-            if( position > m_highestSpecifiedArgPosition )
-                m_highestSpecifiedArgPosition = position;
-            setPositionalArg( m_positionalArgs[position], position );
-            ArgBuilder builder( &m_positionalArgs[position] );
-            return builder;
-        }
-
-        // Invoke this with the _ instance
-        ArgBuilder operator[]( UnpositionalTag ) {
-            if( m_floatingArg.get() )
-                throw std::logic_error( "Only one unpositional argument can be added" );
-            m_floatingArg.reset( new Arg() );
-            ArgBuilder builder( m_floatingArg.get() );
-            return builder;
-        }
-
-        template<typename C, typename M>
-        void bindProcessName( M C::* field ) {
-            m_boundProcessName = new Detail::BoundDataMember<C,M>( field );
-        }
-        template<typename C, typename M>
-        void bindProcessName( void (C::*_unaryMethod)( M ) ) {
-            m_boundProcessName = new Detail::BoundUnaryMethod<C,M>( _unaryMethod );
-        }
-
-        void optUsage( std::ostream& os, std::size_t indent = 0, std::size_t width = Detail::consoleWidth ) const {
-            typename std::vector<Arg>::const_iterator itBegin = m_options.begin(), itEnd = m_options.end(), it;
-            std::size_t maxWidth = 0;
-            for( it = itBegin; it != itEnd; ++it )
-                maxWidth = (std::max)( maxWidth, it->commands().size() );
-
-            for( it = itBegin; it != itEnd; ++it ) {
-                Detail::Text usage( it->commands(), Detail::TextAttributes()
-                                                        .setWidth( maxWidth+indent )
-                                                        .setIndent( indent ) );
-                Detail::Text desc( it->description, Detail::TextAttributes()
-                                                        .setWidth( width - maxWidth - 3 ) );
-
-                for( std::size_t i = 0; i < (std::max)( usage.size(), desc.size() ); ++i ) {
-                    std::string usageCol = i < usage.size() ? usage[i] : "";
-                    os << usageCol;
-
-                    if( i < desc.size() && !desc[i].empty() )
-                        os  << std::string( indent + 2 + maxWidth - usageCol.size(), ' ' )
-                            << desc[i];
-                    os << "\n";
-                }
-            }
-        }
-        std::string optUsage() const {
-            std::ostringstream oss;
-            optUsage( oss );
-            return oss.str();
-        }
-
-        void argSynopsis( std::ostream& os ) const {
-            for( int i = 1; i <= m_highestSpecifiedArgPosition; ++i ) {
-                if( i > 1 )
-                    os << " ";
-                typename std::map<int, Arg>::const_iterator it = m_positionalArgs.find( i );
-                if( it != m_positionalArgs.end() )
-                    os << "<" << it->second.placeholder << ">";
-                else if( m_floatingArg.get() )
-                    os << "<" << m_floatingArg->placeholder << ">";
-                else
-                    throw std::logic_error( "non consecutive positional arguments with no floating args" );
-            }
-            // !TBD No indication of mandatory args
-            if( m_floatingArg.get() ) {
-                if( m_highestSpecifiedArgPosition > 1 )
-                    os << " ";
-                os << "[<" << m_floatingArg->placeholder << "> ...]";
-            }
-        }
-        std::string argSynopsis() const {
-            std::ostringstream oss;
-            argSynopsis( oss );
-            return oss.str();
-        }
-
-        void usage( std::ostream& os, std::string const& procName ) const {
-            validate();
-            os << "usage:\n  " << procName << " ";
-            argSynopsis( os );
-            if( !m_options.empty() ) {
-                os << " [options]\n\nwhere options are: \n";
-                optUsage( os, 2 );
-            }
-            os << "\n";
-        }
-        std::string usage( std::string const& procName ) const {
-            std::ostringstream oss;
-            usage( oss, procName );
-            return oss.str();
-        }
-
-        ConfigT parse( std::vector<std::string> const& args ) const {
-            ConfigT config;
-            parseInto( args, config );
-            return config;
-        }
-
-        std::vector<Parser::Token> parseInto( std::vector<std::string> const& args, ConfigT& config ) const {
-            std::string processName = args.empty() ? std::string() : args[0];
-            std::size_t lastSlash = processName.find_last_of( "/\\" );
-            if( lastSlash != std::string::npos )
-                processName = processName.substr( lastSlash+1 );
-            m_boundProcessName.set( config, processName );
-            std::vector<Parser::Token> tokens;
-            Parser parser;
-            parser.parseIntoTokens( args, tokens );
-            return populate( tokens, config );
-        }
-
-        std::vector<Parser::Token> populate( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
-            validate();
-            std::vector<Parser::Token> unusedTokens = populateOptions( tokens, config );
-            unusedTokens = populateFixedArgs( unusedTokens, config );
-            unusedTokens = populateFloatingArgs( unusedTokens, config );
-            return unusedTokens;
-        }
-
-        std::vector<Parser::Token> populateOptions( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
-            std::vector<Parser::Token> unusedTokens;
-            std::vector<std::string> errors;
-            for( std::size_t i = 0; i < tokens.size(); ++i ) {
-                Parser::Token const& token = tokens[i];
-                typename std::vector<Arg>::const_iterator it = m_options.begin(), itEnd = m_options.end();
-                for(; it != itEnd; ++it ) {
-                    Arg const& arg = *it;
-
-                    try {
-                        if( ( token.type == Parser::Token::ShortOpt && arg.hasShortName( token.data ) ) ||
-                            ( token.type == Parser::Token::LongOpt && arg.hasLongName( token.data ) ) ) {
-                            if( arg.takesArg() ) {
-                                if( i == tokens.size()-1 || tokens[i+1].type != Parser::Token::Positional )
-                                    errors.push_back( "Expected argument to option: " + token.data );
-                                else
-                                    arg.boundField.set( config, tokens[++i].data );
-                            }
-                            else {
-                                arg.boundField.set( config, "true" );
-                            }
-                            break;
-                        }
-                    }
-                    catch( std::exception& ex ) {
-                        errors.push_back( std::string( ex.what() ) + "\n- while parsing: (" + arg.commands() + ")" );
-                    }
-                }
-                if( it == itEnd ) {
-                    if( token.type == Parser::Token::Positional || !m_throwOnUnrecognisedTokens )
-                        unusedTokens.push_back( token );
-                    else if( errors.empty() && m_throwOnUnrecognisedTokens )
-                        errors.push_back( "unrecognised option: " + token.data );
-                }
-            }
-            if( !errors.empty() ) {
-                std::ostringstream oss;
-                for( std::vector<std::string>::const_iterator it = errors.begin(), itEnd = errors.end();
-                        it != itEnd;
-                        ++it ) {
-                    if( it != errors.begin() )
-                        oss << "\n";
-                    oss << *it;
-                }
-                throw std::runtime_error( oss.str() );
-            }
-            return unusedTokens;
-        }
-        std::vector<Parser::Token> populateFixedArgs( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
-            std::vector<Parser::Token> unusedTokens;
-            int position = 1;
-            for( std::size_t i = 0; i < tokens.size(); ++i ) {
-                Parser::Token const& token = tokens[i];
-                typename std::map<int, Arg>::const_iterator it = m_positionalArgs.find( position );
-                if( it != m_positionalArgs.end() )
-                    it->second.boundField.set( config, token.data );
-                else
-                    unusedTokens.push_back( token );
-                if( token.type == Parser::Token::Positional )
-                    position++;
-            }
-            return unusedTokens;
-        }
-        std::vector<Parser::Token> populateFloatingArgs( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
-            if( !m_floatingArg.get() )
-                return tokens;
-            std::vector<Parser::Token> unusedTokens;
-            for( std::size_t i = 0; i < tokens.size(); ++i ) {
-                Parser::Token const& token = tokens[i];
-                if( token.type == Parser::Token::Positional )
-                    m_floatingArg->boundField.set( config, token.data );
-                else
-                    unusedTokens.push_back( token );
-            }
-            return unusedTokens;
-        }
-
-        void validate() const
-        {
-            if( m_options.empty() && m_positionalArgs.empty() && !m_floatingArg.get() )
-                throw std::logic_error( "No options or arguments specified" );
-
-            for( typename std::vector<Arg>::const_iterator  it = m_options.begin(),
-                                                            itEnd = m_options.end();
-                    it != itEnd; ++it )
-                it->validate();
-        }
-
-    private:
-        Detail::BoundArgFunction<ConfigT> m_boundProcessName;
-        std::vector<Arg> m_options;
-        std::map<int, Arg> m_positionalArgs;
-        ArgAutoPtr m_floatingArg;
-        int m_highestSpecifiedArgPosition;
-        bool m_throwOnUnrecognisedTokens;
-    };
-
-} // end namespace Clara
-
-STITCH_CLARA_CLOSE_NAMESPACE
-#undef STITCH_CLARA_OPEN_NAMESPACE
-#undef STITCH_CLARA_CLOSE_NAMESPACE
-
-#endif // TWOBLUECUBES_CLARA_H_INCLUDED
-#undef STITCH_CLARA_OPEN_NAMESPACE
-
-// Restore Clara's value for console width, if present
-#ifdef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
-#define CLARA_CONFIG_CONSOLE_WIDTH CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
-#undef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
-#endif
-
-#include <fstream>
-#include <ctime>
-
-namespace Catch {
-
-    inline void abortAfterFirst( ConfigData& config ) { config.abortAfter = 1; }
-    inline void abortAfterX( ConfigData& config, int x ) {
-        if( x < 1 )
-            throw std::runtime_error( "Value after -x or --abortAfter must be greater than zero" );
-        config.abortAfter = x;
-    }
-    inline void addTestOrTags( ConfigData& config, std::string const& _testSpec ) { config.testsOrTags.push_back( _testSpec ); }
-    inline void addSectionToRun( ConfigData& config, std::string const& sectionName ) { config.sectionsToRun.push_back( sectionName ); }
-    inline void addReporterName( ConfigData& config, std::string const& _reporterName ) { config.reporterNames.push_back( _reporterName ); }
-
-    inline void addWarning( ConfigData& config, std::string const& _warning ) {
-        if( _warning == "NoAssertions" )
-            config.warnings = static_cast<WarnAbout::What>( config.warnings | WarnAbout::NoAssertions );
-        else
-            throw std::runtime_error( "Unrecognised warning: '" + _warning + '\'' );
-    }
-    inline void setOrder( ConfigData& config, 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
-            throw std::runtime_error( "Unrecognised ordering: '" + order + '\'' );
-    }
-    inline void setRngSeed( ConfigData& config, std::string const& seed ) {
-        if( seed == "time" ) {
-            config.rngSeed = static_cast<unsigned int>( std::time(0) );
-        }
-        else {
-            std::stringstream ss;
-            ss << seed;
-            ss >> config.rngSeed;
-            if( ss.fail() )
-                throw std::runtime_error( "Argument to --rng-seed should be the word 'time' or a number" );
-        }
-    }
-    inline void setVerbosity( ConfigData& config, int level ) {
-        // !TBD: accept strings?
-        config.verbosity = static_cast<Verbosity::Level>( level );
-    }
-    inline void setShowDurations( ConfigData& config, bool _showDurations ) {
-        config.showDurations = _showDurations
-            ? ShowDurations::Always
-            : ShowDurations::Never;
-    }
-    inline void setUseColour( ConfigData& config, std::string const& value ) {
-        std::string mode = toLower( value );
-
-        if( mode == "yes" )
-            config.useColour = UseColour::Yes;
-        else if( mode == "no" )
-            config.useColour = UseColour::No;
-        else if( mode == "auto" )
-            config.useColour = UseColour::Auto;
-        else
-            throw std::runtime_error( "colour mode must be one of: auto, yes or no" );
-    }
-    inline void setWaitForKeypress( ConfigData& config, std::string const& keypress ) {
-        std::string 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
-            throw std::runtime_error( "keypress argument must be one of: start, exit or both. '" + keypress + "' not recognised" );
-    };
-
-    inline void forceColour( ConfigData& config ) {
-        config.useColour = UseColour::Yes;
-    }
-    inline void loadTestNamesFromFile( ConfigData& config, std::string const& _filename ) {
-        std::ifstream f( _filename.c_str() );
-        if( !f.is_open() )
-            throw std::domain_error( "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 + '"';
-                addTestOrTags( config, line + ',' );
-            }
-        }
-    }
-
-    inline Clara::CommandLine<ConfigData> makeCommandLineParser() {
-
-        using namespace Clara;
-        CommandLine<ConfigData> cli;
-
-        cli.bindProcessName( &ConfigData::processName );
-
-        cli["-?"]["-h"]["--help"]
-            .describe( "display usage information" )
-            .bind( &ConfigData::showHelp );
-
-        cli["-l"]["--list-tests"]
-            .describe( "list all/matching test cases" )
-            .bind( &ConfigData::listTests );
-
-        cli["-t"]["--list-tags"]
-            .describe( "list all/matching tags" )
-            .bind( &ConfigData::listTags );
-
-        cli["-s"]["--success"]
-            .describe( "include successful tests in output" )
-            .bind( &ConfigData::showSuccessfulTests );
-
-        cli["-b"]["--break"]
-            .describe( "break into debugger on failure" )
-            .bind( &ConfigData::shouldDebugBreak );
-
-        cli["-e"]["--nothrow"]
-            .describe( "skip exception tests" )
-            .bind( &ConfigData::noThrow );
-
-        cli["-i"]["--invisibles"]
-            .describe( "show invisibles (tabs, newlines)" )
-            .bind( &ConfigData::showInvisibles );
-
-        cli["-o"]["--out"]
-            .describe( "output filename" )
-            .bind( &ConfigData::outputFilename, "filename" );
-
-        cli["-r"]["--reporter"]
-//            .placeholder( "name[:filename]" )
-            .describe( "reporter to use (defaults to console)" )
-            .bind( &addReporterName, "name" );
-
-        cli["-n"]["--name"]
-            .describe( "suite name" )
-            .bind( &ConfigData::name, "name" );
-
-        cli["-a"]["--abort"]
-            .describe( "abort at first failure" )
-            .bind( &abortAfterFirst );
-
-        cli["-x"]["--abortx"]
-            .describe( "abort after x failures" )
-            .bind( &abortAfterX, "no. failures" );
-
-        cli["-w"]["--warn"]
-            .describe( "enable warnings" )
-            .bind( &addWarning, "warning name" );
-
-// - needs updating if reinstated
-//        cli.into( &setVerbosity )
-//            .describe( "level of verbosity (0=no output)" )
-//            .shortOpt( "v")
-//            .longOpt( "verbosity" )
-//            .placeholder( "level" );
-
-        cli[_]
-            .describe( "which test or tests to use" )
-            .bind( &addTestOrTags, "test name, pattern or tags" );
-
-        cli["-d"]["--durations"]
-            .describe( "show test durations" )
-            .bind( &setShowDurations, "yes|no" );
-
-        cli["-f"]["--input-file"]
-            .describe( "load test names to run from a file" )
-            .bind( &loadTestNamesFromFile, "filename" );
-
-        cli["-#"]["--filenames-as-tags"]
-            .describe( "adds a tag for the filename" )
-            .bind( &ConfigData::filenamesAsTags );
-
-        cli["-c"]["--section"]
-                .describe( "specify section to run" )
-                .bind( &addSectionToRun, "section name" );
-
-        // Less common commands which don't have a short form
-        cli["--list-test-names-only"]
-            .describe( "list all/matching test cases names only" )
-            .bind( &ConfigData::listTestNamesOnly );
-
-        cli["--list-extra-info"]
-            .describe( "list all/matching test cases with more info" )
-            .bind( &ConfigData::listExtraInfo );
-
-        cli["--list-reporters"]
-            .describe( "list all reporters" )
-            .bind( &ConfigData::listReporters );
-
-        cli["--order"]
-            .describe( "test case order (defaults to decl)" )
-            .bind( &setOrder, "decl|lex|rand" );
-
-        cli["--rng-seed"]
-            .describe( "set a specific seed for random numbers" )
-            .bind( &setRngSeed, "'time'|number" );
-
-        cli["--force-colour"]
-            .describe( "force colourised output (deprecated)" )
-            .bind( &forceColour );
-
-        cli["--use-colour"]
-            .describe( "should output be colourised" )
-            .bind( &setUseColour, "yes|no" );
-
-        cli["--libidentify"]
-            .describe( "report name and version according to libidentify standard" )
-            .bind( &ConfigData::libIdentify );
-
-        cli["--wait-for-keypress"]
-                .describe( "waits for a keypress before exiting" )
-                .bind( &setWaitForKeypress, "start|exit|both" );
-
-        return cli;
-    }
-
-} // end namespace Catch
-
-// #included from: internal/catch_list.hpp
-#define TWOBLUECUBES_CATCH_LIST_HPP_INCLUDED
-
-// #included from: catch_text.h
-#define TWOBLUECUBES_CATCH_TEXT_H_INCLUDED
-
-#define TBC_TEXT_FORMAT_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH
-
-#define CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE Catch
-// #included from: ../external/tbc_text_format.h
-// Only use header guard if we are not using an outer namespace
-#ifndef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
-# ifdef TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED
-#  ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
-#   define TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
-#  endif
-# else
-#  define TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED
-# endif
-#endif
-#ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
-#include <string>
-#include <vector>
-#include <sstream>
-
-// Use optional outer namespace
-#ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
-namespace CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE {
-#endif
-
-namespace Tbc {
-
-#ifdef TBC_TEXT_FORMAT_CONSOLE_WIDTH
-    const unsigned int consoleWidth = TBC_TEXT_FORMAT_CONSOLE_WIDTH;
-#else
-    const unsigned int consoleWidth = 80;
-#endif
-
-    struct TextAttributes {
-        TextAttributes()
-        :   initialIndent( std::string::npos ),
-            indent( 0 ),
-            width( consoleWidth-1 )
-        {}
-
-        TextAttributes& setInitialIndent( std::size_t _value )  { initialIndent = _value; return *this; }
-        TextAttributes& setIndent( std::size_t _value )         { indent = _value; return *this; }
-        TextAttributes& setWidth( std::size_t _value )          { width = _value; return *this; }
-
-        std::size_t initialIndent;  // indent of first line, or npos
-        std::size_t indent;         // indent of subsequent lines, or all if initialIndent is npos
-        std::size_t width;          // maximum width of text, including indent. Longer text will wrap
-    };
-
-    class Text {
-    public:
-        Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() )
-        : attr( _attr )
-        {
-            const std::string wrappableBeforeChars = "[({<\t";
-            const std::string wrappableAfterChars = "])}>-,./|\\";
-            const std::string wrappableInsteadOfChars = " \n\r";
-            std::string indent = _attr.initialIndent != std::string::npos
-                ? std::string( _attr.initialIndent, ' ' )
-                : std::string( _attr.indent, ' ' );
-
-            typedef std::string::const_iterator iterator;
-            iterator it = _str.begin();
-            const iterator strEnd = _str.end();
-
-            while( it != strEnd ) {
-
-                if( lines.size() >= 1000 ) {
-                    lines.push_back( "... message truncated due to excessive size" );
-                    return;
-                }
-
-                std::string suffix;
-                std::size_t width = (std::min)( static_cast<size_t>( strEnd-it ), _attr.width-static_cast<size_t>( indent.size() ) );
-                iterator itEnd = it+width;
-                iterator itNext = _str.end();
-
-                iterator itNewLine = std::find( it, itEnd, '\n' );
-                if( itNewLine != itEnd )
-                    itEnd = itNewLine;
-
-                if( itEnd != strEnd  ) {
-                    bool foundWrapPoint = false;
-                    iterator findIt = itEnd;
-                    do {
-                        if( wrappableAfterChars.find( *findIt ) != std::string::npos && findIt != itEnd ) {
-                            itEnd = findIt+1;
-                            itNext = findIt+1;
-                            foundWrapPoint = true;
-                        }
-                        else if( findIt > it && wrappableBeforeChars.find( *findIt ) != std::string::npos ) {
-                            itEnd = findIt;
-                            itNext = findIt;
-                            foundWrapPoint = true;
-                        }
-                        else if( wrappableInsteadOfChars.find( *findIt ) != std::string::npos ) {
-                            itNext = findIt+1;
-                            itEnd = findIt;
-                            foundWrapPoint = true;
-                        }
-                        if( findIt == it )
-                            break;
-                        else
-                            --findIt;
-                    }
-                    while( !foundWrapPoint );
-
-                    if( !foundWrapPoint ) {
-                        // No good wrap char, so we'll break mid word and add a hyphen
-                        --itEnd;
-                        itNext = itEnd;
-                        suffix = "-";
-                    }
-                    else {
-                        while( itEnd > it && wrappableInsteadOfChars.find( *(itEnd-1) ) != std::string::npos )
-                            --itEnd;
-                    }
-                }
-                lines.push_back( indent + std::string( it, itEnd ) + suffix );
-
-                if( indent.size() != _attr.indent )
-                    indent = std::string( _attr.indent, ' ' );
-                it = itNext;
-            }
-        }
-
-        typedef std::vector<std::string>::const_iterator const_iterator;
-
-        const_iterator begin() const { return lines.begin(); }
-        const_iterator end() const { return lines.end(); }
-        std::string const& last() const { return lines.back(); }
-        std::size_t size() const { return lines.size(); }
-        std::string const& operator[]( std::size_t _index ) const { return lines[_index]; }
-        std::string toString() const {
-            std::ostringstream oss;
-            oss << *this;
-            return oss.str();
-        }
-
-        inline friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) {
-            for( Text::const_iterator it = _text.begin(), itEnd = _text.end();
-                it != itEnd; ++it ) {
-                if( it != _text.begin() )
-                    _stream << "\n";
-                _stream << *it;
-            }
-            return _stream;
-        }
-
-    private:
-        std::string str;
-        TextAttributes attr;
-        std::vector<std::string> lines;
-    };
-
-} // end namespace Tbc
-
-#ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
-} // end outer namespace
-#endif
-
-#endif // TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
-#undef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
-
-namespace Catch {
-    using Tbc::Text;
-    using Tbc::TextAttributes;
-}
-
-// #included from: catch_console_colour.hpp
-#define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_HPP_INCLUDED
-
-namespace Catch {
-
-    struct Colour {
-        enum Code {
-            None = 0,
-
-            White,
-            Red,
-            Green,
-            Blue,
-            Cyan,
-            Yellow,
-            Grey,
-
-            Bright = 0x10,
-
-            BrightRed = Bright | Red,
-            BrightGreen = Bright | Green,
-            LightGrey = Bright | Grey,
-            BrightWhite = Bright | White,
-
-            // By intention
-            FileName = LightGrey,
-            Warning = Yellow,
-            ResultError = BrightRed,
-            ResultSuccess = BrightGreen,
-            ResultExpectedFailure = Warning,
-
-            Error = BrightRed,
-            Success = Green,
-
-            OriginalExpression = Cyan,
-            ReconstructedExpression = Yellow,
-
-            SecondaryText = LightGrey,
-            Headers = White
-        };
-
-        // Use constructed object for RAII guard
-        Colour( Code _colourCode );
-        Colour( Colour const& other );
-        ~Colour();
-
-        // Use static method for one-shot changes
-        static void use( Code _colourCode );
-
-    private:
-        bool m_moved;
-    };
-
-    inline std::ostream& operator << ( std::ostream& os, Colour const& ) { return os; }
-
-} // end namespace Catch
-
-// #included from: catch_interfaces_reporter.h
-#define TWOBLUECUBES_CATCH_INTERFACES_REPORTER_H_INCLUDED
-
-#include <string>
-#include <ostream>
-#include <map>
-
-namespace Catch
-{
-    struct ReporterConfig {
-        explicit ReporterConfig( Ptr<IConfig const> const& _fullConfig )
-        :   m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {}
-
-        ReporterConfig( Ptr<IConfig const> const& _fullConfig, std::ostream& _stream )
-        :   m_stream( &_stream ), m_fullConfig( _fullConfig ) {}
-
-        std::ostream& stream() const    { return *m_stream; }
-        Ptr<IConfig const> fullConfig() const { return m_fullConfig; }
-
-    private:
-        std::ostream* m_stream;
-        Ptr<IConfig const> m_fullConfig;
-    };
-
-    struct ReporterPreferences {
-        ReporterPreferences()
-        : shouldRedirectStdOut( false )
-        {}
-
-        bool shouldRedirectStdOut;
-    };
-
-    template<typename T>
-    struct LazyStat : Option<T> {
-        LazyStat() : used( false ) {}
-        LazyStat& operator=( T const& _value ) {
-            Option<T>::operator=( _value );
-            used = false;
-            return *this;
-        }
-        void reset() {
-            Option<T>::reset();
-            used = false;
-        }
-        bool used;
-    };
-
-    struct TestRunInfo {
-        TestRunInfo( std::string const& _name ) : name( _name ) {}
-        std::string name;
-    };
-    struct GroupInfo {
-        GroupInfo(  std::string const& _name,
-                    std::size_t _groupIndex,
-                    std::size_t _groupsCount )
-        :   name( _name ),
-            groupIndex( _groupIndex ),
-            groupsCounts( _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 )
-        :   assertionResult( _assertionResult ),
-            infoMessages( _infoMessages ),
-            totals( _totals )
-        {
-            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 );
-            }
-        }
-        virtual ~AssertionStats();
-
-#  ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
-        AssertionStats( AssertionStats const& )              = default;
-        AssertionStats( AssertionStats && )                  = default;
-        AssertionStats& operator = ( AssertionStats const& ) = default;
-        AssertionStats& operator = ( AssertionStats && )     = default;
-#  endif
-
-        AssertionResult assertionResult;
-        std::vector<MessageInfo> infoMessages;
-        Totals totals;
-    };
-
-    struct SectionStats {
-        SectionStats(   SectionInfo const& _sectionInfo,
-                        Counts const& _assertions,
-                        double _durationInSeconds,
-                        bool _missingAssertions )
-        :   sectionInfo( _sectionInfo ),
-            assertions( _assertions ),
-            durationInSeconds( _durationInSeconds ),
-            missingAssertions( _missingAssertions )
-        {}
-        virtual ~SectionStats();
-#  ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
-        SectionStats( SectionStats const& )              = default;
-        SectionStats( SectionStats && )                  = default;
-        SectionStats& operator = ( SectionStats const& ) = default;
-        SectionStats& operator = ( SectionStats && )     = default;
-#  endif
-
-        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 )
-        : testInfo( _testInfo ),
-            totals( _totals ),
-            stdOut( _stdOut ),
-            stdErr( _stdErr ),
-            aborting( _aborting )
-        {}
-        virtual ~TestCaseStats();
-
-#  ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
-        TestCaseStats( TestCaseStats const& )              = default;
-        TestCaseStats( TestCaseStats && )                  = default;
-        TestCaseStats& operator = ( TestCaseStats const& ) = default;
-        TestCaseStats& operator = ( TestCaseStats && )     = default;
-#  endif
-
-        TestCaseInfo testInfo;
-        Totals totals;
-        std::string stdOut;
-        std::string stdErr;
-        bool aborting;
-    };
-
-    struct TestGroupStats {
-        TestGroupStats( GroupInfo const& _groupInfo,
-                        Totals const& _totals,
-                        bool _aborting )
-        :   groupInfo( _groupInfo ),
-            totals( _totals ),
-            aborting( _aborting )
-        {}
-        TestGroupStats( GroupInfo const& _groupInfo )
-        :   groupInfo( _groupInfo ),
-            aborting( false )
-        {}
-        virtual ~TestGroupStats();
-
-#  ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
-        TestGroupStats( TestGroupStats const& )              = default;
-        TestGroupStats( TestGroupStats && )                  = default;
-        TestGroupStats& operator = ( TestGroupStats const& ) = default;
-        TestGroupStats& operator = ( TestGroupStats && )     = default;
-#  endif
-
-        GroupInfo groupInfo;
-        Totals totals;
-        bool aborting;
-    };
-
-    struct TestRunStats {
-        TestRunStats(   TestRunInfo const& _runInfo,
-                        Totals const& _totals,
-                        bool _aborting )
-        :   runInfo( _runInfo ),
-            totals( _totals ),
-            aborting( _aborting )
-        {}
-        virtual ~TestRunStats();
-
-#  ifndef CATCH_CONFIG_CPP11_GENERATED_METHODS
-        TestRunStats( TestRunStats const& _other )
-        :   runInfo( _other.runInfo ),
-            totals( _other.totals ),
-            aborting( _other.aborting )
-        {}
-#  else
-        TestRunStats( TestRunStats const& )              = default;
-        TestRunStats( TestRunStats && )                  = default;
-        TestRunStats& operator = ( TestRunStats const& ) = default;
-        TestRunStats& operator = ( TestRunStats && )     = default;
-#  endif
-
-        TestRunInfo runInfo;
-        Totals totals;
-        bool aborting;
-    };
-
-    class MultipleReporters;
-
-    struct IStreamingReporter : IShared {
-        virtual ~IStreamingReporter();
-
-        // Implementing class must also provide the following static method:
-        // static std::string getDescription();
-
-        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;
-
-        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;
-
-        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;
-
-        virtual MultipleReporters* tryAsMulti() { return CATCH_NULL; }
-    };
-
-    struct IReporterFactory : IShared {
-        virtual ~IReporterFactory();
-        virtual IStreamingReporter* create( ReporterConfig const& config ) const = 0;
-        virtual std::string getDescription() const = 0;
-    };
-
-    struct IReporterRegistry {
-        typedef std::map<std::string, Ptr<IReporterFactory> > FactoryMap;
-        typedef std::vector<Ptr<IReporterFactory> > Listeners;
-
-        virtual ~IReporterRegistry();
-        virtual IStreamingReporter* create( std::string const& name, Ptr<IConfig const> const& config ) const = 0;
-        virtual FactoryMap const& getFactories() const = 0;
-        virtual Listeners const& getListeners() const = 0;
-    };
-
-    Ptr<IStreamingReporter> addReporter( Ptr<IStreamingReporter> const& existingReporter, Ptr<IStreamingReporter> const& additionalReporter );
-
-}
-
-#include <limits>
-#include <algorithm>
-
-namespace Catch {
-
-    inline 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();
-        }
-
-        std::size_t matchedTests = 0;
-        TextAttributes nameAttr, descAttr, tagsAttr;
-        nameAttr.setInitialIndent( 2 ).setIndent( 4 );
-        descAttr.setIndent( 4 );
-        tagsAttr.setIndent( 6 );
-
-        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
-        for( std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
-                it != itEnd;
-                ++it ) {
-            matchedTests++;
-            TestCaseInfo const& testCaseInfo = it->getTestCaseInfo();
-            Colour::Code colour = testCaseInfo.isHidden()
-                ? Colour::SecondaryText
-                : Colour::None;
-            Colour colourGuard( colour );
-
-            Catch::cout() << Text( testCaseInfo.name, nameAttr ) << std::endl;
-            if( config.listExtraInfo() ) {
-                Catch::cout() << "    " << testCaseInfo.lineInfo << std::endl;
-                std::string description = testCaseInfo.description;
-                if( description.empty() )
-                    description = "(NO DESCRIPTION)";
-                Catch::cout() << Text( description, descAttr ) << std::endl;
-            }
-            if( !testCaseInfo.tags.empty() )
-                Catch::cout() << Text( testCaseInfo.tagsAsString, tagsAttr ) << std::endl;
-        }
-
-        if( !config.testSpec().hasFilters() )
-            Catch::cout() << pluralise( matchedTests, "test case" ) << '\n' << std::endl;
-        else
-            Catch::cout() << pluralise( matchedTests, "matching test case" ) << '\n' << std::endl;
-        return matchedTests;
-    }
-
-    inline 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( std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
-                it != itEnd;
-                ++it ) {
-            matchedTests++;
-            TestCaseInfo const& testCaseInfo = it->getTestCaseInfo();
-            if( startsWith( testCaseInfo.name, '#' ) )
-               Catch::cout() << '"' << testCaseInfo.name << '"';
-            else
-               Catch::cout() << testCaseInfo.name;
-            if ( config.listExtraInfo() )
-                Catch::cout() << "\t@" << testCaseInfo.lineInfo;
-            Catch::cout() << std::endl;
-        }
-        return matchedTests;
-    }
-
-    struct TagInfo {
-        TagInfo() : count ( 0 ) {}
-        void add( std::string const& spelling ) {
-            ++count;
-            spellings.insert( spelling );
-        }
-        std::string all() const {
-            std::string out;
-            for( std::set<std::string>::const_iterator it = spellings.begin(), itEnd = spellings.end();
-                        it != itEnd;
-                        ++it )
-                out += "[" + *it + "]";
-            return out;
-        }
-        std::set<std::string> spellings;
-        std::size_t count;
-    };
-
-    inline 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( std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
-                it != itEnd;
-                ++it ) {
-            for( std::set<std::string>::const_iterator  tagIt = it->getTestCaseInfo().tags.begin(),
-                                                        tagItEnd = it->getTestCaseInfo().tags.end();
-                    tagIt != tagItEnd;
-                    ++tagIt ) {
-                std::string tagName = *tagIt;
-                std::string lcaseTagName = toLower( tagName );
-                std::map<std::string, TagInfo>::iterator countIt = tagCounts.find( lcaseTagName );
-                if( countIt == tagCounts.end() )
-                    countIt = tagCounts.insert( std::make_pair( lcaseTagName, TagInfo() ) ).first;
-                countIt->second.add( tagName );
-            }
-        }
-
-        for( std::map<std::string, TagInfo>::const_iterator countIt = tagCounts.begin(),
-                                                            countItEnd = tagCounts.end();
-                countIt != countItEnd;
-                ++countIt ) {
-            std::ostringstream oss;
-            oss << "  " << std::setw(2) << countIt->second.count << "  ";
-            Text wrapper( countIt->second.all(), TextAttributes()
-                                                    .setInitialIndent( 0 )
-                                                    .setIndent( oss.str().size() )
-                                                    .setWidth( CATCH_CONFIG_CONSOLE_WIDTH-10 ) );
-            Catch::cout() << oss.str() << wrapper << '\n';
-        }
-        Catch::cout() << pluralise( tagCounts.size(), "tag" ) << '\n' << std::endl;
-        return tagCounts.size();
-    }
-
-    inline std::size_t listReporters( Config const& /*config*/ ) {
-        Catch::cout() << "Available reporters:\n";
-        IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
-        IReporterRegistry::FactoryMap::const_iterator itBegin = factories.begin(), itEnd = factories.end(), it;
-        std::size_t maxNameLen = 0;
-        for(it = itBegin; it != itEnd; ++it )
-            maxNameLen = (std::max)( maxNameLen, it->first.size() );
-
-        for(it = itBegin; it != itEnd; ++it ) {
-            Text wrapper( it->second->getDescription(), TextAttributes()
-                                                        .setInitialIndent( 0 )
-                                                        .setIndent( 7+maxNameLen )
-                                                        .setWidth( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen-8 ) );
-            Catch::cout() << "  "
-                    << it->first
-                    << ':'
-                    << std::string( maxNameLen - it->first.size() + 2, ' ' )
-                    << wrapper << '\n';
-        }
-        Catch::cout() << std::endl;
-        return factories.size();
-    }
-
-    inline Option<std::size_t> list( Config const& config ) {
-        Option<std::size_t> listedCount;
-        if( config.listTests() || ( config.listExtraInfo() && !config.listTestNamesOnly() ) )
-            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;
-    }
-
-} // end namespace Catch
-
-// #included from: internal/catch_run_context.hpp
-#define TWOBLUECUBES_CATCH_RUNNER_IMPL_HPP_INCLUDED
-
-// #included from: catch_test_case_tracker.hpp
-#define TWOBLUECUBES_CATCH_TEST_CASE_TRACKER_HPP_INCLUDED
-
-#include <algorithm>
-#include <string>
-#include <assert.h>
-#include <vector>
-#include <stdexcept>
-
-CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS
-
-namespace Catch {
-namespace TestCaseTracking {
-
-    struct NameAndLocation {
-        std::string name;
-        SourceLineInfo location;
-
-        NameAndLocation( std::string const& _name, SourceLineInfo const& _location )
-        :   name( _name ),
-            location( _location )
-        {}
-    };
-
-    struct ITracker : SharedImpl<> {
-        virtual ~ITracker();
-
-        // static queries
-        virtual NameAndLocation const& nameAndLocation() const = 0;
-
-        // 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;
-
-        // actions
-        virtual void close() = 0; // Successfully complete
-        virtual void fail() = 0;
-        virtual void markAsNeedingAnotherRun() = 0;
-
-        virtual void addChild( Ptr<ITracker> const& child ) = 0;
-        virtual ITracker* findChild( NameAndLocation const& nameAndLocation ) = 0;
-        virtual void openChild() = 0;
-
-        // Debug/ checking
-        virtual bool isSectionTracker() const = 0;
-        virtual bool isIndexTracker() const = 0;
-    };
-
-    class  TrackerContext {
-
-        enum RunState {
-            NotStarted,
-            Executing,
-            CompletedCycle
-        };
-
-        Ptr<ITracker> m_rootTracker;
-        ITracker* m_currentTracker;
-        RunState m_runState;
-
-    public:
-
-        static TrackerContext& instance() {
-            static TrackerContext s_instance;
-            return s_instance;
-        }
-
-        TrackerContext()
-        :   m_currentTracker( CATCH_NULL ),
-            m_runState( NotStarted )
-        {}
-
-        ITracker& startRun();
-
-        void endRun() {
-            m_rootTracker.reset();
-            m_currentTracker = CATCH_NULL;
-            m_runState = NotStarted;
-        }
-
-        void startCycle() {
-            m_currentTracker = m_rootTracker.get();
-            m_runState = Executing;
-        }
-        void completeCycle() {
-            m_runState = CompletedCycle;
-        }
-
-        bool completedCycle() const {
-            return m_runState == CompletedCycle;
-        }
-        ITracker& currentTracker() {
-            return *m_currentTracker;
-        }
-        void setCurrentTracker( ITracker* tracker ) {
-            m_currentTracker = tracker;
-        }
-    };
-
-    class TrackerBase : public ITracker {
-    protected:
-        enum CycleState {
-            NotStarted,
-            Executing,
-            ExecutingChildren,
-            NeedsAnotherRun,
-            CompletedSuccessfully,
-            Failed
-        };
-        class TrackerHasName {
-            NameAndLocation m_nameAndLocation;
-        public:
-            TrackerHasName( NameAndLocation const& nameAndLocation ) : m_nameAndLocation( nameAndLocation ) {}
-            bool operator ()( Ptr<ITracker> const& tracker ) {
-                return
-                    tracker->nameAndLocation().name == m_nameAndLocation.name &&
-                    tracker->nameAndLocation().location == m_nameAndLocation.location;
-            }
-        };
-        typedef std::vector<Ptr<ITracker> > Children;
-        NameAndLocation m_nameAndLocation;
-        TrackerContext& m_ctx;
-        ITracker* m_parent;
-        Children m_children;
-        CycleState m_runState;
-    public:
-        TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
-        :   m_nameAndLocation( nameAndLocation ),
-            m_ctx( ctx ),
-            m_parent( parent ),
-            m_runState( NotStarted )
-        {}
-        virtual ~TrackerBase();
-
-        virtual NameAndLocation const& nameAndLocation() const CATCH_OVERRIDE {
-            return m_nameAndLocation;
-        }
-        virtual bool isComplete() const CATCH_OVERRIDE {
-            return m_runState == CompletedSuccessfully || m_runState == Failed;
-        }
-        virtual bool isSuccessfullyCompleted() const CATCH_OVERRIDE {
-            return m_runState == CompletedSuccessfully;
-        }
-        virtual bool isOpen() const CATCH_OVERRIDE {
-            return m_runState != NotStarted && !isComplete();
-        }
-        virtual bool hasChildren() const CATCH_OVERRIDE {
-            return !m_children.empty();
-        }
-
-        virtual void addChild( Ptr<ITracker> const& child ) CATCH_OVERRIDE {
-            m_children.push_back( child );
-        }
-
-        virtual ITracker* findChild( NameAndLocation const& nameAndLocation ) CATCH_OVERRIDE {
-            Children::const_iterator it = std::find_if( m_children.begin(), m_children.end(), TrackerHasName( nameAndLocation ) );
-            return( it != m_children.end() )
-                ? it->get()
-                : CATCH_NULL;
-        }
-        virtual ITracker& parent() CATCH_OVERRIDE {
-            assert( m_parent ); // Should always be non-null except for root
-            return *m_parent;
-        }
-
-        virtual void openChild() CATCH_OVERRIDE {
-            if( m_runState != ExecutingChildren ) {
-                m_runState = ExecutingChildren;
-                if( m_parent )
-                    m_parent->openChild();
-            }
-        }
-
-        virtual bool isSectionTracker() const CATCH_OVERRIDE { return false; }
-        virtual bool isIndexTracker() const CATCH_OVERRIDE { return false; }
-
-        void open() {
-            m_runState = Executing;
-            moveToThis();
-            if( m_parent )
-                m_parent->openChild();
-        }
-
-        virtual void close() CATCH_OVERRIDE {
-
-            // Close any still open children (e.g. generators)
-            while( &m_ctx.currentTracker() != this )
-                m_ctx.currentTracker().close();
-
-            switch( m_runState ) {
-                case NotStarted:
-                case CompletedSuccessfully:
-                case Failed:
-                    throw std::logic_error( "Illogical state" );
-
-                case NeedsAnotherRun:
-                    break;;
-
-                case Executing:
-                    m_runState = CompletedSuccessfully;
-                    break;
-                case ExecutingChildren:
-                    if( m_children.empty() || m_children.back()->isComplete() )
-                        m_runState = CompletedSuccessfully;
-                    break;
-
-                default:
-                    throw std::logic_error( "Unexpected state" );
-            }
-            moveToParent();
-            m_ctx.completeCycle();
-        }
-        virtual void fail() CATCH_OVERRIDE {
-            m_runState = Failed;
-            if( m_parent )
-                m_parent->markAsNeedingAnotherRun();
-            moveToParent();
-            m_ctx.completeCycle();
-        }
-        virtual void markAsNeedingAnotherRun() CATCH_OVERRIDE {
-            m_runState = NeedsAnotherRun;
-        }
-    private:
-        void moveToParent() {
-            assert( m_parent );
-            m_ctx.setCurrentTracker( m_parent );
-        }
-        void moveToThis() {
-            m_ctx.setCurrentTracker( this );
-        }
-    };
-
-    class SectionTracker : public TrackerBase {
-        std::vector<std::string> m_filters;
-    public:
-        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 );
-            }
-        }
-        virtual ~SectionTracker();
-
-        virtual bool isSectionTracker() const CATCH_OVERRIDE { return true; }
-
-        static SectionTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation ) {
-            SectionTracker* section = CATCH_NULL;
-
-            ITracker& currentTracker = ctx.currentTracker();
-            if( ITracker* childTracker = currentTracker.findChild( nameAndLocation ) ) {
-                assert( childTracker );
-                assert( childTracker->isSectionTracker() );
-                section = static_cast<SectionTracker*>( childTracker );
-            }
-            else {
-                section = new SectionTracker( nameAndLocation, ctx, &currentTracker );
-                currentTracker.addChild( section );
-            }
-            if( !ctx.completedCycle() )
-                section->tryOpen();
-            return *section;
-        }
-
-        void tryOpen() {
-            if( !isComplete() && (m_filters.empty() || m_filters[0].empty() ||  m_filters[0] == m_nameAndLocation.name ) )
-                open();
-        }
-
-        void 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 addNextFilters( std::vector<std::string> const& filters ) {
-            if( filters.size() > 1 )
-                m_filters.insert( m_filters.end(), ++filters.begin(), filters.end() );
-        }
-    };
-
-    class IndexTracker : public TrackerBase {
-        int m_size;
-        int m_index;
-    public:
-        IndexTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent, int size )
-        :   TrackerBase( nameAndLocation, ctx, parent ),
-            m_size( size ),
-            m_index( -1 )
-        {}
-        virtual ~IndexTracker();
-
-        virtual bool isIndexTracker() const CATCH_OVERRIDE { return true; }
-
-        static IndexTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation, int size ) {
-            IndexTracker* tracker = CATCH_NULL;
-
-            ITracker& currentTracker = ctx.currentTracker();
-            if( ITracker* childTracker = currentTracker.findChild( nameAndLocation ) ) {
-                assert( childTracker );
-                assert( childTracker->isIndexTracker() );
-                tracker = static_cast<IndexTracker*>( childTracker );
-            }
-            else {
-                tracker = new 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 index() const { return m_index; }
-
-        void moveNext() {
-            m_index++;
-            m_children.clear();
-        }
-
-        virtual void close() CATCH_OVERRIDE {
-            TrackerBase::close();
-            if( m_runState == CompletedSuccessfully && m_index < m_size-1 )
-                m_runState = Executing;
-        }
-    };
-
-    inline ITracker& TrackerContext::startRun() {
-        m_rootTracker = new SectionTracker( NameAndLocation( "{root}", CATCH_INTERNAL_LINEINFO ), *this, CATCH_NULL );
-        m_currentTracker = CATCH_NULL;
-        m_runState = Executing;
-        return *m_rootTracker;
-    }
-
-} // namespace TestCaseTracking
-
-using TestCaseTracking::ITracker;
-using TestCaseTracking::TrackerContext;
-using TestCaseTracking::SectionTracker;
-using TestCaseTracking::IndexTracker;
-
-} // namespace Catch
-
-CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS
-
-// #included from: catch_fatal_condition.hpp
-#define TWOBLUECUBES_CATCH_FATAL_CONDITION_H_INCLUDED
-
-namespace Catch {
-
-    // Report the error condition
-    inline void reportFatal( std::string const& message ) {
-        IContext& context = Catch::getCurrentContext();
-        IResultCapture* resultCapture = context.getResultCapture();
-        resultCapture->handleFatalErrorCondition( message );
-    }
-
-} // namespace Catch
-
-#if defined ( CATCH_PLATFORM_WINDOWS ) /////////////////////////////////////////
-// #included from: catch_windows_h_proxy.h
-
-#define TWOBLUECUBES_CATCH_WINDOWS_H_PROXY_H_INCLUDED
-
-#ifdef CATCH_DEFINES_NOMINMAX
-#  define NOMINMAX
-#endif
-#ifdef CATCH_DEFINES_WIN32_LEAN_AND_MEAN
-#  define WIN32_LEAN_AND_MEAN
-#endif
-
-#ifdef __AFXDLL
-#include <AfxWin.h>
-#else
-#include <windows.h>
-#endif
-
-#ifdef CATCH_DEFINES_NOMINMAX
-#  undef NOMINMAX
-#endif
-#ifdef CATCH_DEFINES_WIN32_LEAN_AND_MEAN
-#  undef WIN32_LEAN_AND_MEAN
-#endif
-
-
-#  if !defined ( CATCH_CONFIG_WINDOWS_SEH )
-
-namespace Catch {
-    struct FatalConditionHandler {
-        void reset() {}
-    };
-}
-
-#  else // CATCH_CONFIG_WINDOWS_SEH is defined
-
-namespace Catch {
-
-    struct SignalDefs { DWORD id; const char* name; };
-    extern SignalDefs signalDefs[];
-    // 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.
-    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" },
-    };
-
-    struct FatalConditionHandler {
-
-        static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {
-            for (int i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
-                if (ExceptionInfo->ExceptionRecord->ExceptionCode == signalDefs[i].id) {
-                    reportFatal(signalDefs[i].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() {
-            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 = CATCH_NULL;
-            // Register as first handler in current chain
-            exceptionHandlerHandle = AddVectoredExceptionHandler(1, handleVectoredException);
-            // Pass in guarantee size to be filled
-            SetThreadStackGuarantee(&guaranteeSize);
-        }
-
-        static void reset() {
-            if (isSet) {
-                // Unregister handler and restore the old guarantee
-                RemoveVectoredExceptionHandler(exceptionHandlerHandle);
-                SetThreadStackGuarantee(&guaranteeSize);
-                exceptionHandlerHandle = CATCH_NULL;
-                isSet = false;
-            }
-        }
-
-        ~FatalConditionHandler() {
-            reset();
-        }
-    private:
-        static bool isSet;
-        static ULONG guaranteeSize;
-        static PVOID exceptionHandlerHandle;
-    };
-
-    bool FatalConditionHandler::isSet = false;
-    ULONG FatalConditionHandler::guaranteeSize = 0;
-    PVOID FatalConditionHandler::exceptionHandlerHandle = CATCH_NULL;
-
-} // namespace Catch
-
-#  endif // CATCH_CONFIG_WINDOWS_SEH
-
-#else // Not Windows - assumed to be POSIX compatible //////////////////////////
-
-#  if !defined(CATCH_CONFIG_POSIX_SIGNALS)
-
-namespace Catch {
-    struct FatalConditionHandler {
-        void reset() {}
-    };
-}
-
-#  else // CATCH_CONFIG_POSIX_SIGNALS is defined
-
-#include <signal.h>
-
-namespace Catch {
-
-    struct SignalDefs {
-        int id;
-        const char* name;
-    };
-    extern SignalDefs signalDefs[];
-    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" }
-    };
-
-    struct FatalConditionHandler {
-
-        static bool isSet;
-        static struct sigaction oldSigActions [sizeof(signalDefs)/sizeof(SignalDefs)];
-        static stack_t oldSigStack;
-        static char altStackMem[SIGSTKSZ];
-
-        static void handleSignal( int sig ) {
-            std::string name = "<unknown signal>";
-            for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
-                SignalDefs &def = signalDefs[i];
-                if (sig == def.id) {
-                    name = def.name;
-                    break;
-                }
-            }
-            reset();
-            reportFatal(name);
-            raise( sig );
-        }
-
-        FatalConditionHandler() {
-            isSet = true;
-            stack_t sigStack;
-            sigStack.ss_sp = altStackMem;
-            sigStack.ss_size = SIGSTKSZ;
-            sigStack.ss_flags = 0;
-            sigaltstack(&sigStack, &oldSigStack);
-            struct sigaction sa = { 0 };
-
-            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() {
-            reset();
-        }
-        static void 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], CATCH_NULL);
-                }
-                // Return the old stack
-                sigaltstack(&oldSigStack, CATCH_NULL);
-                isSet = false;
-            }
-        }
-    };
-
-    bool FatalConditionHandler::isSet = false;
-    struct sigaction FatalConditionHandler::oldSigActions[sizeof(signalDefs)/sizeof(SignalDefs)] = {};
-    stack_t FatalConditionHandler::oldSigStack = {};
-    char FatalConditionHandler::altStackMem[SIGSTKSZ] = {};
-
-} // namespace Catch
-
-#  endif // CATCH_CONFIG_POSIX_SIGNALS
-
-#endif // not Windows
-
-#include <cassert>
-#include <set>
-#include <string>
-
-namespace Catch {
-
-    class StreamRedirect {
-
-    public:
-        StreamRedirect( std::ostream& stream, std::string& targetString )
-        :   m_stream( stream ),
-            m_prevBuf( stream.rdbuf() ),
-            m_targetString( targetString )
-        {
-            stream.rdbuf( m_oss.rdbuf() );
-        }
-
-        ~StreamRedirect() {
-            m_targetString += m_oss.str();
-            m_stream.rdbuf( m_prevBuf );
-        }
-
-    private:
-        std::ostream& m_stream;
-        std::streambuf* m_prevBuf;
-        std::ostringstream m_oss;
-        std::string& m_targetString;
-    };
-
-    // 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)
-        :m_cerrBuf( cerr().rdbuf() ), m_clogBuf(clog().rdbuf()),
-        m_targetString(targetString){
-            cerr().rdbuf(m_oss.rdbuf());
-            clog().rdbuf(m_oss.rdbuf());
-        }
-        ~StdErrRedirect() {
-            m_targetString += m_oss.str();
-            cerr().rdbuf(m_cerrBuf);
-            clog().rdbuf(m_clogBuf);
-        }
-    private:
-        std::streambuf* m_cerrBuf;
-        std::streambuf* m_clogBuf;
-        std::ostringstream m_oss;
-        std::string& m_targetString;
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    class RunContext : public IResultCapture, public IRunner {
-
-        RunContext( RunContext const& );
-        void operator =( RunContext const& );
-
-    public:
-
-        explicit RunContext( Ptr<IConfig const> const& _config, Ptr<IStreamingReporter> const& reporter )
-        :   m_runInfo( _config->name() ),
-            m_context( getCurrentMutableContext() ),
-            m_activeTestCase( CATCH_NULL ),
-            m_config( _config ),
-            m_reporter( reporter ),
-            m_shouldReportUnexpected ( true )
-        {
-            m_context.setRunner( this );
-            m_context.setConfig( m_config );
-            m_context.setResultCapture( this );
-            m_reporter->testRunStarting( m_runInfo );
-        }
-
-        virtual ~RunContext() {
-            m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, aborting() ) );
-        }
-
-        void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount ) {
-            m_reporter->testGroupStarting( GroupInfo( testSpec, groupIndex, groupsCount ) );
-        }
-        void 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 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;
-
-            do {
-                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() );
-            }
-            // !TBD: deprecated - this will be replaced by indexed trackers
-            while( getCurrentContext().advanceGeneratorsForCurrentTest() && !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 = CATCH_NULL;
-            m_testCaseTracker = CATCH_NULL;
-
-            return deltaTotals;
-        }
-
-        Ptr<IConfig const> config() const {
-            return m_config;
-        }
-
-    private: // IResultCapture
-
-        virtual void 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 = AssertionInfo( "", m_lastAssertionInfo.lineInfo, "{Unknown expression after the reported line}" , m_lastAssertionInfo.resultDisposition );
-            m_lastResult = result;
-        }
-
-        virtual bool lastAssertionPassed()
-        {
-            return m_totals.assertions.passed == (m_prevPassed + 1);
-        }
-
-        virtual void assertionPassed()
-        {
-            m_totals.assertions.passed++;
-            m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}";
-            m_lastAssertionInfo.macroName = "";
-        }
-
-        virtual void assertionRun()
-        {
-            m_prevPassed = m_totals.assertions.passed;
-        }
-
-        virtual bool 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 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;
-        }
-
-        virtual void 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();
-        }
-
-        virtual void 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 );
-        }
-
-        virtual void pushScopedMessage( MessageInfo const& message ) {
-            m_messages.push_back( message );
-        }
-
-        virtual void popScopedMessage( MessageInfo const& message ) {
-            m_messages.erase( std::remove( m_messages.begin(), m_messages.end(), message ), m_messages.end() );
-        }
-
-        virtual std::string getCurrentTestName() const {
-            return m_activeTestCase
-                ? m_activeTestCase->getTestCaseInfo().name
-                : std::string();
-        }
-
-        virtual const AssertionResult* getLastResult() const {
-            return &m_lastResult;
-        }
-
-        virtual void exceptionEarlyReported() {
-            m_shouldReportUnexpected = false;
-        }
-
-        virtual void handleFatalErrorCondition( std::string const& message ) {
-            // Don't rebuild the result -- the stringification itself can cause more fatal errors
-            // Instead, fake a result data.
-            AssertionResultData tempResult;
-            tempResult.resultType = ResultWas::FatalErrorCondition;
-            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)
-            TestCaseInfo 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 );
-
-            TestCaseInfo 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 ) );
-        }
-
-    public:
-        // !TBD We need to do this another way!
-        bool aborting() const {
-            return m_totals.assertions.failed == static_cast<std::size_t>( m_config->abortAfter() );
-        }
-
-    private:
-
-        void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr ) {
-            TestCaseInfo 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 = AssertionInfo( "TEST_CASE", testCaseInfo.lineInfo, "", ResultDisposition::Normal );
-
-                seedRng( *m_config );
-
-                Timer timer;
-                timer.start();
-                if( m_reporter->getPreferences().shouldRedirectStdOut ) {
-                    StreamRedirect coutRedir( Catch::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) {
-                    makeUnexpectedResultBuilder().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 invokeActiveTestCase() {
-            FatalConditionHandler fatalConditionHandler; // Handle signals
-            m_activeTestCase->invoke();
-            fatalConditionHandler.reset();
-        }
-
-    private:
-
-        ResultBuilder makeUnexpectedResultBuilder() const {
-            return ResultBuilder(   m_lastAssertionInfo.macroName,
-                                    m_lastAssertionInfo.lineInfo,
-                                    m_lastAssertionInfo.capturedExpression,
-                                    m_lastAssertionInfo.resultDisposition );
-        }
-
-        void 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( std::vector<SectionEndInfo>::const_reverse_iterator it = m_unfinishedSections.rbegin(),
-                        itEnd = m_unfinishedSections.rend();
-                    it != itEnd;
-                    ++it )
-                sectionEnded( *it );
-            m_unfinishedSections.clear();
-        }
-
-        TestRunInfo m_runInfo;
-        IMutableContext& m_context;
-        TestCase const* m_activeTestCase;
-        ITracker* m_testCaseTracker;
-        ITracker* m_currentSectionTracker;
-        AssertionResult m_lastResult;
-
-        Ptr<IConfig const> m_config;
-        Totals m_totals;
-        Ptr<IStreamingReporter> m_reporter;
-        std::vector<MessageInfo> m_messages;
-        AssertionInfo m_lastAssertionInfo;
-        std::vector<SectionEndInfo> m_unfinishedSections;
-        std::vector<ITracker*> m_activeSections;
-        TrackerContext m_trackerContext;
-        size_t m_prevPassed;
-        bool m_shouldReportUnexpected;
-    };
-
-    IResultCapture& getResultCapture() {
-        if( IResultCapture* capture = getCurrentContext().getResultCapture() )
-            return *capture;
-        else
-            throw std::logic_error( "No result capture instance" );
-    }
-
-} // end namespace Catch
-
-// #included from: internal/catch_version.h
-#define TWOBLUECUBES_CATCH_VERSION_H_INCLUDED
-
-namespace Catch {
-
-    // Versioning information
-    struct Version {
-        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 );
-
-    private:
-        void operator=( Version const& );
-    };
-
-    inline Version libraryVersion();
-}
-
-#include <fstream>
-#include <stdlib.h>
-#include <limits>
-
-namespace Catch {
-
-    Ptr<IStreamingReporter> createReporter( std::string const& reporterName, Ptr<Config> const& config ) {
-        Ptr<IStreamingReporter> reporter = getRegistryHub().getReporterRegistry().create( reporterName, config.get() );
-        if( !reporter ) {
-            std::ostringstream oss;
-            oss << "No reporter registered with name: '" << reporterName << "'";
-            throw std::domain_error( oss.str() );
-        }
-        return reporter;
-    }
-
-#if !defined(CATCH_CONFIG_DEFAULT_REPORTER)
-#define CATCH_CONFIG_DEFAULT_REPORTER "console"
-#endif
-
-    Ptr<IStreamingReporter> makeReporter( Ptr<Config> const& config ) {
-        std::vector<std::string> reporters = config->getReporterNames();
-        if( reporters.empty() )
-            reporters.push_back( CATCH_CONFIG_DEFAULT_REPORTER );
-
-        Ptr<IStreamingReporter> reporter;
-        for( std::vector<std::string>::const_iterator it = reporters.begin(), itEnd = reporters.end();
-                it != itEnd;
-                ++it )
-            reporter = addReporter( reporter, createReporter( *it, config ) );
-        return reporter;
-    }
-    Ptr<IStreamingReporter> addListeners( Ptr<IConfig const> const& config, Ptr<IStreamingReporter> reporters ) {
-        IReporterRegistry::Listeners listeners = getRegistryHub().getReporterRegistry().getListeners();
-        for( IReporterRegistry::Listeners::const_iterator it = listeners.begin(), itEnd = listeners.end();
-                it != itEnd;
-                ++it )
-            reporters = addReporter(reporters, (*it)->create( ReporterConfig( config ) ) );
-        return reporters;
-    }
-
-    Totals runTests( Ptr<Config> const& config ) {
-
-        Ptr<IConfig const> iconfig = config.get();
-
-        Ptr<IStreamingReporter> reporter = makeReporter( config );
-        reporter = addListeners( iconfig, reporter );
-
-        RunContext context( iconfig, 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
-
-        std::vector<TestCase> const& allTestCases = getAllTestCasesSorted( *iconfig );
-        for( std::vector<TestCase>::const_iterator it = allTestCases.begin(), itEnd = allTestCases.end();
-                it != itEnd;
-                ++it ) {
-            if( !context.aborting() && matchTest( *it, testSpec, *iconfig ) )
-                totals += context.runTest( *it );
-            else
-                reporter->skipTest( *it );
-        }
-
-        context.testGroupEnded( iconfig->name(), totals, 1, 1 );
-        return totals;
-    }
-
-    void applyFilenamesAsTags( IConfig const& config ) {
-        std::vector<TestCase> const& tests = getAllTestCasesSorted( config );
-        for(std::size_t i = 0; i < tests.size(); ++i ) {
-            TestCase& test = const_cast<TestCase&>( tests[i] );
-            std::set<std::string> tags = test.tags;
-
-            std::string filename = test.lineInfo.file;
-            std::string::size_type lastSlash = filename.find_last_of( "\\/" );
-            if( lastSlash != std::string::npos )
-                filename = filename.substr( lastSlash+1 );
-
-            std::string::size_type lastDot = filename.find_last_of( '.' );
-            if( lastDot != std::string::npos )
-                filename = filename.substr( 0, lastDot );
-
-            tags.insert( '#' + filename );
-            setTags( test, tags );
-        }
-    }
-
-    class Session : NonCopyable {
-        static bool alreadyInstantiated;
-
-    public:
-
-        struct OnUnusedOptions { enum DoWhat { Ignore, Fail }; };
-
-        Session()
-        : m_cli( makeCommandLineParser() ) {
-            if( alreadyInstantiated ) {
-                std::string msg = "Only one instance of Catch::Session can ever be used";
-                Catch::cerr() << msg << std::endl;
-                throw std::logic_error( msg );
-            }
-            alreadyInstantiated = true;
-        }
-        ~Session() {
-            Catch::cleanUp();
-        }
-
-        void showHelp( std::string const& processName ) {
-            Catch::cout() << "\nCatch v" << libraryVersion() << "\n";
-
-            m_cli.usage( Catch::cout(), processName );
-            Catch::cout() << "For more detail usage please see the project docs\n" << std::endl;
-        }
-        void 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 applyCommandLine( int argc, char const* const* const argv, OnUnusedOptions::DoWhat unusedOptionBehaviour = OnUnusedOptions::Fail ) {
-            try {
-                m_cli.setThrowOnUnrecognisedTokens( unusedOptionBehaviour == OnUnusedOptions::Fail );
-                m_unusedTokens = m_cli.parseInto( Clara::argsToVector( argc, argv ), m_configData );
-                if( m_configData.showHelp )
-                    showHelp( m_configData.processName );
-                if( m_configData.libIdentify )
-                    libIdentify();
-                m_config.reset();
-            }
-            catch( std::exception& ex ) {
-                {
-                    Colour colourGuard( Colour::Red );
-                    Catch::cerr()
-                        << "\nError(s) in input:\n"
-                        << Text( ex.what(), TextAttributes().setIndent(2) )
-                        << "\n\n";
-                }
-                m_cli.usage( Catch::cout(), m_configData.processName );
-                return (std::numeric_limits<int>::max)();
-            }
-            return 0;
-        }
-
-        void useConfigData( ConfigData const& _configData ) {
-            m_configData = _configData;
-            m_config.reset();
-        }
-
-        int run( int argc, char const* const* const argv ) {
-
-            int returnCode = applyCommandLine( argc, argv );
-            if( returnCode == 0 )
-                returnCode = run();
-            return returnCode;
-        }
-
-    #if defined(WIN32) && defined(UNICODE)
-        int run( int argc, wchar_t const* 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 );
-            if( returnCode == 0 )
-                returnCode = run();
-
-            for ( int i = 0; i < argc; ++i )
-                delete [] utf8Argv[ i ];
-
-            delete [] utf8Argv;
-
-            return returnCode;
-        }
-    #endif
-
-        int 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::CommandLine<ConfigData> const& cli() const {
-            return m_cli;
-        }
-        std::vector<Clara::Parser::Token> const& unusedTokens() const {
-            return m_unusedTokens;
-        }
-        ConfigData& configData() {
-            return m_configData;
-        }
-        Config& config() {
-            if( !m_config )
-                m_config = new Config( m_configData );
-            return *m_config;
-        }
-    private:
-
-        int runInternal() {
-            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 static_cast<int>( runTests( m_config ).assertions.failed );
-            }
-            catch( std::exception& ex ) {
-                Catch::cerr() << ex.what() << std::endl;
-                return (std::numeric_limits<int>::max)();
-            }
-        }
-
-        Clara::CommandLine<ConfigData> m_cli;
-        std::vector<Clara::Parser::Token> m_unusedTokens;
-        ConfigData m_configData;
-        Ptr<Config> m_config;
-    };
-
-    bool Session::alreadyInstantiated = false;
-
-} // end namespace Catch
-
-// #included from: catch_registry_hub.hpp
-#define TWOBLUECUBES_CATCH_REGISTRY_HUB_HPP_INCLUDED
-
-// #included from: catch_test_case_registry_impl.hpp
-#define TWOBLUECUBES_CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
-
-#include <vector>
-#include <set>
-#include <sstream>
-#include <algorithm>
-
-namespace Catch {
-
-    struct RandomNumberGenerator {
-        typedef unsigned int result_type;
-
-        result_type operator()( result_type n ) const { return std::rand() % n; }
-
-#ifdef CATCH_CONFIG_CPP11_SHUFFLE
-        static constexpr result_type (min)() { return 0; }
-        static constexpr result_type (max)() { return 1000000; }
-        result_type operator()() const { return std::rand() % (max)(); }
-#endif
-        template<typename V>
-        static void shuffle( V& vector ) {
-            RandomNumberGenerator rng;
-#ifdef CATCH_CONFIG_CPP11_SHUFFLE
-            std::shuffle( vector.begin(), vector.end(), rng );
-#else
-            std::random_shuffle( vector.begin(), vector.end(), rng );
-#endif
-        }
-    };
-
-    inline 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( std::vector<TestCase>::const_iterator it = functions.begin(), itEnd = functions.end();
-            it != itEnd;
-            ++it ) {
-            std::pair<std::set<TestCase>::const_iterator, bool> prev = seenFunctions.insert( *it );
-            if( !prev.second ) {
-                std::ostringstream ss;
-
-                ss  << Colour( Colour::Red )
-                    << "error: TEST_CASE( \"" << it->name << "\" ) already defined.\n"
-                    << "\tFirst seen at " << prev.first->getTestCaseInfo().lineInfo << '\n'
-                    << "\tRedefined at " << it->getTestCaseInfo().lineInfo << std::endl;
-
-                throw std::runtime_error(ss.str());
-            }
-        }
-    }
-
-    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
-        std::vector<TestCase> filtered;
-        filtered.reserve( testCases.size() );
-        for( std::vector<TestCase>::const_iterator it = testCases.begin(), itEnd = testCases.end();
-                it != itEnd;
-                ++it )
-            if( matchTest( *it, testSpec, config ) )
-                filtered.push_back( *it );
-        return filtered;
-    }
-    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config ) {
-        return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config );
-    }
-
-    class TestRegistry : public ITestCaseRegistry {
-    public:
-        TestRegistry()
-        :   m_currentSortOrder( RunTests::InDeclarationOrder ),
-            m_unnamedCount( 0 )
-        {}
-        virtual ~TestRegistry();
-
-        virtual void 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 );
-        }
-
-        virtual std::vector<TestCase> const& getAllTests() const {
-            return m_functions;
-        }
-        virtual std::vector<TestCase> const& 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;
-        }
-
-    private:
-        std::vector<TestCase> m_functions;
-        mutable RunTests::InWhatOrder m_currentSortOrder;
-        mutable std::vector<TestCase> m_sortedFunctions;
-        size_t m_unnamedCount;
-        std::ios_base::Init m_ostreamInit; // Forces cout/ cerr to be initialised
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    class FreeFunctionTestCase : public SharedImpl<ITestCase> {
-    public:
-
-        FreeFunctionTestCase( TestFunction fun ) : m_fun( fun ) {}
-
-        virtual void invoke() const {
-            m_fun();
-        }
-
-    private:
-        virtual ~FreeFunctionTestCase();
-
-        TestFunction m_fun;
-    };
-
-    inline 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;
-    }
-
-    void registerTestCase
-        (   ITestCase* testCase,
-            char const* classOrQualifiedMethodName,
-            NameAndDesc const& nameAndDesc,
-            SourceLineInfo const& lineInfo ) {
-
-        getMutableRegistryHub().registerTest
-            ( makeTestCase
-                (   testCase,
-                    extractClassName( classOrQualifiedMethodName ),
-                    nameAndDesc.name,
-                    nameAndDesc.description,
-                    lineInfo ) );
-    }
-    void registerTestCaseFunction
-        (   TestFunction function,
-            SourceLineInfo const& lineInfo,
-            NameAndDesc const& nameAndDesc ) {
-        registerTestCase( new FreeFunctionTestCase( function ), "", nameAndDesc, lineInfo );
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    AutoReg::AutoReg
-        (   TestFunction function,
-            SourceLineInfo const& lineInfo,
-            NameAndDesc const& nameAndDesc ) {
-        registerTestCaseFunction( function, lineInfo, nameAndDesc );
-    }
-
-    AutoReg::~AutoReg() {}
-
-} // end namespace Catch
-
-// #included from: catch_reporter_registry.hpp
-#define TWOBLUECUBES_CATCH_REPORTER_REGISTRY_HPP_INCLUDED
-
-#include <map>
-
-namespace Catch {
-
-    class ReporterRegistry : public IReporterRegistry {
-
-    public:
-
-        virtual ~ReporterRegistry() CATCH_OVERRIDE {}
-
-        virtual IStreamingReporter* create( std::string const& name, Ptr<IConfig const> const& config ) const CATCH_OVERRIDE {
-            FactoryMap::const_iterator it =  m_factories.find( name );
-            if( it == m_factories.end() )
-                return CATCH_NULL;
-            return it->second->create( ReporterConfig( config ) );
-        }
-
-        void registerReporter( std::string const& name, Ptr<IReporterFactory> const& factory ) {
-            m_factories.insert( std::make_pair( name, factory ) );
-        }
-        void registerListener( Ptr<IReporterFactory> const& factory ) {
-            m_listeners.push_back( factory );
-        }
-
-        virtual FactoryMap const& getFactories() const CATCH_OVERRIDE {
-            return m_factories;
-        }
-        virtual Listeners const& getListeners() const CATCH_OVERRIDE {
-            return m_listeners;
-        }
-
-    private:
-        FactoryMap m_factories;
-        Listeners m_listeners;
-    };
-}
-
-// #included from: catch_exception_translator_registry.hpp
-#define TWOBLUECUBES_CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED
-
-#ifdef __OBJC__
-#import "Foundation/Foundation.h"
-#endif
-
-namespace Catch {
-
-    class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry {
-    public:
-        ~ExceptionTranslatorRegistry() {
-            deleteAll( m_translators );
-        }
-
-        virtual void registerTranslator( const IExceptionTranslator* translator ) {
-            m_translators.push_back( translator );
-        }
-
-        virtual std::string translateActiveException() const {
-            try {
-#ifdef __OBJC__
-                // In Objective-C try objective-c exceptions first
-                @try {
-                    return tryTranslators();
-                }
-                @catch (NSException *exception) {
-                    return Catch::toString( [exception description] );
-                }
-#else
-                return tryTranslators();
-#endif
-            }
-            catch( TestFailureException& ) {
-                throw;
-            }
-            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 tryTranslators() const {
-            if( m_translators.empty() )
-                throw;
-            else
-                return m_translators[0]->translate( m_translators.begin()+1, m_translators.end() );
-        }
-
-    private:
-        std::vector<const IExceptionTranslator*> m_translators;
-    };
-}
-
-// #included from: catch_tag_alias_registry.h
-#define TWOBLUECUBES_CATCH_TAG_ALIAS_REGISTRY_H_INCLUDED
-
-#include <map>
-
-namespace Catch {
-
-    class TagAliasRegistry : public ITagAliasRegistry {
-    public:
-        virtual ~TagAliasRegistry();
-        virtual Option<TagAlias> find( std::string const& alias ) const;
-        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const;
-        void add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo );
-
-    private:
-        std::map<std::string, TagAlias> m_registry;
-    };
-
-} // end namespace Catch
-
-namespace Catch {
-
-    namespace {
-
-        class RegistryHub : public IRegistryHub, public IMutableRegistryHub {
-
-            RegistryHub( RegistryHub const& );
-            void operator=( RegistryHub const& );
-
-        public: // IRegistryHub
-            RegistryHub() {
-            }
-            virtual IReporterRegistry const& getReporterRegistry() const CATCH_OVERRIDE {
-                return m_reporterRegistry;
-            }
-            virtual ITestCaseRegistry const& getTestCaseRegistry() const CATCH_OVERRIDE {
-                return m_testCaseRegistry;
-            }
-            virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() CATCH_OVERRIDE {
-                return m_exceptionTranslatorRegistry;
-            }
-            virtual ITagAliasRegistry const& getTagAliasRegistry() const CATCH_OVERRIDE {
-                return m_tagAliasRegistry;
-            }
-
-        public: // IMutableRegistryHub
-            virtual void registerReporter( std::string const& name, Ptr<IReporterFactory> const& factory ) CATCH_OVERRIDE {
-                m_reporterRegistry.registerReporter( name, factory );
-            }
-            virtual void registerListener( Ptr<IReporterFactory> const& factory ) CATCH_OVERRIDE {
-                m_reporterRegistry.registerListener( factory );
-            }
-            virtual void registerTest( TestCase const& testInfo ) CATCH_OVERRIDE {
-                m_testCaseRegistry.registerTest( testInfo );
-            }
-            virtual void registerTranslator( const IExceptionTranslator* translator ) CATCH_OVERRIDE {
-                m_exceptionTranslatorRegistry.registerTranslator( translator );
-            }
-            virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) CATCH_OVERRIDE {
-                m_tagAliasRegistry.add( alias, tag, lineInfo );
-            }
-
-        private:
-            TestRegistry m_testCaseRegistry;
-            ReporterRegistry m_reporterRegistry;
-            ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
-            TagAliasRegistry m_tagAliasRegistry;
-        };
-
-        // Single, global, instance
-        inline RegistryHub*& getTheRegistryHub() {
-            static RegistryHub* theRegistryHub = CATCH_NULL;
-            if( !theRegistryHub )
-                theRegistryHub = new RegistryHub();
-            return theRegistryHub;
-        }
-    }
-
-    IRegistryHub& getRegistryHub() {
-        return *getTheRegistryHub();
-    }
-    IMutableRegistryHub& getMutableRegistryHub() {
-        return *getTheRegistryHub();
-    }
-    void cleanUp() {
-        delete getTheRegistryHub();
-        getTheRegistryHub() = CATCH_NULL;
-        cleanUpContext();
-    }
-    std::string translateActiveException() {
-        return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
-    }
-
-} // end namespace Catch
-
-// #included from: catch_notimplemented_exception.hpp
-#define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_HPP_INCLUDED
-
-#include <sstream>
-
-namespace Catch {
-
-    NotImplementedException::NotImplementedException( SourceLineInfo const& lineInfo )
-    :   m_lineInfo( lineInfo ) {
-        std::ostringstream oss;
-        oss << lineInfo << ": function ";
-        oss << "not implemented";
-        m_what = oss.str();
-    }
-
-    const char* NotImplementedException::what() const CATCH_NOEXCEPT {
-        return m_what.c_str();
-    }
-
-} // end namespace Catch
-
-// #included from: catch_context_impl.hpp
-#define TWOBLUECUBES_CATCH_CONTEXT_IMPL_HPP_INCLUDED
-
-// #included from: catch_stream.hpp
-#define TWOBLUECUBES_CATCH_STREAM_HPP_INCLUDED
-
-#include <stdexcept>
-#include <cstdio>
-#include <iostream>
-
-namespace Catch {
-
-    template<typename WriterF, size_t bufferSize=256>
-    class StreamBufImpl : public StreamBufBase {
-        char data[bufferSize];
-        WriterF m_writer;
-
-    public:
-        StreamBufImpl() {
-            setp( data, data + sizeof(data) );
-        }
-
-        ~StreamBufImpl() CATCH_NOEXCEPT {
-            sync();
-        }
-
-    private:
-        int overflow( int c ) {
-            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() {
-            if( pbase() != pptr() ) {
-                m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
-                setp( pbase(), epptr() );
-            }
-            return 0;
-        }
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    FileStream::FileStream( std::string const& filename ) {
-        m_ofs.open( filename.c_str() );
-        if( m_ofs.fail() ) {
-            std::ostringstream oss;
-            oss << "Unable to open file: '" << filename << '\'';
-            throw std::domain_error( oss.str() );
-        }
-    }
-
-    std::ostream& FileStream::stream() const {
-        return m_ofs;
-    }
-
-    struct OutputDebugWriter {
-
-        void operator()( std::string const&str ) {
-            writeToDebugConsole( str );
-        }
-    };
-
-    DebugOutStream::DebugOutStream()
-    :   m_streamBuf( new StreamBufImpl<OutputDebugWriter>() ),
-        m_os( m_streamBuf.get() )
-    {}
-
-    std::ostream& DebugOutStream::stream() const {
-        return m_os;
-    }
-
-    // Store the streambuf from cout up-front because
-    // cout may get redirected when running tests
-    CoutStream::CoutStream()
-    :   m_os( Catch::cout().rdbuf() )
-    {}
-
-    std::ostream& CoutStream::stream() const {
-        return m_os;
-    }
-
-#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
-}
-
-namespace Catch {
-
-    class Context : public IMutableContext {
-
-        Context() : m_config( CATCH_NULL ), m_runner( CATCH_NULL ), m_resultCapture( CATCH_NULL ) {}
-        Context( Context const& );
-        void operator=( Context const& );
-
-    public:
-        virtual ~Context() {
-            deleteAllValues( m_generatorsByTestName );
-        }
-
-    public: // IContext
-        virtual IResultCapture* getResultCapture() {
-            return m_resultCapture;
-        }
-        virtual IRunner* getRunner() {
-            return m_runner;
-        }
-        virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) {
-            return getGeneratorsForCurrentTest()
-            .getGeneratorInfo( fileInfo, totalSize )
-            .getCurrentIndex();
-        }
-        virtual bool advanceGeneratorsForCurrentTest() {
-            IGeneratorsForTest* generators = findGeneratorsForCurrentTest();
-            return generators && generators->moveNext();
-        }
-
-        virtual Ptr<IConfig const> getConfig() const {
-            return m_config;
-        }
-
-    public: // IMutableContext
-        virtual void setResultCapture( IResultCapture* resultCapture ) {
-            m_resultCapture = resultCapture;
-        }
-        virtual void setRunner( IRunner* runner ) {
-            m_runner = runner;
-        }
-        virtual void setConfig( Ptr<IConfig const> const& config ) {
-            m_config = config;
-        }
-
-        friend IMutableContext& getCurrentMutableContext();
-
-    private:
-        IGeneratorsForTest* findGeneratorsForCurrentTest() {
-            std::string testName = getResultCapture()->getCurrentTestName();
-
-            std::map<std::string, IGeneratorsForTest*>::const_iterator it =
-                m_generatorsByTestName.find( testName );
-            return it != m_generatorsByTestName.end()
-                ? it->second
-                : CATCH_NULL;
-        }
-
-        IGeneratorsForTest& getGeneratorsForCurrentTest() {
-            IGeneratorsForTest* generators = findGeneratorsForCurrentTest();
-            if( !generators ) {
-                std::string testName = getResultCapture()->getCurrentTestName();
-                generators = createGeneratorsForTest();
-                m_generatorsByTestName.insert( std::make_pair( testName, generators ) );
-            }
-            return *generators;
-        }
-
-    private:
-        Ptr<IConfig const> m_config;
-        IRunner* m_runner;
-        IResultCapture* m_resultCapture;
-        std::map<std::string, IGeneratorsForTest*> m_generatorsByTestName;
-    };
-
-    namespace {
-        Context* currentContext = CATCH_NULL;
-    }
-    IMutableContext& getCurrentMutableContext() {
-        if( !currentContext )
-            currentContext = new Context();
-        return *currentContext;
-    }
-    IContext& getCurrentContext() {
-        return getCurrentMutableContext();
-    }
-
-    void cleanUpContext() {
-        delete currentContext;
-        currentContext = CATCH_NULL;
-    }
-}
-
-// #included from: catch_console_colour_impl.hpp
-#define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_IMPL_HPP_INCLUDED
-
-// #included from: catch_errno_guard.hpp
-#define TWOBLUECUBES_CATCH_ERRNO_GUARD_HPP_INCLUDED
-
-#include <cerrno>
-
-namespace Catch {
-
-    class ErrnoGuard {
-    public:
-        ErrnoGuard():m_oldErrno(errno){}
-        ~ErrnoGuard() { errno = m_oldErrno; }
-    private:
-        int m_oldErrno;
-    };
-
-}
-
-namespace Catch {
-    namespace {
-
-        struct IColourImpl {
-            virtual ~IColourImpl() {}
-            virtual void use( Colour::Code _colourCode ) = 0;
-        };
-
-        struct NoColourImpl : IColourImpl {
-            void use( Colour::Code ) {}
-
-            static IColourImpl* instance() {
-                static NoColourImpl s_instance;
-                return &s_instance;
-            }
-        };
-
-    } // 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
-
-#if defined ( CATCH_CONFIG_COLOUR_WINDOWS ) /////////////////////////////////////////
-
-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 ) {
-            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: throw std::logic_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;
-
-        Ptr<IConfig const> config = getCurrentContext().getConfig();
-        UseColour::YesOrNo colourMode = config
-            ? config->useColour()
-            : UseColour::Auto;
-        if( colourMode == UseColour::Auto )
-            colourMode = !isDebuggerActive()
-                ? UseColour::Yes
-                : UseColour::No;
-        return colourMode == UseColour::Yes
-            ? &s_instance
-            : NoColourImpl::instance();
-    }
-
-} // end anon namespace
-} // end namespace Catch
-
-#elif defined( CATCH_CONFIG_COLOUR_ANSI ) //////////////////////////////////////
-
-#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 ) {
-            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: throw std::logic_error( "not a colour" );
-            }
-        }
-        static IColourImpl* instance() {
-            static PosixColourImpl s_instance;
-            return &s_instance;
-        }
-
-    private:
-        void setColour( const char* _escapeCode ) {
-            Catch::cout() << '\033' << _escapeCode;
-        }
-    };
-
-    IColourImpl* platformColourInstance() {
-        ErrnoGuard guard;
-        Ptr<IConfig const> config = getCurrentContext().getConfig();
-        UseColour::YesOrNo colourMode = config
-            ? config->useColour()
-            : UseColour::Auto;
-        if( colourMode == UseColour::Auto )
-            colourMode = (!isDebuggerActive() && isatty(STDOUT_FILENO) )
-                ? UseColour::Yes
-                : UseColour::No;
-        return colourMode == UseColour::Yes
-            ? PosixColourImpl::instance()
-            : NoColourImpl::instance();
-    }
-
-} // end anon namespace
-} // end namespace Catch
-
-#else  // not Windows or ANSI ///////////////////////////////////////////////
-
-namespace Catch {
-
-    static IColourImpl* platformColourInstance() { return NoColourImpl::instance(); }
-
-} // end namespace Catch
-
-#endif // Windows/ ANSI/ None
-
-namespace Catch {
-
-    Colour::Colour( Code _colourCode ) : m_moved( false ) { use( _colourCode ); }
-    Colour::Colour( Colour const& _other ) : m_moved( false ) { const_cast<Colour&>( _other ).m_moved = true; }
-    Colour::~Colour(){ if( !m_moved ) use( None ); }
-
-    void Colour::use( Code _colourCode ) {
-        static IColourImpl* impl = platformColourInstance();
-        impl->use( _colourCode );
-    }
-
-} // end namespace Catch
-
-// #included from: catch_generators_impl.hpp
-#define TWOBLUECUBES_CATCH_GENERATORS_IMPL_HPP_INCLUDED
-
-#include <vector>
-#include <string>
-#include <map>
-
-namespace Catch {
-
-    struct GeneratorInfo : IGeneratorInfo {
-
-        GeneratorInfo( std::size_t size )
-        :   m_size( size ),
-            m_currentIndex( 0 )
-        {}
-
-        bool moveNext() {
-            if( ++m_currentIndex == m_size ) {
-                m_currentIndex = 0;
-                return false;
-            }
-            return true;
-        }
-
-        std::size_t getCurrentIndex() const {
-            return m_currentIndex;
-        }
-
-        std::size_t m_size;
-        std::size_t m_currentIndex;
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    class GeneratorsForTest : public IGeneratorsForTest {
-
-    public:
-        ~GeneratorsForTest() {
-            deleteAll( m_generatorsInOrder );
-        }
-
-        IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) {
-            std::map<std::string, IGeneratorInfo*>::const_iterator it = m_generatorsByName.find( fileInfo );
-            if( it == m_generatorsByName.end() ) {
-                IGeneratorInfo* info = new GeneratorInfo( size );
-                m_generatorsByName.insert( std::make_pair( fileInfo, info ) );
-                m_generatorsInOrder.push_back( info );
-                return *info;
-            }
-            return *it->second;
-        }
-
-        bool moveNext() {
-            std::vector<IGeneratorInfo*>::const_iterator it = m_generatorsInOrder.begin();
-            std::vector<IGeneratorInfo*>::const_iterator itEnd = m_generatorsInOrder.end();
-            for(; it != itEnd; ++it ) {
-                if( (*it)->moveNext() )
-                    return true;
-            }
-            return false;
-        }
-
-    private:
-        std::map<std::string, IGeneratorInfo*> m_generatorsByName;
-        std::vector<IGeneratorInfo*> m_generatorsInOrder;
-    };
-
-    IGeneratorsForTest* createGeneratorsForTest()
-    {
-        return new GeneratorsForTest();
-    }
-
-} // end namespace Catch
-
-// #included from: catch_assertionresult.hpp
-#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_HPP_INCLUDED
-
-namespace Catch {
-
-    AssertionInfo::AssertionInfo():macroName(""), capturedExpression(""), resultDisposition(ResultDisposition::Normal), secondArg(""){}
-
-    AssertionInfo::AssertionInfo(   char const * _macroName,
-                                    SourceLineInfo const& _lineInfo,
-                                    char const * _capturedExpression,
-                                    ResultDisposition::Flags _resultDisposition,
-                                    char const * _secondArg)
-    :   macroName( _macroName ),
-        lineInfo( _lineInfo ),
-        capturedExpression( _capturedExpression ),
-        resultDisposition( _resultDisposition ),
-        secondArg( _secondArg )
-    {}
-
-    AssertionResult::AssertionResult() {}
-
-    AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
-    :   m_info( info ),
-        m_resultData( data )
-    {}
-
-    AssertionResult::~AssertionResult() {}
-
-    // 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 capturedExpressionWithSecondArgument( char const * capturedExpression, char const * secondArg ) {
-        return (secondArg[0] == 0 || secondArg[0] == '"' && secondArg[1] == '"')
-            ? capturedExpression
-            : std::string(capturedExpression) + ", " + secondArg;
-    }
-
-    std::string AssertionResult::getExpression() const {
-        if( isFalseTest( m_info.resultDisposition ) )
-            return "!(" + capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg) + ")";
-        else
-            return capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg);
-    }
-    std::string AssertionResult::getExpressionInMacro() const {
-        if( m_info.macroName[0] == 0 )
-            return capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg);
-        else
-            return std::string(m_info.macroName) + "( " + capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg) + " )";
-    }
-
-    bool AssertionResult::hasExpandedExpression() const {
-        return hasExpression() && getExpandedExpression() != getExpression();
-    }
-
-    std::string AssertionResult::getExpandedExpression() const {
-        return m_resultData.reconstructExpression();
-    }
-
-    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 AssertionResult::discardDecomposedExpression() const {
-        m_resultData.decomposedExpression = CATCH_NULL;
-    }
-
-    void AssertionResult::expandDecomposedExpression() const {
-        m_resultData.reconstructExpression();
-    }
-
-} // end namespace Catch
-
-// #included from: catch_test_case_info.hpp
-#define TWOBLUECUBES_CATCH_TEST_CASE_INFO_HPP_INCLUDED
-
-#include <cctype>
-
-namespace Catch {
-
-    inline TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
-        if( startsWith( tag, '.' ) ||
-            tag == "hide" ||
-            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
-            return TestCaseInfo::None;
-    }
-    inline bool isReservedTag( std::string const& tag ) {
-        return parseSpecialTag( tag ) == TestCaseInfo::None && tag.size() > 0 && !std::isalnum( tag[0] );
-    }
-    inline void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
-        if( isReservedTag( tag ) ) {
-            std::ostringstream ss;
-            ss << Colour(Colour::Red)
-               << "Tag name [" << tag << "] not allowed.\n"
-               << "Tag names starting with non alpha-numeric characters are reserved\n"
-               << Colour(Colour::FileName)
-               << _lineInfo << '\n';
-            throw std::runtime_error(ss.str());
-        }
-    }
-
-    TestCase makeTestCase(  ITestCase* _testCase,
-                            std::string const& _className,
-                            std::string const& _name,
-                            std::string const& _descOrTags,
-                            SourceLineInfo const& _lineInfo )
-    {
-        bool isHidden( startsWith( _name, "./" ) ); // Legacy support
-
-        // Parse out tags
-        std::set<std::string> tags;
-        std::string desc, tag;
-        bool inTag = false;
-        for( std::size_t i = 0; i < _descOrTags.size(); ++i ) {
-            char c = _descOrTags[i];
-            if( !inTag ) {
-                if( c == '[' )
-                    inTag = true;
-                else
-                    desc += c;
-            }
-            else {
-                if( c == ']' ) {
-                    TestCaseInfo::SpecialProperties prop = parseSpecialTag( tag );
-                    if( prop == TestCaseInfo::IsHidden )
-                        isHidden = true;
-                    else if( prop == TestCaseInfo::None )
-                        enforceNotReservedTag( tag, _lineInfo );
-
-                    tags.insert( tag );
-                    tag.clear();
-                    inTag = false;
-                }
-                else
-                    tag += c;
-            }
-        }
-        if( isHidden ) {
-            tags.insert( "hide" );
-            tags.insert( "." );
-        }
-
-        TestCaseInfo info( _name, _className, desc, tags, _lineInfo );
-        return TestCase( _testCase, info );
-    }
-
-    void setTags( TestCaseInfo& testCaseInfo, std::set<std::string> const& tags )
-    {
-        testCaseInfo.tags = tags;
-        testCaseInfo.lcaseTags.clear();
-
-        std::ostringstream oss;
-        for( std::set<std::string>::const_iterator it = tags.begin(), itEnd = tags.end(); it != itEnd; ++it ) {
-            oss << '[' << *it << ']';
-            std::string lcaseTag = toLower( *it );
-            testCaseInfo.properties = static_cast<TestCaseInfo::SpecialProperties>( testCaseInfo.properties | parseSpecialTag( lcaseTag ) );
-            testCaseInfo.lcaseTags.insert( lcaseTag );
-        }
-        testCaseInfo.tagsAsString = oss.str();
-    }
-
-    TestCaseInfo::TestCaseInfo( std::string const& _name,
-                                std::string const& _className,
-                                std::string const& _description,
-                                std::set<std::string> const& _tags,
-                                SourceLineInfo const& _lineInfo )
-    :   name( _name ),
-        className( _className ),
-        description( _description ),
-        lineInfo( _lineInfo ),
-        properties( None )
-    {
-        setTags( *this, _tags );
-    }
-
-    TestCaseInfo::TestCaseInfo( TestCaseInfo const& other )
-    :   name( other.name ),
-        className( other.className ),
-        description( other.description ),
-        tags( other.tags ),
-        lcaseTags( other.lcaseTags ),
-        tagsAsString( other.tagsAsString ),
-        lineInfo( other.lineInfo ),
-        properties( other.properties )
-    {}
-
-    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;
-    }
-
-    TestCase::TestCase( ITestCase* testCase, TestCaseInfo const& info ) : TestCaseInfo( info ), test( testCase ) {}
-
-    TestCase::TestCase( TestCase const& other )
-    :   TestCaseInfo( other ),
-        test( other.test )
-    {}
-
-    TestCase TestCase::withName( std::string const& _newName ) const {
-        TestCase other( *this );
-        other.name = _newName;
-        return other;
-    }
-
-    void TestCase::swap( TestCase& other ) {
-        test.swap( other.test );
-        name.swap( other.name );
-        className.swap( other.className );
-        description.swap( other.description );
-        tags.swap( other.tags );
-        lcaseTags.swap( other.lcaseTags );
-        tagsAsString.swap( other.tagsAsString );
-        std::swap( TestCaseInfo::properties, static_cast<TestCaseInfo&>( other ).properties );
-        std::swap( lineInfo, other.lineInfo );
-    }
-
-    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;
-    }
-    TestCase& TestCase::operator = ( TestCase const& other ) {
-        TestCase temp( other );
-        swap( temp );
-        return *this;
-    }
-
-    TestCaseInfo const& TestCase::getTestCaseInfo() const
-    {
-        return *this;
-    }
-
-} // end namespace Catch
-
-// #included from: catch_version.hpp
-#define TWOBLUECUBES_CATCH_VERSION_HPP_INCLUDED
-
-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;
-    }
-
-    inline Version libraryVersion() {
-        static Version version( 1, 12, 2, "", 0 );
-        return version;
-    }
-
-}
-
-// #included from: catch_message.hpp
-#define TWOBLUECUBES_CATCH_MESSAGE_HPP_INCLUDED
-
-namespace Catch {
-
-    MessageInfo::MessageInfo(   std::string const& _macroName,
-                                SourceLineInfo const& _lineInfo,
-                                ResultWas::OfType _type )
-    :   macroName( _macroName ),
-        lineInfo( _lineInfo ),
-        type( _type ),
-        sequence( ++globalCount )
-    {}
-
-    // This may need protecting if threading support is added
-    unsigned int MessageInfo::globalCount = 0;
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    ScopedMessage::ScopedMessage( MessageBuilder const& builder )
-    : m_info( builder.m_info )
-    {
-        m_info.message = builder.m_stream.str();
-        getResultCapture().pushScopedMessage( m_info );
-    }
-    ScopedMessage::ScopedMessage( ScopedMessage const& other )
-    : m_info( other.m_info )
-    {}
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4996) // std::uncaught_exception is deprecated in C++17
-#endif
-    ScopedMessage::~ScopedMessage() {
-        if ( !std::uncaught_exception() ){
-            getResultCapture().popScopedMessage(m_info);
-        }
-    }
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-
-} // end namespace Catch
-
-// #included from: catch_legacy_reporter_adapter.hpp
-#define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_HPP_INCLUDED
-
-// #included from: catch_legacy_reporter_adapter.h
-#define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_H_INCLUDED
-
-namespace Catch
-{
-    // Deprecated
-    struct IReporter : IShared {
-        virtual ~IReporter();
-
-        virtual bool shouldRedirectStdout() const = 0;
-
-        virtual void StartTesting() = 0;
-        virtual void EndTesting( Totals const& totals ) = 0;
-        virtual void StartGroup( std::string const& groupName ) = 0;
-        virtual void EndGroup( std::string const& groupName, Totals const& totals ) = 0;
-        virtual void StartTestCase( TestCaseInfo const& testInfo ) = 0;
-        virtual void EndTestCase( TestCaseInfo const& testInfo, Totals const& totals, std::string const& stdOut, std::string const& stdErr ) = 0;
-        virtual void StartSection( std::string const& sectionName, std::string const& description ) = 0;
-        virtual void EndSection( std::string const& sectionName, Counts const& assertions ) = 0;
-        virtual void NoAssertionsInSection( std::string const& sectionName ) = 0;
-        virtual void NoAssertionsInTestCase( std::string const& testName ) = 0;
-        virtual void Aborted() = 0;
-        virtual void Result( AssertionResult const& result ) = 0;
-    };
-
-    class LegacyReporterAdapter : public SharedImpl<IStreamingReporter>
-    {
-    public:
-        LegacyReporterAdapter( Ptr<IReporter> const& legacyReporter );
-        virtual ~LegacyReporterAdapter();
-
-        virtual ReporterPreferences getPreferences() const;
-        virtual void noMatchingTestCases( std::string const& );
-        virtual void testRunStarting( TestRunInfo const& );
-        virtual void testGroupStarting( GroupInfo const& groupInfo );
-        virtual void testCaseStarting( TestCaseInfo const& testInfo );
-        virtual void sectionStarting( SectionInfo const& sectionInfo );
-        virtual void assertionStarting( AssertionInfo const& );
-        virtual bool assertionEnded( AssertionStats const& assertionStats );
-        virtual void sectionEnded( SectionStats const& sectionStats );
-        virtual void testCaseEnded( TestCaseStats const& testCaseStats );
-        virtual void testGroupEnded( TestGroupStats const& testGroupStats );
-        virtual void testRunEnded( TestRunStats const& testRunStats );
-        virtual void skipTest( TestCaseInfo const& );
-
-    private:
-        Ptr<IReporter> m_legacyReporter;
-    };
-}
-
-namespace Catch
-{
-    LegacyReporterAdapter::LegacyReporterAdapter( Ptr<IReporter> const& legacyReporter )
-    :   m_legacyReporter( legacyReporter )
-    {}
-    LegacyReporterAdapter::~LegacyReporterAdapter() {}
-
-    ReporterPreferences LegacyReporterAdapter::getPreferences() const {
-        ReporterPreferences prefs;
-        prefs.shouldRedirectStdOut = m_legacyReporter->shouldRedirectStdout();
-        return prefs;
-    }
-
-    void LegacyReporterAdapter::noMatchingTestCases( std::string const& ) {}
-    void LegacyReporterAdapter::testRunStarting( TestRunInfo const& ) {
-        m_legacyReporter->StartTesting();
-    }
-    void LegacyReporterAdapter::testGroupStarting( GroupInfo const& groupInfo ) {
-        m_legacyReporter->StartGroup( groupInfo.name );
-    }
-    void LegacyReporterAdapter::testCaseStarting( TestCaseInfo const& testInfo ) {
-        m_legacyReporter->StartTestCase( testInfo );
-    }
-    void LegacyReporterAdapter::sectionStarting( SectionInfo const& sectionInfo ) {
-        m_legacyReporter->StartSection( sectionInfo.name, sectionInfo.description );
-    }
-    void LegacyReporterAdapter::assertionStarting( AssertionInfo const& ) {
-        // Not on legacy interface
-    }
-
-    bool LegacyReporterAdapter::assertionEnded( AssertionStats const& assertionStats ) {
-        if( assertionStats.assertionResult.getResultType() != ResultWas::Ok ) {
-            for( std::vector<MessageInfo>::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end();
-                    it != itEnd;
-                    ++it ) {
-                if( it->type == ResultWas::Info ) {
-                    ResultBuilder rb( it->macroName.c_str(), it->lineInfo, "", ResultDisposition::Normal );
-                    rb << it->message;
-                    rb.setResultType( ResultWas::Info );
-                    AssertionResult result = rb.build();
-                    m_legacyReporter->Result( result );
-                }
-            }
-        }
-        m_legacyReporter->Result( assertionStats.assertionResult );
-        return true;
-    }
-    void LegacyReporterAdapter::sectionEnded( SectionStats const& sectionStats ) {
-        if( sectionStats.missingAssertions )
-            m_legacyReporter->NoAssertionsInSection( sectionStats.sectionInfo.name );
-        m_legacyReporter->EndSection( sectionStats.sectionInfo.name, sectionStats.assertions );
-    }
-    void LegacyReporterAdapter::testCaseEnded( TestCaseStats const& testCaseStats ) {
-        m_legacyReporter->EndTestCase
-            (   testCaseStats.testInfo,
-                testCaseStats.totals,
-                testCaseStats.stdOut,
-                testCaseStats.stdErr );
-    }
-    void LegacyReporterAdapter::testGroupEnded( TestGroupStats const& testGroupStats ) {
-        if( testGroupStats.aborting )
-            m_legacyReporter->Aborted();
-        m_legacyReporter->EndGroup( testGroupStats.groupInfo.name, testGroupStats.totals );
-    }
-    void LegacyReporterAdapter::testRunEnded( TestRunStats const& testRunStats ) {
-        m_legacyReporter->EndTesting( testRunStats.totals );
-    }
-    void LegacyReporterAdapter::skipTest( TestCaseInfo const& ) {
-    }
-}
-
-// #included from: catch_timer.hpp
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wc++11-long-long"
-#endif
-
-#ifdef CATCH_PLATFORM_WINDOWS
-
-#else
-
-#include <sys/time.h>
-
-#endif
-
-namespace Catch {
-
-    namespace {
-#ifdef CATCH_PLATFORM_WINDOWS
-        UInt64 getCurrentTicks() {
-            static UInt64 hz=0, hzo=0;
-            if (!hz) {
-                QueryPerformanceFrequency( reinterpret_cast<LARGE_INTEGER*>( &hz ) );
-                QueryPerformanceCounter( reinterpret_cast<LARGE_INTEGER*>( &hzo ) );
-            }
-            UInt64 t;
-            QueryPerformanceCounter( reinterpret_cast<LARGE_INTEGER*>( &t ) );
-            return ((t-hzo)*1000000)/hz;
-        }
-#else
-        UInt64 getCurrentTicks() {
-            timeval t;
-            gettimeofday(&t,CATCH_NULL);
-            return static_cast<UInt64>( t.tv_sec ) * 1000000ull + static_cast<UInt64>( t.tv_usec );
-        }
-#endif
-    }
-
-    void Timer::start() {
-        m_ticks = getCurrentTicks();
-    }
-    unsigned int Timer::getElapsedMicroseconds() const {
-        return static_cast<unsigned int>(getCurrentTicks() - m_ticks);
-    }
-    unsigned int Timer::getElapsedMilliseconds() const {
-        return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
-    }
-    double Timer::getElapsedSeconds() const {
-        return getElapsedMicroseconds()/1000000.0;
-    }
-
-} // namespace Catch
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-// #included from: catch_common.hpp
-#define TWOBLUECUBES_CATCH_COMMON_HPP_INCLUDED
-
-#include <cstring>
-#include <cctype>
-
-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;
-    }
-
-    SourceLineInfo::SourceLineInfo() : file(""), line( 0 ){}
-    SourceLineInfo::SourceLineInfo( char const* _file, std::size_t _line )
-    :   file( _file ),
-        line( _line )
-    {}
-    bool SourceLineInfo::empty() const {
-        return file[0] == '\0';
-    }
-    bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const {
-        return line == other.line && (file == other.file || std::strcmp(file, other.file) == 0);
-    }
-    bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const {
-        return line < other.line || ( line == other.line && (std::strcmp(file, other.file) < 0));
-    }
-
-    void seedRng( IConfig const& config ) {
-        if( config.rngSeed() != 0 )
-            std::srand( config.rngSeed() );
-    }
-    unsigned int rngSeed() {
-        return getCurrentContext().getConfig()->rngSeed();
-    }
-
-    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;
-    }
-
-    void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo ) {
-        std::ostringstream oss;
-        oss << locationInfo << ": Internal Catch error: '" << message << '\'';
-        if( alwaysTrue() )
-            throw std::logic_error( oss.str() );
-    }
-}
-
-// #included from: catch_section.hpp
-#define TWOBLUECUBES_CATCH_SECTION_HPP_INCLUDED
-
-namespace Catch {
-
-    SectionInfo::SectionInfo
-        (   SourceLineInfo const& _lineInfo,
-            std::string const& _name,
-            std::string const& _description )
-    :   name( _name ),
-        description( _description ),
-        lineInfo( _lineInfo )
-    {}
-
-    Section::Section( SectionInfo const& info )
-    :   m_info( info ),
-        m_sectionIncluded( getResultCapture().sectionStarted( m_info, m_assertions ) )
-    {
-        m_timer.start();
-    }
-
-#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
-
-    // This indicates whether the section should be executed or not
-    Section::operator bool() const {
-        return m_sectionIncluded;
-    }
-
-} // end namespace Catch
-
-// #included from: catch_debugger.hpp
-#define TWOBLUECUBES_CATCH_DEBUGGER_HPP_INCLUDED
-
-#ifdef CATCH_PLATFORM_MAC
-
-    #include <assert.h>
-    #include <stdbool.h>
-    #include <sys/types.h>
-    #include <unistd.h>
-    #include <sys/sysctl.h>
-
-    namespace Catch{
-
-        // 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(){
-
-            int                 mib[4];
-            struct kinfo_proc   info;
-            size_t              size;
-
-            // Initialize the flags so that, if sysctl fails for some bizarre
-            // reason, we get a predictable result.
-
-            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.
-
-            mib[0] = CTL_KERN;
-            mib[1] = KERN_PROC;
-            mib[2] = KERN_PROC_PID;
-            mib[3] = getpid();
-
-            // Call sysctl.
-
-            size = sizeof(info);
-            if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, CATCH_NULL, 0) != 0 ) {
-                Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n" << std::endl;
-                return false;
-            }
-
-            // We're being debugged if the P_TRACED flag is set.
-
-            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 {
-       inline bool isDebuggerActive() { return false; }
-    }
-#endif // Platform
-
-#ifdef CATCH_PLATFORM_WINDOWS
-
-    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
-
-// #included from: catch_tostring.hpp
-#define TWOBLUECUBES_CATCH_TOSTRING_HPP_INCLUDED
-
-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);
-        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();
-    }
-}
-
-std::string toString( std::string const& value ) {
-    std::string s = value;
-    if( getCurrentContext().getConfig()->showInvisibles() ) {
-        for(size_t i = 0; i < s.size(); ++i ) {
-            std::string subs;
-            switch( s[i] ) {
-            case '\n': subs = "\\n"; break;
-            case '\t': subs = "\\t"; break;
-            default: break;
-            }
-            if( !subs.empty() ) {
-                s = s.substr( 0, i ) + subs + s.substr( i+1 );
-                ++i;
-            }
-        }
-    }
-    return '"' + s + '"';
-}
-std::string toString( std::wstring const& value ) {
-
-    std::string s;
-    s.reserve( value.size() );
-    for(size_t i = 0; i < value.size(); ++i )
-        s += value[i] <= 0xff ? static_cast<char>( value[i] ) : '?';
-    return Catch::toString( s );
-}
-
-std::string toString( const char* const value ) {
-    return value ? Catch::toString( std::string( value ) ) : std::string( "{null string}" );
-}
-
-std::string toString( char* const value ) {
-    return Catch::toString( static_cast<const char*>( value ) );
-}
-
-std::string toString( const wchar_t* const value )
-{
-    return value ? Catch::toString( std::wstring(value) ) : std::string( "{null string}" );
-}
-
-std::string toString( wchar_t* const value )
-{
-    return Catch::toString( static_cast<const wchar_t*>( value ) );
-}
-
-std::string toString( int value ) {
-    std::ostringstream oss;
-    oss << value;
-    if( value > Detail::hexThreshold )
-        oss << " (0x" << std::hex << value << ')';
-    return oss.str();
-}
-
-std::string toString( unsigned long value ) {
-    std::ostringstream oss;
-    oss << value;
-    if( value > Detail::hexThreshold )
-        oss << " (0x" << std::hex << value << ')';
-    return oss.str();
-}
-
-std::string toString( unsigned int value ) {
-    return Catch::toString( static_cast<unsigned long>( value ) );
-}
-
-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;
-}
-
-std::string toString( const double value ) {
-    return fpToString( value, 10 );
-}
-std::string toString( const float value ) {
-    return fpToString( value, 5 ) + 'f';
-}
-
-std::string toString( bool value ) {
-    return value ? "true" : "false";
-}
-
-std::string toString( char value ) {
-    if ( value == '\r' )
-        return "'\\r'";
-    if ( value == '\f' )
-        return "'\\f'";
-    if ( value == '\n' )
-        return "'\\n'";
-    if ( value == '\t' )
-        return "'\\t'";
-    if ( '\0' <= value && value < ' ' )
-        return toString( static_cast<unsigned int>( value ) );
-    char chstr[] = "' '";
-    chstr[1] = value;
-    return chstr;
-}
-
-std::string toString( signed char value ) {
-    return toString( static_cast<char>( value ) );
-}
-
-std::string toString( unsigned char value ) {
-    return toString( static_cast<char>( value ) );
-}
-
-#ifdef CATCH_CONFIG_CPP11_LONG_LONG
-std::string toString( long long value ) {
-    std::ostringstream oss;
-    oss << value;
-    if( value > Detail::hexThreshold )
-        oss << " (0x" << std::hex << value << ')';
-    return oss.str();
-}
-std::string toString( unsigned long long value ) {
-    std::ostringstream oss;
-    oss << value;
-    if( value > Detail::hexThreshold )
-        oss << " (0x" << std::hex << value << ')';
-    return oss.str();
-}
-#endif
-
-#ifdef CATCH_CONFIG_CPP11_NULLPTR
-std::string toString( std::nullptr_t ) {
-    return "nullptr";
-}
-#endif
-
-#ifdef __OBJC__
-    std::string toString( NSString const * const& nsstring ) {
-        if( !nsstring )
-            return "nil";
-        return "@" + toString([nsstring UTF8String]);
-    }
-    std::string toString( NSString * CATCH_ARC_STRONG & nsstring ) {
-        if( !nsstring )
-            return "nil";
-        return "@" + toString([nsstring UTF8String]);
-    }
-    std::string toString( NSObject* const& nsObject ) {
-        return toString( [nsObject description] );
-    }
-#endif
-
-} // end namespace Catch
-
-// #included from: catch_result_builder.hpp
-#define TWOBLUECUBES_CATCH_RESULT_BUILDER_HPP_INCLUDED
-
-#include <cassert>
-
-namespace Catch {
-
-    ResultBuilder::ResultBuilder(   char const* macroName,
-                                    SourceLineInfo const& lineInfo,
-                                    char const* capturedExpression,
-                                    ResultDisposition::Flags resultDisposition,
-                                    char const* secondArg )
-    :   m_assertionInfo( macroName, lineInfo, capturedExpression, resultDisposition, secondArg ),
-        m_shouldDebugBreak( false ),
-        m_shouldThrow( false ),
-        m_guardException( false ),
-        m_usedStream( false )
-    {}
-
-    ResultBuilder::~ResultBuilder() {
-#if defined(CATCH_CONFIG_FAST_COMPILE)
-        if ( m_guardException ) {
-            stream().oss << "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE";
-            captureResult( ResultWas::ThrewException );
-            getCurrentContext().getResultCapture()->exceptionEarlyReported();
-        }
-#endif
-    }
-
-    ResultBuilder& ResultBuilder::setResultType( ResultWas::OfType result ) {
-        m_data.resultType = result;
-        return *this;
-    }
-    ResultBuilder& ResultBuilder::setResultType( bool result ) {
-        m_data.resultType = result ? ResultWas::Ok : ResultWas::ExpressionFailed;
-        return *this;
-    }
-
-    void ResultBuilder::endExpression( DecomposedExpression const& expr ) {
-        // Flip bool results if FalseTest flag is set
-        if( isFalseTest( m_assertionInfo.resultDisposition ) ) {
-            m_data.negate( expr.isBinaryExpression() );
-        }
-
-        getResultCapture().assertionRun();
-
-        if(getCurrentContext().getConfig()->includeSuccessfulResults() || m_data.resultType != ResultWas::Ok)
-        {
-            AssertionResult result = build( expr );
-            handleResult( result );
-        }
-        else
-            getResultCapture().assertionPassed();
-    }
-
-    void ResultBuilder::useActiveException( ResultDisposition::Flags resultDisposition ) {
-        m_assertionInfo.resultDisposition = resultDisposition;
-        stream().oss << Catch::translateActiveException();
-        captureResult( ResultWas::ThrewException );
-    }
-
-    void ResultBuilder::captureResult( ResultWas::OfType resultType ) {
-        setResultType( resultType );
-        captureExpression();
-    }
-
-    void ResultBuilder::captureExpectedException( std::string const& expectedMessage ) {
-        if( expectedMessage.empty() )
-            captureExpectedException( Matchers::Impl::MatchAllOf<std::string>() );
-        else
-            captureExpectedException( Matchers::Equals( expectedMessage ) );
-    }
-
-    void ResultBuilder::captureExpectedException( Matchers::Impl::MatcherBase<std::string> const& matcher ) {
-
-        assert( !isFalseTest( m_assertionInfo.resultDisposition ) );
-        AssertionResultData data = m_data;
-        data.resultType = ResultWas::Ok;
-        data.reconstructedExpression = capturedExpressionWithSecondArgument(m_assertionInfo.capturedExpression, m_assertionInfo.secondArg);
-
-        std::string actualMessage = Catch::translateActiveException();
-        if( !matcher.match( actualMessage ) ) {
-            data.resultType = ResultWas::ExpressionFailed;
-            data.reconstructedExpression = actualMessage;
-        }
-        AssertionResult result( m_assertionInfo, data );
-        handleResult( result );
-    }
-
-    void ResultBuilder::captureExpression() {
-        AssertionResult result = build();
-        handleResult( result );
-    }
-
-    void ResultBuilder::handleResult( AssertionResult const& result )
-    {
-        getResultCapture().assertionEnded( result );
-
-        if( !result.isOk() ) {
-            if( getCurrentContext().getConfig()->shouldDebugBreak() )
-                m_shouldDebugBreak = true;
-            if( getCurrentContext().getRunner()->aborting() || (m_assertionInfo.resultDisposition & ResultDisposition::Normal) )
-                m_shouldThrow = true;
-        }
-    }
-
-    void ResultBuilder::react() {
-#if defined(CATCH_CONFIG_FAST_COMPILE)
-        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 throw statement
-            ///////////////////////////////////////////////////////////////////
-            CATCH_BREAK_INTO_DEBUGGER();
-        }
-#endif
-        if( m_shouldThrow )
-            throw Catch::TestFailureException();
-    }
-
-    bool ResultBuilder::shouldDebugBreak() const { return m_shouldDebugBreak; }
-    bool ResultBuilder::allowThrows() const { return getCurrentContext().getConfig()->allowThrows(); }
-
-    AssertionResult ResultBuilder::build() const
-    {
-        return build( *this );
-    }
-
-    // CAVEAT: The returned AssertionResult stores a pointer to the argument expr,
-    //         a temporary DecomposedExpression, which in turn holds references to
-    //         operands, possibly temporary as well.
-    //         It should immediately be passed to handleResult; if the expression
-    //         needs to be reported, its string expansion must be composed before
-    //         the temporaries are destroyed.
-    AssertionResult ResultBuilder::build( DecomposedExpression const& expr ) const
-    {
-        assert( m_data.resultType != ResultWas::Unknown );
-        AssertionResultData data = m_data;
-
-        if(m_usedStream)
-            data.message = m_stream().oss.str();
-        data.decomposedExpression = &expr; // for lazy reconstruction
-        return AssertionResult( m_assertionInfo, data );
-    }
-
-    void ResultBuilder::reconstructExpression( std::string& dest ) const {
-        dest = capturedExpressionWithSecondArgument(m_assertionInfo.capturedExpression, m_assertionInfo.secondArg);
-    }
-
-    void ResultBuilder::setExceptionGuard() {
-        m_guardException = true;
-    }
-    void ResultBuilder::unsetExceptionGuard() {
-        m_guardException = false;
-    }
-
-} // end namespace Catch
-
-// #included from: catch_tag_alias_registry.hpp
-#define TWOBLUECUBES_CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED
-
-namespace Catch {
-
-    TagAliasRegistry::~TagAliasRegistry() {}
-
-    Option<TagAlias> TagAliasRegistry::find( std::string const& alias ) const {
-        std::map<std::string, TagAlias>::const_iterator it = m_registry.find( alias );
-        if( it != m_registry.end() )
-            return it->second;
-        else
-            return Option<TagAlias>();
-    }
-
-    std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
-        std::string expandedTestSpec = unexpandedTestSpec;
-        for( std::map<std::string, TagAlias>::const_iterator it = m_registry.begin(), itEnd = m_registry.end();
-                it != itEnd;
-                ++it ) {
-            std::size_t pos = expandedTestSpec.find( it->first );
-            if( pos != std::string::npos ) {
-                expandedTestSpec =  expandedTestSpec.substr( 0, pos ) +
-                                    it->second.tag +
-                                    expandedTestSpec.substr( pos + it->first.size() );
-            }
-        }
-        return expandedTestSpec;
-    }
-
-    void TagAliasRegistry::add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) {
-
-        if( !startsWith( alias, "[@" ) || !endsWith( alias, ']' ) ) {
-            std::ostringstream oss;
-            oss << Colour( Colour::Red )
-                << "error: tag alias, \"" << alias << "\" is not of the form [@alias name].\n"
-                << Colour( Colour::FileName )
-                << lineInfo << '\n';
-            throw std::domain_error( oss.str().c_str() );
-        }
-        if( !m_registry.insert( std::make_pair( alias, TagAlias( tag, lineInfo ) ) ).second ) {
-            std::ostringstream oss;
-            oss << Colour( Colour::Red )
-                << "error: tag alias, \"" << alias << "\" already registered.\n"
-                << "\tFirst seen at "
-                << Colour( Colour::Red ) << find(alias)->lineInfo << '\n'
-                << Colour( Colour::Red ) << "\tRedefined at "
-                << Colour( Colour::FileName) << lineInfo << '\n';
-            throw std::domain_error( oss.str().c_str() );
-        }
-    }
-
-    ITagAliasRegistry::~ITagAliasRegistry() {}
-
-    ITagAliasRegistry const& ITagAliasRegistry::get() {
-        return getRegistryHub().getTagAliasRegistry();
-    }
-
-    RegistrarForTagAliases::RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo ) {
-        getMutableRegistryHub().registerTagAlias( alias, tag, lineInfo );
-    }
-
-} // end namespace Catch
-
-// #included from: catch_matchers_string.hpp
-
-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
-// #included from: ../reporters/catch_reporter_multi.hpp
-#define TWOBLUECUBES_CATCH_REPORTER_MULTI_HPP_INCLUDED
-
-namespace Catch {
-
-class MultipleReporters : public SharedImpl<IStreamingReporter> {
-    typedef std::vector<Ptr<IStreamingReporter> > Reporters;
-    Reporters m_reporters;
-
-public:
-    void add( Ptr<IStreamingReporter> const& reporter ) {
-        m_reporters.push_back( reporter );
-    }
-
-public: // IStreamingReporter
-
-    virtual ReporterPreferences getPreferences() const CATCH_OVERRIDE {
-        return m_reporters[0]->getPreferences();
-    }
-
-    virtual void noMatchingTestCases( std::string const& spec ) CATCH_OVERRIDE {
-        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
-                it != itEnd;
-                ++it )
-            (*it)->noMatchingTestCases( spec );
-    }
-
-    virtual void testRunStarting( TestRunInfo const& testRunInfo ) CATCH_OVERRIDE {
-        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
-                it != itEnd;
-                ++it )
-            (*it)->testRunStarting( testRunInfo );
-    }
-
-    virtual void testGroupStarting( GroupInfo const& groupInfo ) CATCH_OVERRIDE {
-        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
-                it != itEnd;
-                ++it )
-            (*it)->testGroupStarting( groupInfo );
-    }
-
-    virtual void testCaseStarting( TestCaseInfo const& testInfo ) CATCH_OVERRIDE {
-        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
-                it != itEnd;
-                ++it )
-            (*it)->testCaseStarting( testInfo );
-    }
-
-    virtual void sectionStarting( SectionInfo const& sectionInfo ) CATCH_OVERRIDE {
-        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
-                it != itEnd;
-                ++it )
-            (*it)->sectionStarting( sectionInfo );
-    }
-
-    virtual void assertionStarting( AssertionInfo const& assertionInfo ) CATCH_OVERRIDE {
-        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
-                it != itEnd;
-                ++it )
-            (*it)->assertionStarting( assertionInfo );
-    }
-
-    // The return value indicates if the messages buffer should be cleared:
-    virtual bool assertionEnded( AssertionStats const& assertionStats ) CATCH_OVERRIDE {
-        bool clearBuffer = false;
-        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
-                it != itEnd;
-                ++it )
-            clearBuffer |= (*it)->assertionEnded( assertionStats );
-        return clearBuffer;
-    }
-
-    virtual void sectionEnded( SectionStats const& sectionStats ) CATCH_OVERRIDE {
-        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
-                it != itEnd;
-                ++it )
-            (*it)->sectionEnded( sectionStats );
-    }
-
-    virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE {
-        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
-                it != itEnd;
-                ++it )
-            (*it)->testCaseEnded( testCaseStats );
-    }
-
-    virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE {
-        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
-                it != itEnd;
-                ++it )
-            (*it)->testGroupEnded( testGroupStats );
-    }
-
-    virtual void testRunEnded( TestRunStats const& testRunStats ) CATCH_OVERRIDE {
-        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
-                it != itEnd;
-                ++it )
-            (*it)->testRunEnded( testRunStats );
-    }
-
-    virtual void skipTest( TestCaseInfo const& testInfo ) CATCH_OVERRIDE {
-        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
-                it != itEnd;
-                ++it )
-            (*it)->skipTest( testInfo );
-    }
-
-    virtual MultipleReporters* tryAsMulti() CATCH_OVERRIDE {
-        return this;
-    }
-
-};
-
-Ptr<IStreamingReporter> addReporter( Ptr<IStreamingReporter> const& existingReporter, Ptr<IStreamingReporter> const& additionalReporter ) {
-    Ptr<IStreamingReporter> resultingReporter;
-
-    if( existingReporter ) {
-        MultipleReporters* multi = existingReporter->tryAsMulti();
-        if( !multi ) {
-            multi = new MultipleReporters;
-            resultingReporter = Ptr<IStreamingReporter>( multi );
-            if( existingReporter )
-                multi->add( existingReporter );
-        }
-        else
-            resultingReporter = existingReporter;
-        multi->add( additionalReporter );
-    }
-    else
-        resultingReporter = additionalReporter;
-
-    return resultingReporter;
-}
-
-} // end namespace Catch
-
-// #included from: ../reporters/catch_reporter_xml.hpp
-#define TWOBLUECUBES_CATCH_REPORTER_XML_HPP_INCLUDED
-
-// #included from: catch_reporter_bases.hpp
-#define TWOBLUECUBES_CATCH_REPORTER_BASES_HPP_INCLUDED
-
-#include <cstring>
-#include <cfloat>
-#include <cstdio>
-#include <assert.h>
-
-namespace Catch {
-
-    namespace {
-        // 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 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);
-        }
-    }
-
-    struct StreamingReporterBase : SharedImpl<IStreamingReporter> {
-
-        StreamingReporterBase( ReporterConfig const& _config )
-        :   m_config( _config.fullConfig() ),
-            stream( _config.stream() )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = false;
-        }
-
-        virtual ReporterPreferences getPreferences() const CATCH_OVERRIDE {
-            return m_reporterPrefs;
-        }
-
-        virtual ~StreamingReporterBase() CATCH_OVERRIDE;
-
-        virtual void noMatchingTestCases( std::string const& ) CATCH_OVERRIDE {}
-
-        virtual void testRunStarting( TestRunInfo const& _testRunInfo ) CATCH_OVERRIDE {
-            currentTestRunInfo = _testRunInfo;
-        }
-        virtual void testGroupStarting( GroupInfo const& _groupInfo ) CATCH_OVERRIDE {
-            currentGroupInfo = _groupInfo;
-        }
-
-        virtual void testCaseStarting( TestCaseInfo const& _testInfo ) CATCH_OVERRIDE {
-            currentTestCaseInfo = _testInfo;
-        }
-        virtual void sectionStarting( SectionInfo const& _sectionInfo ) CATCH_OVERRIDE {
-            m_sectionStack.push_back( _sectionInfo );
-        }
-
-        virtual void sectionEnded( SectionStats const& /* _sectionStats */ ) CATCH_OVERRIDE {
-            m_sectionStack.pop_back();
-        }
-        virtual void testCaseEnded( TestCaseStats const& /* _testCaseStats */ ) CATCH_OVERRIDE {
-            currentTestCaseInfo.reset();
-        }
-        virtual void testGroupEnded( TestGroupStats const& /* _testGroupStats */ ) CATCH_OVERRIDE {
-            currentGroupInfo.reset();
-        }
-        virtual void testRunEnded( TestRunStats const& /* _testRunStats */ ) CATCH_OVERRIDE {
-            currentTestCaseInfo.reset();
-            currentGroupInfo.reset();
-            currentTestRunInfo.reset();
-        }
-
-        virtual void skipTest( TestCaseInfo const& ) CATCH_OVERRIDE {
-            // Don't do anything with this by default.
-            // It can optionally be overridden in the derived class.
-        }
-
-        Ptr<IConfig const> m_config;
-        std::ostream& stream;
-
-        LazyStat<TestRunInfo> currentTestRunInfo;
-        LazyStat<GroupInfo> currentGroupInfo;
-        LazyStat<TestCaseInfo> currentTestCaseInfo;
-
-        std::vector<SectionInfo> m_sectionStack;
-        ReporterPreferences m_reporterPrefs;
-    };
-
-    struct CumulativeReporterBase : SharedImpl<IStreamingReporter> {
-        template<typename T, typename ChildNodeT>
-        struct Node : SharedImpl<> {
-            explicit Node( T const& _value ) : value( _value ) {}
-            virtual ~Node() {}
-
-            typedef std::vector<Ptr<ChildNodeT> > ChildNodes;
-            T value;
-            ChildNodes children;
-        };
-        struct SectionNode : SharedImpl<> {
-            explicit SectionNode( SectionStats const& _stats ) : stats( _stats ) {}
-            virtual ~SectionNode();
-
-            bool operator == ( SectionNode const& other ) const {
-                return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
-            }
-            bool operator == ( Ptr<SectionNode> const& other ) const {
-                return operator==( *other );
-            }
-
-            SectionStats stats;
-            typedef std::vector<Ptr<SectionNode> > ChildSections;
-            typedef std::vector<AssertionStats> Assertions;
-            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() ( Ptr<SectionNode> const& node ) const {
-                return ((node->stats.sectionInfo.name == m_other.name) &&
-                        (node->stats.sectionInfo.lineInfo == m_other.lineInfo));
-            }
-        private:
-            void operator=( BySectionInfo const& );
-            SectionInfo const& m_other;
-        };
-
-        typedef Node<TestCaseStats, SectionNode> TestCaseNode;
-        typedef Node<TestGroupStats, TestCaseNode> TestGroupNode;
-        typedef Node<TestRunStats, TestGroupNode> TestRunNode;
-
-        CumulativeReporterBase( ReporterConfig const& _config )
-        :   m_config( _config.fullConfig() ),
-            stream( _config.stream() )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = false;
-        }
-        ~CumulativeReporterBase();
-
-        virtual ReporterPreferences getPreferences() const CATCH_OVERRIDE {
-            return m_reporterPrefs;
-        }
-
-        virtual void testRunStarting( TestRunInfo const& ) CATCH_OVERRIDE {}
-        virtual void testGroupStarting( GroupInfo const& ) CATCH_OVERRIDE {}
-
-        virtual void testCaseStarting( TestCaseInfo const& ) CATCH_OVERRIDE {}
-
-        virtual void sectionStarting( SectionInfo const& sectionInfo ) CATCH_OVERRIDE {
-            SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
-            Ptr<SectionNode> node;
-            if( m_sectionStack.empty() ) {
-                if( !m_rootSection )
-                    m_rootSection = new SectionNode( incompleteStats );
-                node = m_rootSection;
-            }
-            else {
-                SectionNode& parentNode = *m_sectionStack.back();
-                SectionNode::ChildSections::const_iterator it =
-                    std::find_if(   parentNode.childSections.begin(),
-                                    parentNode.childSections.end(),
-                                    BySectionInfo( sectionInfo ) );
-                if( it == parentNode.childSections.end() ) {
-                    node = new SectionNode( incompleteStats );
-                    parentNode.childSections.push_back( node );
-                }
-                else
-                    node = *it;
-            }
-            m_sectionStack.push_back( node );
-            m_deepestSection = node;
-        }
-
-        virtual void assertionStarting( AssertionInfo const& ) CATCH_OVERRIDE {}
-
-        virtual bool assertionEnded( AssertionStats const& assertionStats ) CATCH_OVERRIDE {
-            assert( !m_sectionStack.empty() );
-            SectionNode& sectionNode = *m_sectionStack.back();
-            sectionNode.assertions.push_back( assertionStats );
-            // 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( sectionNode.assertions.back().assertionResult );
-            return true;
-        }
-        virtual void sectionEnded( SectionStats const& sectionStats ) CATCH_OVERRIDE {
-            assert( !m_sectionStack.empty() );
-            SectionNode& node = *m_sectionStack.back();
-            node.stats = sectionStats;
-            m_sectionStack.pop_back();
-        }
-        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE {
-            Ptr<TestCaseNode> node = new 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;
-        }
-        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE {
-            Ptr<TestGroupNode> node = new TestGroupNode( testGroupStats );
-            node->children.swap( m_testCases );
-            m_testGroups.push_back( node );
-        }
-        virtual void testRunEnded( TestRunStats const& testRunStats ) CATCH_OVERRIDE {
-            Ptr<TestRunNode> node = new TestRunNode( testRunStats );
-            node->children.swap( m_testGroups );
-            m_testRuns.push_back( node );
-            testRunEndedCumulative();
-        }
-        virtual void testRunEndedCumulative() = 0;
-
-        virtual void skipTest( TestCaseInfo const& ) CATCH_OVERRIDE {}
-
-        virtual void prepareExpandedExpression( AssertionResult& result ) const {
-            if( result.isOk() )
-                result.discardDecomposedExpression();
-            else
-                result.expandDecomposedExpression();
-        }
-
-        Ptr<IConfig const> m_config;
-        std::ostream& stream;
-        std::vector<AssertionStats> m_assertions;
-        std::vector<std::vector<Ptr<SectionNode> > > m_sections;
-        std::vector<Ptr<TestCaseNode> > m_testCases;
-        std::vector<Ptr<TestGroupNode> > m_testGroups;
-
-        std::vector<Ptr<TestRunNode> > m_testRuns;
-
-        Ptr<SectionNode> m_rootSection;
-        Ptr<SectionNode> m_deepestSection;
-        std::vector<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( ReporterConfig const& _config )
-        :   StreamingReporterBase( _config )
-        {}
-
-        virtual void assertionStarting( AssertionInfo const& ) CATCH_OVERRIDE {}
-        virtual bool assertionEnded( AssertionStats const& ) CATCH_OVERRIDE {
-            return false;
-        }
-    };
-
-} // end namespace Catch
-
-// #included from: ../internal/catch_reporter_registrars.hpp
-#define TWOBLUECUBES_CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
-
-namespace Catch {
-
-    template<typename T>
-    class LegacyReporterRegistrar {
-
-        class ReporterFactory : public IReporterFactory {
-            virtual IStreamingReporter* create( ReporterConfig const& config ) const {
-                return new LegacyReporterAdapter( new T( config ) );
-            }
-
-            virtual std::string getDescription() const {
-                return T::getDescription();
-            }
-        };
-
-    public:
-
-        LegacyReporterRegistrar( std::string const& name ) {
-            getMutableRegistryHub().registerReporter( name, new ReporterFactory() );
-        }
-    };
-
-    template<typename T>
-    class ReporterRegistrar {
-
-        class ReporterFactory : public SharedImpl<IReporterFactory> {
-
-            // *** Please Note ***:
-            // - If you end up here looking at a compiler error because it's trying to register
-            // your custom reporter class be aware that the native reporter interface has changed
-            // to IStreamingReporter. The "legacy" interface, IReporter, is still supported via
-            // an adapter. Just use REGISTER_LEGACY_REPORTER to take advantage of the adapter.
-            // However please consider updating to the new interface as the old one is now
-            // deprecated and will probably be removed quite soon!
-            // Please contact me via github if you have any questions at all about this.
-            // In fact, ideally, please contact me anyway to let me know you've hit this - as I have
-            // no idea who is actually using custom reporters at all (possibly no-one!).
-            // The new interface is designed to minimise exposure to interface changes in the future.
-            virtual IStreamingReporter* create( ReporterConfig const& config ) const {
-                return new T( config );
-            }
-
-            virtual std::string getDescription() const {
-                return T::getDescription();
-            }
-        };
-
-    public:
-
-        ReporterRegistrar( std::string const& name ) {
-            getMutableRegistryHub().registerReporter( name, new ReporterFactory() );
-        }
-    };
-
-    template<typename T>
-    class ListenerRegistrar {
-
-        class ListenerFactory : public SharedImpl<IReporterFactory> {
-
-            virtual IStreamingReporter* create( ReporterConfig const& config ) const {
-                return new T( config );
-            }
-            virtual std::string getDescription() const {
-                return std::string();
-            }
-        };
-
-    public:
-
-        ListenerRegistrar() {
-            getMutableRegistryHub().registerListener( new ListenerFactory() );
-        }
-    };
-}
-
-#define INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) \
-    namespace{ Catch::LegacyReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); }
-
-#define INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType ) \
-    namespace{ Catch::ReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); }
-
-// Deprecated - use the form without INTERNAL_
-#define INTERNAL_CATCH_REGISTER_LISTENER( listenerType ) \
-    namespace{ Catch::ListenerRegistrar<listenerType> catch_internal_RegistrarFor##listenerType; }
-
-#define CATCH_REGISTER_LISTENER( listenerType ) \
-    namespace{ Catch::ListenerRegistrar<listenerType> catch_internal_RegistrarFor##listenerType; }
-
-// #included from: ../internal/catch_xmlwriter.hpp
-#define TWOBLUECUBES_CATCH_XMLWRITER_HPP_INCLUDED
-
-#include <sstream>
-#include <string>
-#include <vector>
-#include <iomanip>
-
-namespace Catch {
-
-    class XmlEncode {
-    public:
-        enum ForWhat { ForTextNodes, ForAttributes };
-
-        XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes )
-        :   m_str( str ),
-            m_forWhat( forWhat )
-        {}
-
-        void 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;
-                }
-            }
-        }
-
-        friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
-            xmlEncode.encodeTo( os );
-            return os;
-        }
-
-    private:
-        std::string m_str;
-        ForWhat m_forWhat;
-    };
-
-    class XmlWriter {
-    public:
-
-        class ScopedElement {
-        public:
-            ScopedElement( XmlWriter* writer )
-            :   m_writer( writer )
-            {}
-
-            ScopedElement( ScopedElement const& other )
-            :   m_writer( other.m_writer ){
-                other.m_writer = CATCH_NULL;
-            }
-
-            ~ScopedElement() {
-                if( m_writer )
-                    m_writer->endElement();
-            }
-
-            ScopedElement& writeText( std::string const& text, bool indent = true ) {
-                m_writer->writeText( text, indent );
-                return *this;
-            }
-
-            template<typename T>
-            ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
-                m_writer->writeAttribute( name, attribute );
-                return *this;
-            }
-
-        private:
-            mutable XmlWriter* m_writer;
-        };
-
-        XmlWriter()
-        :   m_tagIsOpen( false ),
-            m_needsNewline( false ),
-            m_os( Catch::cout() )
-        {
-            writeDeclaration();
-        }
-
-        XmlWriter( std::ostream& os )
-        :   m_tagIsOpen( false ),
-            m_needsNewline( false ),
-            m_os( os )
-        {
-            writeDeclaration();
-        }
-
-        ~XmlWriter() {
-            while( !m_tags.empty() )
-                endElement();
-        }
-
-        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;
-        }
-
-        ScopedElement scopedElement( std::string const& name ) {
-            ScopedElement scoped( this );
-            startElement( name );
-            return scoped;
-        }
-
-        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& writeAttribute( std::string const& name, std::string const& attribute ) {
-            if( !name.empty() && !attribute.empty() )
-                m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
-            return *this;
-        }
-
-        XmlWriter& writeAttribute( std::string const& name, bool attribute ) {
-            m_os << ' ' << name << "=\"" << ( attribute ? "true" : "false" ) << '"';
-            return *this;
-        }
-
-        template<typename T>
-        XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
-            std::ostringstream oss;
-            oss << attribute;
-            return writeAttribute( name, oss.str() );
-        }
-
-        XmlWriter& writeText( std::string const& text, bool indent = true ) {
-            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& writeComment( std::string const& text ) {
-            ensureTagClosed();
-            m_os << m_indent << "<!--" << text << "-->";
-            m_needsNewline = true;
-            return *this;
-        }
-
-        void writeStylesheetRef( std::string const& url ) {
-            m_os << "<?xml-stylesheet type=\"text/xsl\" href=\"" << url << "\"?>\n";
-        }
-
-        XmlWriter& writeBlankLine() {
-            ensureTagClosed();
-            m_os << '\n';
-            return *this;
-        }
-
-        void ensureTagClosed() {
-            if( m_tagIsOpen ) {
-                m_os << ">" << std::endl;
-                m_tagIsOpen = false;
-            }
-        }
-
-    private:
-        XmlWriter( XmlWriter const& );
-        void operator=( XmlWriter const& );
-
-        void writeDeclaration() {
-            m_os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
-        }
-
-        void newlineIfNecessary() {
-            if( m_needsNewline ) {
-                m_os << std::endl;
-                m_needsNewline = false;
-            }
-        }
-
-        bool m_tagIsOpen;
-        bool m_needsNewline;
-        std::vector<std::string> m_tags;
-        std::string m_indent;
-        std::ostream& m_os;
-    };
-
-}
-
-namespace Catch {
-    class XmlReporter : public StreamingReporterBase {
-    public:
-        XmlReporter( ReporterConfig const& _config )
-        :   StreamingReporterBase( _config ),
-            m_xml(_config.stream()),
-            m_sectionDepth( 0 )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = true;
-        }
-
-        virtual ~XmlReporter() CATCH_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
-
-        virtual void noMatchingTestCases( std::string const& s ) CATCH_OVERRIDE {
-            StreamingReporterBase::noMatchingTestCases( s );
-        }
-
-        virtual void testRunStarting( TestRunInfo const& testInfo ) CATCH_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() );
-        }
-
-        virtual void testGroupStarting( GroupInfo const& groupInfo ) CATCH_OVERRIDE {
-            StreamingReporterBase::testGroupStarting( groupInfo );
-            m_xml.startElement( "Group" )
-                .writeAttribute( "name", groupInfo.name );
-        }
-
-        virtual void testCaseStarting( TestCaseInfo const& testInfo ) CATCH_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();
-        }
-
-        virtual void sectionStarting( SectionInfo const& sectionInfo ) CATCH_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();
-            }
-        }
-
-        virtual void assertionStarting( AssertionInfo const& ) CATCH_OVERRIDE { }
-
-        virtual bool assertionEnded( AssertionStats const& assertionStats ) CATCH_OVERRIDE {
-
-            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( std::vector<MessageInfo>::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end();
-                     it != itEnd;
-                     ++it ) {
-                    if( it->type == ResultWas::Info && includeResults ) {
-                        m_xml.scopedElement( "Info" )
-                                .writeText( it->message );
-                    } else if ( it->type == ResultWas::Warning ) {
-                        m_xml.scopedElement( "Warning" )
-                                .writeText( it->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;
-        }
-
-        virtual void sectionEnded( SectionStats const& sectionStats ) CATCH_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();
-            }
-        }
-
-        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_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();
-        }
-
-        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_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();
-        }
-
-        virtual void testRunEnded( TestRunStats const& testRunStats ) CATCH_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;
-    };
-
-     INTERNAL_CATCH_REGISTER_REPORTER( "xml", XmlReporter )
-
-} // end namespace Catch
-
-// #included from: ../reporters/catch_reporter_junit.hpp
-#define TWOBLUECUBES_CATCH_REPORTER_JUNIT_HPP_INCLUDED
-
-#include <assert.h>
-
-namespace Catch {
-
-    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);
-            const size_t timeStampSize = sizeof("2017-01-16T17:06:45Z");
-
-#ifdef _MSC_VER
-            std::tm timeInfo = {};
-            gmtime_s(&timeInfo, &rawtime);
-#else
-            std::tm* timeInfo;
-            timeInfo = std::gmtime(&rawtime);
-#endif
-
-            char timeStamp[timeStampSize];
-            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
-
-#ifdef _MSC_VER
-            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
-#else
-            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
-#endif
-            return std::string(timeStamp);
-        }
-
-    }
-
-    class JunitReporter : public CumulativeReporterBase {
-    public:
-        JunitReporter( ReporterConfig const& _config )
-        :   CumulativeReporterBase( _config ),
-            xml( _config.stream() ),
-            unexpectedExceptions( 0 ),
-            m_okToFail( false )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = true;
-        }
-
-        virtual ~JunitReporter() CATCH_OVERRIDE;
-
-        static std::string getDescription() {
-            return "Reports test results in an XML format that looks like Ant's junitreport target";
-        }
-
-        virtual void noMatchingTestCases( std::string const& /*spec*/ ) CATCH_OVERRIDE {}
-
-        virtual void testRunStarting( TestRunInfo const& runInfo ) CATCH_OVERRIDE {
-            CumulativeReporterBase::testRunStarting( runInfo );
-            xml.startElement( "testsuites" );
-        }
-
-        virtual void testGroupStarting( GroupInfo const& groupInfo ) CATCH_OVERRIDE {
-            suiteTimer.start();
-            stdOutForSuite.str("");
-            stdErrForSuite.str("");
-            unexpectedExceptions = 0;
-            CumulativeReporterBase::testGroupStarting( groupInfo );
-        }
-
-        virtual void testCaseStarting( TestCaseInfo const& testCaseInfo ) CATCH_OVERRIDE {
-            m_okToFail = testCaseInfo.okToFail();
-        }
-        virtual bool assertionEnded( AssertionStats const& assertionStats ) CATCH_OVERRIDE {
-            if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException && !m_okToFail )
-                unexpectedExceptions++;
-            return CumulativeReporterBase::assertionEnded( assertionStats );
-        }
-
-        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE {
-            stdOutForSuite << testCaseStats.stdOut;
-            stdErrForSuite << testCaseStats.stdErr;
-            CumulativeReporterBase::testCaseEnded( testCaseStats );
-        }
-
-        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE {
-            double suiteTime = suiteTimer.getElapsedSeconds();
-            CumulativeReporterBase::testGroupEnded( testGroupStats );
-            writeGroup( *m_testGroups.back(), suiteTime );
-        }
-
-        virtual void testRunEndedCumulative() CATCH_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( TestGroupNode::ChildNodes::const_iterator
-                    it = groupNode.children.begin(), itEnd = groupNode.children.end();
-                    it != itEnd;
-                    ++it )
-                writeTestCase( **it );
-
-            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() ) {
-                if( rootSection.childSections.empty() )
-                    className = "global";
-            }
-            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::toString( 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( SectionNode::ChildSections::const_iterator
-                    it = sectionNode.childSections.begin(),
-                    itEnd = sectionNode.childSections.end();
-                    it != itEnd;
-                    ++it )
-                if( className.empty() )
-                    writeSection( name, "", **it );
-                else
-                    writeSection( className, name, **it );
-        }
-
-        void writeAssertions( SectionNode const& sectionNode ) {
-            for( SectionNode::Assertions::const_iterator
-                    it = sectionNode.assertions.begin(), itEnd = sectionNode.assertions.end();
-                    it != itEnd;
-                    ++it )
-                writeAssertion( *it );
-        }
-        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( std::vector<MessageInfo>::const_iterator
-                        it = stats.infoMessages.begin(),
-                        itEnd = stats.infoMessages.end();
-                            it != itEnd;
-                            ++it )
-                    if( it->type == ResultWas::Info )
-                        oss << it->message << '\n';
-
-                oss << "at " << result.getSourceInfo();
-                xml.writeText( oss.str(), false );
-            }
-        }
-
-        XmlWriter xml;
-        Timer suiteTimer;
-        std::ostringstream stdOutForSuite;
-        std::ostringstream stdErrForSuite;
-        unsigned int unexpectedExceptions;
-        bool m_okToFail;
-    };
-
-    INTERNAL_CATCH_REGISTER_REPORTER( "junit", JunitReporter )
-
-} // end namespace Catch
-
-// #included from: ../reporters/catch_reporter_console.hpp
-#define TWOBLUECUBES_CATCH_REPORTER_CONSOLE_HPP_INCLUDED
-
-#include <cassert>
-#include <cfloat>
-#include <cstdio>
-
-namespace Catch {
-
-    struct ConsoleReporter : StreamingReporterBase {
-        ConsoleReporter( ReporterConfig const& _config )
-        :   StreamingReporterBase( _config ),
-            m_headerPrinted( false )
-        {}
-
-        virtual ~ConsoleReporter() CATCH_OVERRIDE;
-        static std::string getDescription() {
-            return "Reports test results as plain lines of text";
-        }
-
-        virtual void noMatchingTestCases( std::string const& spec ) CATCH_OVERRIDE {
-            stream << "No test cases matched '" << spec << '\'' << std::endl;
-        }
-
-        virtual void assertionStarting( AssertionInfo const& ) CATCH_OVERRIDE {
-        }
-
-        virtual bool assertionEnded( AssertionStats const& _assertionStats ) CATCH_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;
-        }
-
-        virtual void sectionStarting( SectionInfo const& _sectionInfo ) CATCH_OVERRIDE {
-            m_headerPrinted = false;
-            StreamingReporterBase::sectionStarting( _sectionInfo );
-        }
-        virtual void sectionEnded( SectionStats const& _sectionStats ) CATCH_OVERRIDE {
-            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 );
-        }
-
-        virtual void testCaseEnded( TestCaseStats const& _testCaseStats ) CATCH_OVERRIDE {
-            StreamingReporterBase::testCaseEnded( _testCaseStats );
-            m_headerPrinted = false;
-        }
-        virtual void testGroupEnded( TestGroupStats const& _testGroupStats ) CATCH_OVERRIDE {
-            if( currentGroupInfo.used ) {
-                printSummaryDivider();
-                stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
-                printTotals( _testGroupStats.totals );
-                stream << '\n' << std::endl;
-            }
-            StreamingReporterBase::testGroupEnded( _testGroupStats );
-        }
-        virtual void testRunEnded( TestRunStats const& _testRunStats ) CATCH_OVERRIDE {
-            printTotalsDivider( _testRunStats.totals );
-            printTotals( _testRunStats.totals );
-            stream << std::endl;
-            StreamingReporterBase::testRunEnded( _testRunStats );
-        }
-
-    private:
-
-        class AssertionPrinter {
-            void operator= ( AssertionPrinter const& );
-        public:
-            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 << Text( result.getExpandedExpression(), TextAttributes().setIndent(2) ) << '\n';
-                }
-            }
-            void printMessage() const {
-                if( !messageLabel.empty() )
-                    stream << messageLabel << ':' << '\n';
-                for( std::vector<MessageInfo>::const_iterator it = messages.begin(), itEnd = messages.end();
-                        it != itEnd;
-                        ++it ) {
-                    // If this assertion is a warning ignore any INFO messages
-                    if( printInfoMessages || it->type != ResultWas::Info )
-                        stream << Text( it->message, TextAttributes().setIndent(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() {
-
-            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 );
-
-                std::vector<SectionInfo>::const_iterator
-                    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 << Text( _string, TextAttributes()
-                                        .setIndent( indent+i)
-                                        .setInitialIndent( 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( std::vector<std::string>::iterator it = rows.begin(); it != rows.end(); ++it ) {
-                    while( it->size() < row.size() )
-                        *it = ' ' + *it;
-                    while( it->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( std::vector<SummaryColumn>::const_iterator it = cols.begin(); it != cols.end(); ++it ) {
-                std::string value = it->rows[row];
-                if( it->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( it->colour )
-                            << value << ' ' << it->label;
-                }
-            }
-            stream << '\n';
-        }
-
-        static 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;
-        }
-        static 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;
-        }
-
-        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;
-    };
-
-    INTERNAL_CATCH_REGISTER_REPORTER( "console", ConsoleReporter )
-
-} // end namespace Catch
-
-// #included from: ../reporters/catch_reporter_compact.hpp
-#define TWOBLUECUBES_CATCH_REPORTER_COMPACT_HPP_INCLUDED
-
-namespace Catch {
-
-    struct CompactReporter : StreamingReporterBase {
-
-        CompactReporter( ReporterConfig const& _config )
-        : StreamingReporterBase( _config )
-        {}
-
-        virtual ~CompactReporter();
-
-        static std::string getDescription() {
-            return "Reports test results on a single line, suitable for IDEs";
-        }
-
-        virtual ReporterPreferences getPreferences() const {
-            ReporterPreferences prefs;
-            prefs.shouldRedirectStdOut = false;
-            return prefs;
-        }
-
-        virtual void noMatchingTestCases( std::string const& spec ) {
-            stream << "No test cases matched '" << spec << '\'' << std::endl;
-        }
-
-        virtual void assertionStarting( AssertionInfo const& ) {}
-
-        virtual bool assertionEnded( AssertionStats const& _assertionStats ) {
-            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;
-        }
-
-        virtual void sectionEnded(SectionStats const& _sectionStats) CATCH_OVERRIDE {
-            if (m_config->showDurations() == ShowDurations::Always) {
-                stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
-            }
-        }
-
-        virtual void testRunEnded( TestRunStats const& _testRunStats ) {
-            printTotals( _testRunStats.totals );
-            stream << '\n' << std::endl;
-            StreamingReporterBase::testRunEnded( _testRunStats );
-        }
-
-    private:
-        class AssertionPrinter {
-            void operator= ( AssertionPrinter const& );
-        public:
-            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages )
-            : stream( _stream )
-            , stats( _stats )
-            , 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:
-            // Colour::LightGrey
-
-            static Colour::Code dimColour() { return Colour::FileName; }
-
-#ifdef CATCH_PLATFORM_MAC
-            static const char* failedString() { return "FAILED"; }
-            static const char* passedString() { return "PASSED"; }
-#else
-            static const char* failedString() { return "failed"; }
-            static const char* passedString() { return "passed"; }
-#endif
-
-            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 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;
-            AssertionStats const& stats;
-            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.
-
-        std::string bothOrAll( std::size_t count ) const {
-            return count == 1 ? std::string() : count == 2 ? "both " : "all " ;
-        }
-
-        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" ) << '.';
-            }
-        }
-    };
-
-    INTERNAL_CATCH_REGISTER_REPORTER( "compact", CompactReporter )
-
-} // end namespace Catch
-
-namespace Catch {
-    // These are all here to avoid warnings about not having any out of line
-    // virtual methods
-    NonCopyable::~NonCopyable() {}
-    IShared::~IShared() {}
-    IStream::~IStream() CATCH_NOEXCEPT {}
-    FileStream::~FileStream() CATCH_NOEXCEPT {}
-    CoutStream::~CoutStream() CATCH_NOEXCEPT {}
-    DebugOutStream::~DebugOutStream() CATCH_NOEXCEPT {}
-    StreamBufBase::~StreamBufBase() CATCH_NOEXCEPT {}
-    IContext::~IContext() {}
-    IResultCapture::~IResultCapture() {}
-    ITestCase::~ITestCase() {}
-    ITestCaseRegistry::~ITestCaseRegistry() {}
-    IRegistryHub::~IRegistryHub() {}
-    IMutableRegistryHub::~IMutableRegistryHub() {}
-    IExceptionTranslator::~IExceptionTranslator() {}
-    IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() {}
-    IReporter::~IReporter() {}
-    IReporterFactory::~IReporterFactory() {}
-    IReporterRegistry::~IReporterRegistry() {}
-    IStreamingReporter::~IStreamingReporter() {}
-    AssertionStats::~AssertionStats() {}
-    SectionStats::~SectionStats() {}
-    TestCaseStats::~TestCaseStats() {}
-    TestGroupStats::~TestGroupStats() {}
-    TestRunStats::~TestRunStats() {}
-    CumulativeReporterBase::SectionNode::~SectionNode() {}
-    CumulativeReporterBase::~CumulativeReporterBase() {}
-
-    StreamingReporterBase::~StreamingReporterBase() {}
-    ConsoleReporter::~ConsoleReporter() {}
-    CompactReporter::~CompactReporter() {}
-    IRunner::~IRunner() {}
-    IMutableContext::~IMutableContext() {}
-    IConfig::~IConfig() {}
-    XmlReporter::~XmlReporter() {}
-    JunitReporter::~JunitReporter() {}
-    TestRegistry::~TestRegistry() {}
-    FreeFunctionTestCase::~FreeFunctionTestCase() {}
-    IGeneratorInfo::~IGeneratorInfo() {}
-    IGeneratorsForTest::~IGeneratorsForTest() {}
-    WildcardPattern::~WildcardPattern() {}
-    TestSpec::Pattern::~Pattern() {}
-    TestSpec::NamePattern::~NamePattern() {}
-    TestSpec::TagPattern::~TagPattern() {}
-    TestSpec::ExcludedPattern::~ExcludedPattern() {}
-    Matchers::Impl::MatcherUntypedBase::~MatcherUntypedBase() {}
-
-    void Config::dummy() {}
-
-    namespace TestCaseTracking {
-        ITracker::~ITracker() {}
-        TrackerBase::~TrackerBase() {}
-        SectionTracker::~SectionTracker() {}
-        IndexTracker::~IndexTracker() {}
-    }
-}
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-#endif
-
-#ifdef CATCH_CONFIG_MAIN
-// #included from: internal/catch_default_main.hpp
-#define TWOBLUECUBES_CATCH_DEFAULT_MAIN_HPP_INCLUDED
-
-#ifndef __OBJC__
-
-#if 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
-// Standard C/C++ main entry point
-int main (int argc, char * argv[]) {
-#endif
-
-    int result = Catch::Session().run( argc, argv );
-    return ( result < 0xff ? result : 0xff );
-}
-
-#else // __OBJC__
-
-// Objective-C entry point
-int main (int argc, char * const argv[]) {
-#if !CATCH_ARC_ENABLED
-    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
-#endif
-
-    Catch::registerTestMethods();
-    int result = Catch::Session().run( argc, (char* const*)argv );
-
-#if !CATCH_ARC_ENABLED
-    [pool drain];
-#endif
-
-    return ( result < 0xff ? result : 0xff );
-}
-
-#endif // __OBJC__
-
-#endif
-
-#ifdef CLARA_CONFIG_MAIN_NOT_DEFINED
-#  undef CLARA_CONFIG_MAIN
-#endif
-
-//////
-
-// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
-#ifdef CATCH_CONFIG_PREFIX_ALL
-
-#if defined(CATCH_CONFIG_FAST_COMPILE)
-#define CATCH_REQUIRE( expr ) INTERNAL_CATCH_TEST_NO_TRY( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, expr )
-#define CATCH_REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST_NO_TRY( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, expr )
-#else
-#define CATCH_REQUIRE( expr ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, expr )
-#define CATCH_REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, expr  )
-#endif
-
-#define CATCH_REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, "", expr )
-#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
-#define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
-#define CATCH_REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( "CATCH_REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, expr )
-
-#define CATCH_CHECK( expr ) INTERNAL_CATCH_TEST( "CATCH_CHECK", Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CATCH_CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( "CATCH_CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, expr )
-#define CATCH_CHECKED_IF( expr ) INTERNAL_CATCH_IF( "CATCH_CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CATCH_CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CATCH_CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, expr )
-
-#define CATCH_CHECK_THROWS( expr )  INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, "", expr )
-#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#define CATCH_CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( "CATCH_CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, expr )
-
-#define CATCH_CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
-
-#if defined(CATCH_CONFIG_FAST_COMPILE)
-#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT_NO_TRY( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
-#else
-#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
-#endif
-
-#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_SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
-#define CATCH_CAPTURE( msg ) INTERNAL_CATCH_INFO( "CATCH_CAPTURE", #msg " := " << Catch::toString(msg) )
-#define CATCH_SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( "CATCH_CAPTURE", #msg " := " << Catch::toString(msg) )
-
-#ifdef CATCH_CONFIG_VARIADIC_MACROS
-    #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_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__ )
-#else
-    #define CATCH_TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description )
-    #define CATCH_TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description )
-    #define CATCH_METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description )
-    #define CATCH_REGISTER_TEST_CASE( function, name, description ) INTERNAL_CATCH_REGISTER_TESTCASE( function, name, description )
-    #define CATCH_SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description )
-    #define CATCH_FAIL( msg ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, msg )
-    #define CATCH_FAIL_CHECK( msg ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, msg )
-    #define CATCH_SUCCEED( msg ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, msg )
-#endif
-#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" )
-
-#define CATCH_REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType )
-#define CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType )
-
-#define CATCH_GENERATE( expr) INTERNAL_CATCH_GENERATE( expr )
-
-// "BDD-style" convenience wrappers
-#ifdef CATCH_CONFIG_VARIADIC_MACROS
-#define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ )
-#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
-#else
-#define CATCH_SCENARIO( name, tags ) CATCH_TEST_CASE( "Scenario: " name, tags )
-#define CATCH_SCENARIO_METHOD( className, name, tags ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " name, tags )
-#endif
-#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, "" )
-
-// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
-#else
-
-#if defined(CATCH_CONFIG_FAST_COMPILE)
-#define REQUIRE( expr ) INTERNAL_CATCH_TEST_NO_TRY( "REQUIRE", Catch::ResultDisposition::Normal, expr )
-#define REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST_NO_TRY( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, expr )
-
-#else
-#define REQUIRE( expr ) INTERNAL_CATCH_TEST( "REQUIRE", Catch::ResultDisposition::Normal, expr  )
-#define REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, expr )
-#endif
-
-#define REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS", Catch::ResultDisposition::Normal, "", expr )
-#define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
-#define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
-#define REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( "REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, expr )
-
-#define CHECK( expr ) INTERNAL_CATCH_TEST( "CHECK", Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( "CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, expr )
-#define CHECKED_IF( expr ) INTERNAL_CATCH_IF( "CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( "CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( "CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, expr )
-
-#define CHECK_THROWS( expr )  INTERNAL_CATCH_THROWS( "CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, "", expr )
-#define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#define CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( "CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, expr )
-
-#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
-
-#if defined(CATCH_CONFIG_FAST_COMPILE)
-#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT_NO_TRY( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
-#else
-#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
-#endif
-
-#define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
-#define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
-#define SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
-#define CAPTURE( msg ) INTERNAL_CATCH_INFO( "CAPTURE", #msg " := " << Catch::toString(msg) )
-#define SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( "CAPTURE", #msg " := " << Catch::toString(msg) )
-
-#ifdef CATCH_CONFIG_VARIADIC_MACROS
-#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 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__ )
-#else
-#define TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description )
-    #define TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description )
-    #define METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description )
-    #define REGISTER_TEST_CASE( method, name, description ) INTERNAL_CATCH_REGISTER_TESTCASE( method, name, description )
-    #define SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description )
-    #define FAIL( msg ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, msg )
-    #define FAIL_CHECK( msg ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, msg )
-    #define SUCCEED( msg ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, msg )
-#endif
-#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" )
-
-#define REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType )
-#define REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType )
-
-#define GENERATE( expr) INTERNAL_CATCH_GENERATE( expr )
-
-#endif
-
-#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
-
-// "BDD-style" convenience wrappers
-#ifdef CATCH_CONFIG_VARIADIC_MACROS
-#define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
-#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
-#else
-#define SCENARIO( name, tags ) TEST_CASE( "Scenario: " name, tags )
-#define SCENARIO_METHOD( className, name, tags ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " name, tags )
-#endif
-#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, "" )
-
-using Catch::Detail::Approx;
-
-// #included from: internal/catch_reenable_warnings.h
-
-#define TWOBLUECUBES_CATCH_REENABLE_WARNINGS_H_INCLUDED
-
-#ifdef __clang__
-#    ifdef __ICC // icpc defines the __clang__ macro
-#        pragma warning(pop)
-#    else
-#        pragma clang diagnostic pop
-#    endif
-#elif defined __GNUC__
-#    pragma GCC diagnostic pop
-#endif
-
-#endif // TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
-
diff --git a/Tests/main.cpp b/Tests/main.cpp
index 0c7c351f4..c7810e372 100644
--- a/Tests/main.cpp
+++ b/Tests/main.cpp
@@ -1,2 +1,2 @@
 #define CATCH_CONFIG_MAIN
-#include "catch.hpp"
+#include "catch_amalgamated.hpp"

From bab65d759d2861a038ea9e96efa86e60748ac503 Mon Sep 17 00:00:00 2001
From: Graham Pentheny <graham.pentheny@gmail.com>
Date: Sat, 29 Oct 2022 14:24:54 -0400
Subject: [PATCH 34/51] Updated cmake build with Catch2 library location

---
 Tests/CMakeLists.txt | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Tests/CMakeLists.txt b/Tests/CMakeLists.txt
index a98ccbf13..3b906897b 100644
--- a/Tests/CMakeLists.txt
+++ b/Tests/CMakeLists.txt
@@ -1,7 +1,8 @@
-file(GLOB TESTS_SOURCES *.cpp Detour/*.cpp Recast/*.cpp)
+file(GLOB TESTS_SOURCES *.cpp Detour/*.cpp Recast/*.cpp Contrib/Catch/*.cpp)
 
 include_directories(../Detour/Include)
 include_directories(../Recast/Include)
+include_directories(./Contrib/Catch)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 
 add_executable(Tests ${TESTS_SOURCES})

From 9098a816824ea5d069f5df0be94cc19f4d6d4e02 Mon Sep 17 00:00:00 2001
From: Graham Pentheny <graham.pentheny@gmail.com>
Date: Sat, 29 Oct 2022 23:08:16 -0400
Subject: [PATCH 35/51] Change to C++14 instead of C++20

Updated appveyor version matrix.  Removed vs2013
---
 RecastDemo/premake5.lua | 2 +-
 appveyor.yml            | 9 ++++++---
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/RecastDemo/premake5.lua b/RecastDemo/premake5.lua
index 08a2dbbda..5dc68470a 100644
--- a/RecastDemo/premake5.lua
+++ b/RecastDemo/premake5.lua
@@ -194,7 +194,7 @@ project "RecastDemo"
 project "Tests"
 	language "C++"
 	kind "ConsoleApp"
-	cppdialect "C++20" -- Catch requires newer C++ features
+	cppdialect "C++14" -- Catch requires newer C++ features
 
 	-- Catch requires RTTI and exceptions
 	exceptionhandling "On"
diff --git a/appveyor.yml b/appveyor.yml
index 263d1e520..6459e1cb5 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -2,15 +2,18 @@ shallow_clone: true
 
 environment:
   matrix:
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-      PREMAKE_ACTION: vs2013
-      CMAKE_GENERATOR: Visual Studio 12 2013 Win64
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
       PREMAKE_ACTION: vs2015
       CMAKE_GENERATOR: Visual Studio 14 2015 Win64
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
       PREMAKE_ACTION: vs2017
       CMAKE_GENERATOR: Visual Studio 15 2017 Win64
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+      PREMAKE_ACTION: vs2019
+      CMAKE_GENERATOR: Visual Studio 16 2019 Win64
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2022
+      PREMAKE_ACTION: vs2022
+      CMAKE_GENERATOR: Visual Studio 17 2022 Win64
 
 configuration:
   - Debug

From 80e55ebfb7f2fcc5d7b741c489b8dda1fc7c7950 Mon Sep 17 00:00:00 2001
From: Graham Pentheny <graham.pentheny@gmail.com>
Date: Sat, 29 Oct 2022 23:27:41 -0400
Subject: [PATCH 36/51] Update to a newer premake version that supports vs2019
 and vs2022

---
 appveyor.yml | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/appveyor.yml b/appveyor.yml
index 6459e1cb5..58dde7658 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -24,7 +24,7 @@ platform:
 
 install:
   # Download Premake
-  - ps: Start-FileDownload 'https://github.com/premake/premake-core/releases/download/v5.0.0-alpha12/premake-5.0.0-alpha12-windows.zip' 'premake.zip'
+  - ps: Start-FileDownload 'https://github.com/premake/premake-core/releases/download/v5.0.0-beta2/premake-5.0.0-beta2-windows.zip' 'premake.zip'
   
   # Extract it in-place; premake5.exe is at the top level.
   - 7z x premake.zip
@@ -38,7 +38,6 @@ install:
   # Generate solution files using premake.
   - cd RecastDemo && "../premake5.exe" %PREMAKE_ACTION% && cd ..
 
-
 build:
   project: RecastDemo/Build/$(PREMAKE_ACTION)/recastnavigation.sln
 

From b0d71bed92a89c0b4ad63ca4278d12c63d8d6eb4 Mon Sep 17 00:00:00 2001
From: Graham Pentheny <graham.pentheny@gmail.com>
Date: Sat, 29 Oct 2022 23:53:26 -0400
Subject: [PATCH 37/51] Removed VS2015 and fixed cmake generators for 2019,
 2022

Catch seems to only work with VS 2017+
---
 appveyor.yml | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/appveyor.yml b/appveyor.yml
index 58dde7658..dd4e3ab2b 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -2,18 +2,15 @@ shallow_clone: true
 
 environment:
   matrix:
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      PREMAKE_ACTION: vs2015
-      CMAKE_GENERATOR: Visual Studio 14 2015 Win64
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
       PREMAKE_ACTION: vs2017
       CMAKE_GENERATOR: Visual Studio 15 2017 Win64
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
       PREMAKE_ACTION: vs2019
-      CMAKE_GENERATOR: Visual Studio 16 2019 Win64
+      CMAKE_GENERATOR: Visual Studio 16 2019
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2022
       PREMAKE_ACTION: vs2022
-      CMAKE_GENERATOR: Visual Studio 17 2022 Win64
+      CMAKE_GENERATOR: Visual Studio 17 2022
 
 configuration:
   - Debug

From e6b675bb9a302c93a28104a0b36ac1d4f75be37d Mon Sep 17 00:00:00 2001
From: Siddharth J Singh <Dante-666@users.noreply.github.com>
Date: Wed, 9 Nov 2022 22:24:56 +0530
Subject: [PATCH 38/51] Fastlz fix for -Wno-class-memaccess' is valid for
 C++/ObjC++ but not for C (#479)

* Added a selective filter for *.c files compiled on linux using make

Co-authored-by: Graham Pentheny <graham.pentheny@gmail.com>
---
 RecastDemo/premake5.lua | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/RecastDemo/premake5.lua b/RecastDemo/premake5.lua
index 5dc68470a..ce7ce51b2 100644
--- a/RecastDemo/premake5.lua
+++ b/RecastDemo/premake5.lua
@@ -156,8 +156,6 @@ project "RecastDemo"
 			"`pkg-config --cflags gl`",
 			"`pkg-config --cflags glu`",
 			"-Wno-ignored-qualifiers",
-			"-Wno-error=class-memaccess"
-
 		}
 		linkoptions { 
 			"`pkg-config --libs sdl2`",
@@ -165,6 +163,11 @@ project "RecastDemo"
 			"`pkg-config --libs glu`" 
 		}
 
+	filter { "system:linux", "action:gmake*", "files:*.c" }
+		buildoptions {
+			"-Wno-class-memaccess"
+		}
+
 	-- windows library cflags and libs
 	filter "system:windows"
 		includedirs { "../RecastDemo/Contrib/SDL/include" }

From ea7bfbee709b7a2467ccf96a1bb34523fdf1b5a2 Mon Sep 17 00:00:00 2001
From: Graham Pentheny <grahamboree@users.noreply.github.com>
Date: Fri, 11 Nov 2022 20:11:14 -0500
Subject: [PATCH 39/51] Fix clang linux builds (#578)

Also remove hard-coded filter on gmake premake target since it's deprecated in favor of gmake2. It also doesn't matter; what matters is that we filter on gcc, since the warnings we've disabled don't exist in clang and will throw errors.
---
 RecastDemo/premake5.lua | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/RecastDemo/premake5.lua b/RecastDemo/premake5.lua
index ce7ce51b2..8330b061e 100644
--- a/RecastDemo/premake5.lua
+++ b/RecastDemo/premake5.lua
@@ -75,9 +75,10 @@ project "Detour"
 		"../Detour/Source/*.cpp" 
 	}
 	-- linux library cflags and libs
-	filter {"system:linux", "action:gmake"}
+	filter {"system:linux", "toolset:gcc"}
 		buildoptions {
-			"-Wno-error=class-memaccess"
+			"-Wno-error=class-memaccess",
+			"-Wno-error=maybe-uninitialized"
 		}
 
 project "DetourCrowd"
@@ -130,7 +131,7 @@ project "RecastDemo"
 		"../DetourTileCache/Include",
 		"../Recast/Include"
 	}
-	files	{ 
+	files {
 		"../RecastDemo/Include/*.h",
 		"../RecastDemo/Source/*.cpp",
 		"../RecastDemo/Contrib/fastlz/*.h",
@@ -138,7 +139,7 @@ project "RecastDemo"
 	}
 
 	-- project dependencies
-	links { 
+	links {
 		"DebugUtils",
 		"Detour",
 		"DetourCrowd",
@@ -150,7 +151,7 @@ project "RecastDemo"
 	targetdir "Bin"
 
 	-- linux library cflags and libs
-	filter {"system:linux", "action:gmake"}
+	filter "system:linux"
 		buildoptions { 
 			"`pkg-config --cflags sdl2`",
 			"`pkg-config --cflags gl`",
@@ -163,7 +164,7 @@ project "RecastDemo"
 			"`pkg-config --libs glu`" 
 		}
 
-	filter { "system:linux", "action:gmake*", "files:*.c" }
+	filter { "system:linux", "toolset:gcc", "files:*.c" }
 		buildoptions {
 			"-Wno-class-memaccess"
 		}
@@ -238,8 +239,8 @@ project "Tests"
 	targetdir "Bin"
 
 	-- linux library cflags and libs
-	filter {"system:linux", "action:gmake"}
-		buildoptions { 
+	filter "system:linux"
+		buildoptions {
 			"`pkg-config --cflags sdl2`",
 			"`pkg-config --cflags gl`",
 			"`pkg-config --cflags glu`",
@@ -248,7 +249,8 @@ project "Tests"
 		linkoptions { 
 			"`pkg-config --libs sdl2`",
 			"`pkg-config --libs gl`",
-			"`pkg-config --libs glu`" 
+			"`pkg-config --libs glu`",
+			"-lpthread"
 		}
 
 	-- windows library cflags and libs

From 51111395580c897d8bb178c778829e7ad8b5ab6e Mon Sep 17 00:00:00 2001
From: Graham Pentheny <grahamboree@users.noreply.github.com>
Date: Fri, 11 Nov 2022 21:03:03 -0500
Subject: [PATCH 40/51] Fixes for many low-severity compiler warnings (#576)

* Fixes for many low-severity compiler warnings

Mostly a lot of pedantic things like end-of-file newlines and commas on the last enum value.  However some fixes like the weak v-tables warnings fixes might help with code gen.  It's unclear if the linker is able to elide multiple copies of the same type's v-table in different translation units, (sometimes it can) but these fixes ensure we don't have to rely on it.
---
 DebugUtils/Include/DebugDraw.h                |  6 +--
 DebugUtils/Include/DetourDebugDraw.h          |  2 +-
 DebugUtils/Include/RecastDump.h               |  3 +-
 DebugUtils/Source/DebugDraw.cpp               |  4 +-
 DebugUtils/Source/RecastDump.cpp              |  3 +-
 Detour/Include/DetourNavMesh.h                | 14 +++---
 Detour/Include/DetourNavMeshQuery.h           |  2 +-
 Detour/Include/DetourNode.h                   |  2 +-
 Detour/Source/DetourNavMeshQuery.cpp          | 19 +++++++
 DetourCrowd/Include/DetourCrowd.h             |  6 +--
 DetourTileCache/Include/DetourTileCache.h     | 18 +++----
 .../Include/DetourTileCacheBuilder.h          |  4 +-
 DetourTileCache/Source/DetourTileCache.cpp    |  5 ++
 .../Source/DetourTileCacheBuilder.cpp         |  9 ++++
 Recast/Include/Recast.h                       |  8 ++-
 Recast/Source/Recast.cpp                      |  5 ++
 Recast/Source/RecastMeshDetail.cpp            |  2 +-
 RecastDemo/Include/ChunkyTriMesh.h            |  2 +-
 RecastDemo/Include/CrowdTool.h                |  2 +-
 RecastDemo/Include/NavMeshTesterTool.h        |  5 +-
 RecastDemo/Include/PerfTimer.h                |  3 +-
 RecastDemo/Include/Sample.h                   |  8 +--
 RecastDemo/Include/TestCase.h                 |  4 +-
 RecastDemo/Include/ValueHistory.h             |  3 +-
 RecastDemo/Include/imgui.h                    |  6 +--
 RecastDemo/Include/imguiRenderGL.h            |  3 +-
 RecastDemo/Source/Filelist.cpp                |  4 +-
 RecastDemo/Source/Sample.cpp                  | 10 ++++
 RecastDemo/Source/SampleInterfaces.cpp        |  2 +-
 RecastDemo/Source/Sample_TempObstacles.cpp    | 50 ++++++++++++-------
 RecastDemo/Source/Sample_TileMesh.cpp         | 10 ++--
 RecastDemo/Source/main.cpp                    |  3 --
 32 files changed, 139 insertions(+), 88 deletions(-)

diff --git a/DebugUtils/Include/DebugDraw.h b/DebugUtils/Include/DebugDraw.h
index 00b544d1c..1a6b3e74a 100644
--- a/DebugUtils/Include/DebugDraw.h
+++ b/DebugUtils/Include/DebugDraw.h
@@ -27,7 +27,7 @@ enum duDebugDrawPrimitives
 	DU_DRAW_POINTS,
 	DU_DRAW_LINES,
 	DU_DRAW_TRIS,
-	DU_DRAW_QUADS,	
+	DU_DRAW_QUADS
 };
 
 /// Abstract debug draw interface.
@@ -197,15 +197,15 @@ class duDisplayList : public duDebugDraw
 	int m_size;
 	int m_cap;
 
-	bool m_depthMask;
 	duDebugDrawPrimitives m_prim;
 	float m_primSize;
+	bool m_depthMask;
 	
 	void resize(int cap);
 	
 public:
 	duDisplayList(int cap = 512);
-	~duDisplayList();
+	virtual ~duDisplayList();
 	virtual void depthMask(bool state);
 	virtual void begin(duDebugDrawPrimitives prim, float size = 1.0f);
 	virtual void vertex(const float x, const float y, const float z, unsigned int color);
diff --git a/DebugUtils/Include/DetourDebugDraw.h b/DebugUtils/Include/DetourDebugDraw.h
index ff2ca2f9d..d1a808f1d 100755
--- a/DebugUtils/Include/DetourDebugDraw.h
+++ b/DebugUtils/Include/DetourDebugDraw.h
@@ -27,7 +27,7 @@ enum DrawNavMeshFlags
 {
 	DU_DRAWNAVMESH_OFFMESHCONS = 0x01,
 	DU_DRAWNAVMESH_CLOSEDLIST = 0x02,
-	DU_DRAWNAVMESH_COLOR_TILES = 0x04,
+	DU_DRAWNAVMESH_COLOR_TILES = 0x04
 };
 
 void duDebugDrawNavMesh(struct duDebugDraw* dd, const dtNavMesh& mesh, unsigned char flags);
diff --git a/DebugUtils/Include/RecastDump.h b/DebugUtils/Include/RecastDump.h
index 6a722fdae..18cc891a5 100644
--- a/DebugUtils/Include/RecastDump.h
+++ b/DebugUtils/Include/RecastDump.h
@@ -21,7 +21,7 @@
 
 struct duFileIO
 {
-	virtual ~duFileIO() = 0;
+	virtual ~duFileIO();
 	virtual bool isWriting() const = 0;
 	virtual bool isReading() const = 0;
 	virtual bool write(const void* ptr, const size_t size) = 0;
@@ -39,5 +39,4 @@ bool duReadCompactHeightfield(struct rcCompactHeightfield& chf, duFileIO* io);
 
 void duLogBuildTimes(rcContext& ctx, const int totalTileUsec);
 
-
 #endif // RECAST_DUMP_H
diff --git a/DebugUtils/Source/DebugDraw.cpp b/DebugUtils/Source/DebugDraw.cpp
index d0179bca2..925699284 100644
--- a/DebugUtils/Source/DebugDraw.cpp
+++ b/DebugUtils/Source/DebugDraw.cpp
@@ -530,9 +530,9 @@ duDisplayList::duDisplayList(int cap) :
 	m_color(0),
 	m_size(0),
 	m_cap(0),
-	m_depthMask(true),
 	m_prim(DU_DRAW_LINES),
-	m_primSize(1.0f)
+	m_primSize(1.0f),
+	m_depthMask(true)
 {
 	if (cap < 8)
 		cap = 8;
diff --git a/DebugUtils/Source/RecastDump.cpp b/DebugUtils/Source/RecastDump.cpp
index 209382515..581089983 100644
--- a/DebugUtils/Source/RecastDump.cpp
+++ b/DebugUtils/Source/RecastDump.cpp
@@ -25,10 +25,9 @@
 #include "RecastAlloc.h"
 #include "RecastDump.h"
 
-
 duFileIO::~duFileIO()
 {
-	// Empty
+	// Defined out of line to fix the weak v-tables warning
 }
 	
 static void ioprintf(duFileIO* io, const char* format, ...)
diff --git a/Detour/Include/DetourNavMesh.h b/Detour/Include/DetourNavMesh.h
index cb5414f53..34819e1e8 100644
--- a/Detour/Include/DetourNavMesh.h
+++ b/Detour/Include/DetourNavMesh.h
@@ -99,7 +99,7 @@ static const int DT_MAX_AREAS = 64;
 enum dtTileFlags
 {
 	/// The navigation mesh owns the tile memory and is responsible for freeing it.
-	DT_TILE_FREE_DATA = 0x01,
+	DT_TILE_FREE_DATA = 0x01
 };
 
 /// Vertex flags returned by dtNavMeshQuery::findStraightPath.
@@ -107,32 +107,32 @@ enum dtStraightPathFlags
 {
 	DT_STRAIGHTPATH_START = 0x01,				///< The vertex is the start position in the path.
 	DT_STRAIGHTPATH_END = 0x02,					///< The vertex is the end position in the path.
-	DT_STRAIGHTPATH_OFFMESH_CONNECTION = 0x04,	///< The vertex is the start of an off-mesh connection.
+	DT_STRAIGHTPATH_OFFMESH_CONNECTION = 0x04	///< The vertex is the start of an off-mesh connection.
 };
 
 /// Options for dtNavMeshQuery::findStraightPath.
 enum dtStraightPathOptions
 {
 	DT_STRAIGHTPATH_AREA_CROSSINGS = 0x01,	///< Add a vertex at every polygon edge crossing where area changes.
-	DT_STRAIGHTPATH_ALL_CROSSINGS = 0x02,	///< Add a vertex at every polygon edge crossing.
+	DT_STRAIGHTPATH_ALL_CROSSINGS = 0x02	///< Add a vertex at every polygon edge crossing.
 };
 
 
 /// Options for dtNavMeshQuery::initSlicedFindPath and updateSlicedFindPath
 enum dtFindPathOptions
 {
-	DT_FINDPATH_ANY_ANGLE	= 0x02,		///< use raycasts during pathfind to "shortcut" (raycast still consider costs)
+	DT_FINDPATH_ANY_ANGLE	= 0x02		///< use raycasts during pathfind to "shortcut" (raycast still consider costs)
 };
 
 /// Options for dtNavMeshQuery::raycast
 enum dtRaycastOptions
 {
-	DT_RAYCAST_USE_COSTS = 0x01,		///< Raycast should calculate movement cost along the ray and fill RaycastHit::cost
+	DT_RAYCAST_USE_COSTS = 0x01		///< Raycast should calculate movement cost along the ray and fill RaycastHit::cost
 };
 
 enum dtDetailTriEdgeFlags
 {
-	DT_DETAIL_EDGE_BOUNDARY = 0x01,		///< Detail triangle edge is part of the poly boundary
+	DT_DETAIL_EDGE_BOUNDARY = 0x01		///< Detail triangle edge is part of the poly boundary
 };
 
 
@@ -146,7 +146,7 @@ enum dtPolyTypes
 	/// The polygon is a standard convex polygon that is part of the surface of the mesh.
 	DT_POLYTYPE_GROUND = 0,
 	/// The polygon is an off-mesh connection consisting of two vertices.
-	DT_POLYTYPE_OFFMESH_CONNECTION = 1,
+	DT_POLYTYPE_OFFMESH_CONNECTION = 1
 };
 
 
diff --git a/Detour/Include/DetourNavMeshQuery.h b/Detour/Include/DetourNavMeshQuery.h
index 08b70a8f5..fc5dec84e 100644
--- a/Detour/Include/DetourNavMeshQuery.h
+++ b/Detour/Include/DetourNavMeshQuery.h
@@ -152,7 +152,7 @@ struct dtRaycastHit
 class dtPolyQuery
 {
 public:
-	virtual ~dtPolyQuery() { }
+	virtual ~dtPolyQuery();
 
 	/// Called for each batch of unique polygons touched by the search area in dtNavMeshQuery::queryPolygons.
 	/// This can be called multiple times for a single query.
diff --git a/Detour/Include/DetourNode.h b/Detour/Include/DetourNode.h
index db0974708..8918d4686 100644
--- a/Detour/Include/DetourNode.h
+++ b/Detour/Include/DetourNode.h
@@ -25,7 +25,7 @@ enum dtNodeFlags
 {
 	DT_NODE_OPEN = 0x01,
 	DT_NODE_CLOSED = 0x02,
-	DT_NODE_PARENT_DETACHED = 0x04, // parent of the node is not adjacent. Found using raycast.
+	DT_NODE_PARENT_DETACHED = 0x04 // parent of the node is not adjacent. Found using raycast.
 };
 
 typedef unsigned short dtNodeIndex;
diff --git a/Detour/Source/DetourNavMeshQuery.cpp b/Detour/Source/DetourNavMeshQuery.cpp
index b48618f0a..cebe26b5d 100644
--- a/Detour/Source/DetourNavMeshQuery.cpp
+++ b/Detour/Source/DetourNavMeshQuery.cpp
@@ -117,6 +117,11 @@ void dtFreeNavMeshQuery(dtNavMeshQuery* navmesh)
 	dtFree(navmesh);
 }
 
+dtPolyQuery::~dtPolyQuery()
+{
+	// Defined out of line to fix the weak v-tables warning
+}
+
 //////////////////////////////////////////////////////////////////////////////////////////
 
 /// @class dtNavMeshQuery
@@ -630,6 +635,8 @@ class dtFindNearestPolyQuery : public dtPolyQuery
 	{
 	}
 
+	virtual ~dtFindNearestPolyQuery();
+
 	dtPolyRef nearestRef() const { return m_nearestRef; }
 	const float* nearestPoint() const { return m_nearestPoint; }
 	bool isOverPoly() const { return m_overPoly; }
@@ -672,6 +679,11 @@ class dtFindNearestPolyQuery : public dtPolyQuery
 	}
 };
 
+dtFindNearestPolyQuery::~dtFindNearestPolyQuery()
+{
+	// Defined out of line to fix the weak v-tables warning
+}
+
 /// @par 
 ///
 /// @note If the search box does not intersect any polygons the search will 
@@ -847,6 +859,8 @@ class dtCollectPolysQuery : public dtPolyQuery
 	{
 	}
 
+	virtual ~dtCollectPolysQuery();
+
 	int numCollected() const { return m_numCollected; }
 	bool overflowed() const { return m_overflow; }
 
@@ -868,6 +882,11 @@ class dtCollectPolysQuery : public dtPolyQuery
 	}
 };
 
+dtCollectPolysQuery::~dtCollectPolysQuery()
+{
+	// Defined out of line to fix the weak v-tables warning
+}
+
 /// @par 
 ///
 /// If no polygons are found, the function will return #DT_SUCCESS with a
diff --git a/DetourCrowd/Include/DetourCrowd.h b/DetourCrowd/Include/DetourCrowd.h
index 952050878..854546fc1 100644
--- a/DetourCrowd/Include/DetourCrowd.h
+++ b/DetourCrowd/Include/DetourCrowd.h
@@ -66,7 +66,7 @@ enum CrowdAgentState
 {
 	DT_CROWDAGENT_STATE_INVALID,		///< The agent is not in a valid state.
 	DT_CROWDAGENT_STATE_WALKING,		///< The agent is traversing a normal navigation mesh polygon.
-	DT_CROWDAGENT_STATE_OFFMESH,		///< The agent is traversing an off-mesh connection.
+	DT_CROWDAGENT_STATE_OFFMESH 		///< The agent is traversing an off-mesh connection.
 };
 
 /// Configuration parameters for a crowd agent.
@@ -108,7 +108,7 @@ enum MoveRequestState
 	DT_CROWDAGENT_TARGET_REQUESTING,
 	DT_CROWDAGENT_TARGET_WAITING_FOR_QUEUE,
 	DT_CROWDAGENT_TARGET_WAITING_FOR_PATH,
-	DT_CROWDAGENT_TARGET_VELOCITY,
+	DT_CROWDAGENT_TARGET_VELOCITY
 };
 
 /// Represents an agent managed by a #dtCrowd object.
@@ -188,7 +188,7 @@ enum UpdateFlags
 	DT_CROWD_OBSTACLE_AVOIDANCE = 2,
 	DT_CROWD_SEPARATION = 4,
 	DT_CROWD_OPTIMIZE_VIS = 8,			///< Use #dtPathCorridor::optimizePathVisibility() to optimize the agent path.
-	DT_CROWD_OPTIMIZE_TOPO = 16,		///< Use dtPathCorridor::optimizePathTopology() to optimize the agent path.
+	DT_CROWD_OPTIMIZE_TOPO = 16 		///< Use dtPathCorridor::optimizePathTopology() to optimize the agent path.
 };
 
 struct dtCrowdAgentDebugInfo
diff --git a/DetourTileCache/Include/DetourTileCache.h b/DetourTileCache/Include/DetourTileCache.h
index 75713366d..0d346f17c 100644
--- a/DetourTileCache/Include/DetourTileCache.h
+++ b/DetourTileCache/Include/DetourTileCache.h
@@ -3,16 +3,13 @@
 
 #include "DetourStatus.h"
 
-
-
 typedef unsigned int dtObstacleRef;
-
 typedef unsigned int dtCompressedTileRef;
 
 /// Flags for addTile
 enum dtCompressedTileFlags
 {
-	DT_COMPRESSEDTILE_FREE_DATA = 0x01,					///< Navmesh owns the tile memory and should free it.
+	DT_COMPRESSEDTILE_FREE_DATA = 0x01	///< Navmesh owns the tile memory and should free it.
 };
 
 struct dtCompressedTile
@@ -32,14 +29,14 @@ enum ObstacleState
 	DT_OBSTACLE_EMPTY,
 	DT_OBSTACLE_PROCESSING,
 	DT_OBSTACLE_PROCESSED,
-	DT_OBSTACLE_REMOVING,
+	DT_OBSTACLE_REMOVING
 };
 
 enum ObstacleType
 {
 	DT_OBSTACLE_CYLINDER,
 	DT_OBSTACLE_BOX, // AABB
-	DT_OBSTACLE_ORIENTED_BOX, // OBB
+	DT_OBSTACLE_ORIENTED_BOX // OBB
 };
 
 struct dtObstacleCylinder
@@ -97,13 +94,10 @@ struct dtTileCacheParams
 
 struct dtTileCacheMeshProcess
 {
-	virtual ~dtTileCacheMeshProcess() { }
-
-	virtual void process(struct dtNavMeshCreateParams* params,
-						 unsigned char* polyAreas, unsigned short* polyFlags) = 0;
+	virtual ~dtTileCacheMeshProcess();
+	virtual void process(struct dtNavMeshCreateParams* params, unsigned char* polyAreas, unsigned short* polyFlags) = 0;
 };
 
-
 class dtTileCache
 {
 public:
@@ -219,7 +213,7 @@ class dtTileCache
 	enum ObstacleRequestAction
 	{
 		REQUEST_ADD,
-		REQUEST_REMOVE,
+		REQUEST_REMOVE
 	};
 	
 	struct ObstacleRequest
diff --git a/DetourTileCache/Include/DetourTileCacheBuilder.h b/DetourTileCache/Include/DetourTileCacheBuilder.h
index ff6109193..9a6844c65 100644
--- a/DetourTileCache/Include/DetourTileCacheBuilder.h
+++ b/DetourTileCache/Include/DetourTileCacheBuilder.h
@@ -78,7 +78,7 @@ struct dtTileCachePolyMesh
 
 struct dtTileCacheAlloc
 {
-	virtual ~dtTileCacheAlloc() {}
+	virtual ~dtTileCacheAlloc();
 
 	virtual void reset() {}
 	
@@ -95,7 +95,7 @@ struct dtTileCacheAlloc
 
 struct dtTileCacheCompressor
 {
-	virtual ~dtTileCacheCompressor() { }
+	virtual ~dtTileCacheCompressor();
 
 	virtual int maxCompressedSize(const int bufferSize) = 0;
 	virtual dtStatus compress(const unsigned char* buffer, const int bufferSize,
diff --git a/DetourTileCache/Source/DetourTileCache.cpp b/DetourTileCache/Source/DetourTileCache.cpp
index a82cd1350..6f97ab5b7 100644
--- a/DetourTileCache/Source/DetourTileCache.cpp
+++ b/DetourTileCache/Source/DetourTileCache.cpp
@@ -239,6 +239,11 @@ const dtTileCacheObstacle* dtTileCache::getObstacleByRef(dtObstacleRef ref)
 	return ob;
 }
 
+dtTileCacheMeshProcess::~dtTileCacheMeshProcess()
+{
+	// Defined out of line to fix the weak v-tables warning
+}
+
 dtStatus dtTileCache::addTile(unsigned char* data, const int dataSize, unsigned char flags, dtCompressedTileRef* result)
 {
 	// Make sure the data is in right format.
diff --git a/DetourTileCache/Source/DetourTileCacheBuilder.cpp b/DetourTileCache/Source/DetourTileCacheBuilder.cpp
index 05e34acd1..796e165d3 100644
--- a/DetourTileCache/Source/DetourTileCacheBuilder.cpp
+++ b/DetourTileCache/Source/DetourTileCacheBuilder.cpp
@@ -23,6 +23,15 @@
 #include "DetourTileCacheBuilder.h"
 #include <string.h>
 
+dtTileCacheAlloc::~dtTileCacheAlloc()
+{
+	// Defined out of line to fix the weak v-tables warning
+}
+
+dtTileCacheCompressor::~dtTileCacheCompressor()
+{
+	// Defined out of line to fix the weak v-tables warning
+}
 
 template<class T> class dtFixedArray
 {
diff --git a/Recast/Include/Recast.h b/Recast/Include/Recast.h
index 4d557389b..a36d7add7 100644
--- a/Recast/Include/Recast.h
+++ b/Recast/Include/Recast.h
@@ -28,7 +28,7 @@ enum rcLogCategory
 {
 	RC_LOG_PROGRESS = 1,	///< A progress log entry.
 	RC_LOG_WARNING,			///< A warning log entry.
-	RC_LOG_ERROR,			///< An error log entry.
+	RC_LOG_ERROR			///< An error log entry.
 };
 
 /// Recast performance timer categories.
@@ -101,7 +101,6 @@ enum rcTimerLabel
 class rcContext
 {
 public:
-
 	/// Contructor.
 	///  @param[in]		state	TRUE if the logging and performance timers should be enabled.  [Default: true]
 	inline rcContext(bool state = true) : m_logEnabled(state), m_timerEnabled(state) {}
@@ -140,9 +139,8 @@ class rcContext
 	inline int getAccumulatedTime(const rcTimerLabel label) const { return m_timerEnabled ? doGetAccumulatedTime(label) : -1; }
 
 protected:
-
 	/// Clears all log entries.
-	virtual void doResetLog() {}
+	virtual void doResetLog();
 
 	/// Logs a message.
 	///  @param[in]		category	The category of the message.
@@ -564,7 +562,7 @@ static const int RC_AREA_BORDER = 0x20000;
 enum rcBuildContoursFlags
 {
 	RC_CONTOUR_TESS_WALL_EDGES = 0x01,	///< Tessellate solid (impassable) edges during contour simplification.
-	RC_CONTOUR_TESS_AREA_EDGES = 0x02,	///< Tessellate edges between areas during contour simplification.
+	RC_CONTOUR_TESS_AREA_EDGES = 0x02	///< Tessellate edges between areas during contour simplification.
 };
 
 /// Applied to the region id field of contour vertices in order to extract the region id.
diff --git a/Recast/Source/Recast.cpp b/Recast/Source/Recast.cpp
index 1b71710cd..4cf145c98 100644
--- a/Recast/Source/Recast.cpp
+++ b/Recast/Source/Recast.cpp
@@ -94,6 +94,11 @@ void rcContext::log(const rcLogCategory category, const char* format, ...)
 	doLog(category, msg, len);
 }
 
+void rcContext::doResetLog()
+{
+	// Defined out of line to fix the weak v-tables warning
+}
+
 rcHeightfield* rcAllocHeightfield()
 {
 	return rcNew<rcHeightfield>(RC_ALLOC_PERM);
diff --git a/Recast/Source/RecastMeshDetail.cpp b/Recast/Source/RecastMeshDetail.cpp
index 1999200c1..40bfc9b4b 100644
--- a/Recast/Source/RecastMeshDetail.cpp
+++ b/Recast/Source/RecastMeshDetail.cpp
@@ -284,7 +284,7 @@ static unsigned short getHeight(const float fx, const float fy, const float fz,
 enum EdgeValues
 {
 	EV_UNDEF = -1,
-	EV_HULL = -2,
+	EV_HULL = -2
 };
 
 static int findEdge(const int* edges, int nedges, int s, int t)
diff --git a/RecastDemo/Include/ChunkyTriMesh.h b/RecastDemo/Include/ChunkyTriMesh.h
index 65849799f..0870d64ef 100644
--- a/RecastDemo/Include/ChunkyTriMesh.h
+++ b/RecastDemo/Include/ChunkyTriMesh.h
@@ -29,7 +29,7 @@ struct rcChunkyTriMeshNode
 
 struct rcChunkyTriMesh
 {
-	inline rcChunkyTriMesh() : nodes(0), nnodes(0), tris(0), ntris(0), maxTrisPerChunk(0) {};
+	inline rcChunkyTriMesh() : nodes(0), nnodes(0), tris(0), ntris(0), maxTrisPerChunk(0) {}
 	inline ~rcChunkyTriMesh() { delete [] nodes; delete [] tris; }
 
 	rcChunkyTriMeshNode* nodes;
diff --git a/RecastDemo/Include/CrowdTool.h b/RecastDemo/Include/CrowdTool.h
index 8c170ef47..a2980660f 100644
--- a/RecastDemo/Include/CrowdTool.h
+++ b/RecastDemo/Include/CrowdTool.h
@@ -122,7 +122,7 @@ class CrowdTool : public SampleTool
 		TOOLMODE_CREATE,
 		TOOLMODE_MOVE_TARGET,
 		TOOLMODE_SELECT,
-		TOOLMODE_TOGGLE_POLYS,
+		TOOLMODE_TOGGLE_POLYS
 	};
 	ToolMode m_mode;
 	
diff --git a/RecastDemo/Include/NavMeshTesterTool.h b/RecastDemo/Include/NavMeshTesterTool.h
index 01f46808c..080170ea0 100644
--- a/RecastDemo/Include/NavMeshTesterTool.h
+++ b/RecastDemo/Include/NavMeshTesterTool.h
@@ -43,7 +43,7 @@ class NavMeshTesterTool : public SampleTool
 		TOOLMODE_DISTANCE_TO_WALL,
 		TOOLMODE_FIND_POLYS_IN_CIRCLE,
 		TOOLMODE_FIND_POLYS_IN_SHAPE,
-		TOOLMODE_FIND_LOCAL_NEIGHBOURHOOD,
+		TOOLMODE_FIND_LOCAL_NEIGHBOURHOOD
 	};
 	
 	ToolMode m_toolMode;
@@ -110,4 +110,5 @@ class NavMeshTesterTool : public SampleTool
 	void drawAgent(const float* pos, float r, float h, float c, const unsigned int col);
 };
 
-#endif // NAVMESHTESTERTOOL_H
\ No newline at end of file
+#endif // NAVMESHTESTERTOOL_H
+
diff --git a/RecastDemo/Include/PerfTimer.h b/RecastDemo/Include/PerfTimer.h
index ed62c1805..ce0f296f0 100644
--- a/RecastDemo/Include/PerfTimer.h
+++ b/RecastDemo/Include/PerfTimer.h
@@ -29,4 +29,5 @@ typedef __int64 TimeVal;
 TimeVal getPerfTime();
 int getPerfTimeUsec(const TimeVal duration);
 
-#endif // PERFTIMER_H
\ No newline at end of file
+#endif // PERFTIMER_H
+
diff --git a/RecastDemo/Include/Sample.h b/RecastDemo/Include/Sample.h
index aa46f860a..608c3dbea 100644
--- a/RecastDemo/Include/Sample.h
+++ b/RecastDemo/Include/Sample.h
@@ -47,7 +47,7 @@ enum SamplePolyAreas
 	SAMPLE_POLYAREA_ROAD,
 	SAMPLE_POLYAREA_DOOR,
 	SAMPLE_POLYAREA_GRASS,
-	SAMPLE_POLYAREA_JUMP,
+	SAMPLE_POLYAREA_JUMP
 };
 enum SamplePolyFlags
 {
@@ -69,12 +69,12 @@ enum SamplePartitionType
 {
 	SAMPLE_PARTITION_WATERSHED,
 	SAMPLE_PARTITION_MONOTONE,
-	SAMPLE_PARTITION_LAYERS,
+	SAMPLE_PARTITION_LAYERS
 };
 
 struct SampleTool
 {
-	virtual ~SampleTool() {}
+	virtual ~SampleTool();
 	virtual int type() = 0;
 	virtual void init(class Sample* sample) = 0;
 	virtual void reset() = 0;
@@ -88,7 +88,7 @@ struct SampleTool
 };
 
 struct SampleToolState {
-	virtual ~SampleToolState() {}
+	virtual ~SampleToolState();
 	virtual void init(class Sample* sample) = 0;
 	virtual void reset() = 0;
 	virtual void handleRender() = 0;
diff --git a/RecastDemo/Include/TestCase.h b/RecastDemo/Include/TestCase.h
index 49dcb2348..8991e576f 100644
--- a/RecastDemo/Include/TestCase.h
+++ b/RecastDemo/Include/TestCase.h
@@ -27,7 +27,7 @@ class TestCase
 	enum TestType
 	{
 		TEST_PATHFIND,
-		TEST_RAYCAST,
+		TEST_RAYCAST
 	};
 	
 	struct Test
@@ -111,4 +111,4 @@ class TestCase
 	TestCase& operator=(const TestCase&);
 };
 
-#endif // TESTCASE_H
\ No newline at end of file
+#endif // TESTCASE_H
diff --git a/RecastDemo/Include/ValueHistory.h b/RecastDemo/Include/ValueHistory.h
index 2da53902a..1e83a2110 100644
--- a/RecastDemo/Include/ValueHistory.h
+++ b/RecastDemo/Include/ValueHistory.h
@@ -47,4 +47,5 @@ void drawGraph(const GraphParams* p, const ValueHistory* graph,
 			   int idx, const char* label, const unsigned int col);
 
 
-#endif // VALUEHISTORY_H
\ No newline at end of file
+#endif // VALUEHISTORY_H
+
diff --git a/RecastDemo/Include/imgui.h b/RecastDemo/Include/imgui.h
index 325829b3d..3d7346ef1 100644
--- a/RecastDemo/Include/imgui.h
+++ b/RecastDemo/Include/imgui.h
@@ -22,14 +22,14 @@
 enum imguiMouseButton
 {
 	IMGUI_MBUT_LEFT = 0x01, 
-	IMGUI_MBUT_RIGHT = 0x02, 
+	IMGUI_MBUT_RIGHT = 0x02
 };
 
 enum imguiTextAlign
 {
 	IMGUI_ALIGN_LEFT,
 	IMGUI_ALIGN_CENTER,
-	IMGUI_ALIGN_RIGHT,
+	IMGUI_ALIGN_RIGHT
 };
 
 inline unsigned int imguiRGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a=255)
@@ -68,7 +68,7 @@ enum imguiGfxCmdType
 	IMGUI_GFXCMD_TRIANGLE,
 	IMGUI_GFXCMD_LINE,
 	IMGUI_GFXCMD_TEXT,
-	IMGUI_GFXCMD_SCISSOR,
+	IMGUI_GFXCMD_SCISSOR
 };
 
 struct imguiGfxRect
diff --git a/RecastDemo/Include/imguiRenderGL.h b/RecastDemo/Include/imguiRenderGL.h
index b14834169..33cd017ce 100644
--- a/RecastDemo/Include/imguiRenderGL.h
+++ b/RecastDemo/Include/imguiRenderGL.h
@@ -23,4 +23,5 @@ bool imguiRenderGLInit(const char* fontpath);
 void imguiRenderGLDestroy();
 void imguiRenderGLDraw();
 
-#endif // IMGUI_RENDER_GL_H
\ No newline at end of file
+#endif // IMGUI_RENDER_GL_H
+
diff --git a/RecastDemo/Source/Filelist.cpp b/RecastDemo/Source/Filelist.cpp
index 7e0513040..bd715c47b 100644
--- a/RecastDemo/Source/Filelist.cpp
+++ b/RecastDemo/Source/Filelist.cpp
@@ -55,10 +55,10 @@ void scanDirectoryAppend(const string& path, const string& ext, vector<string>&
 		return;
 	}
 	
-	int extLen = strlen(ext.c_str());
+	size_t extLen = strlen(ext.c_str());
 	while ((current = readdir(dp)) != 0)
 	{
-		int len = strlen(current->d_name);
+		size_t len = strlen(current->d_name);
 		if (len > extLen && strncmp(current->d_name + len - extLen, ext.c_str(), extLen) == 0)
 		{
 			filelist.push_back(current->d_name);
diff --git a/RecastDemo/Source/Sample.cpp b/RecastDemo/Source/Sample.cpp
index d8c4cfdb1..2b5a7a2dc 100644
--- a/RecastDemo/Source/Sample.cpp
+++ b/RecastDemo/Source/Sample.cpp
@@ -35,6 +35,16 @@
 #	define snprintf _snprintf
 #endif
 
+SampleTool::~SampleTool()
+{
+	// Defined out of line to fix the weak v-tables warning
+}
+
+SampleToolState::~SampleToolState()
+{
+	// Defined out of line to fix the weak v-tables warning
+}
+
 unsigned int SampleDebugDraw::areaToCol(unsigned int area)
 {
 	switch(area)
diff --git a/RecastDemo/Source/SampleInterfaces.cpp b/RecastDemo/Source/SampleInterfaces.cpp
index 72bb34c28..a9fd3ae54 100644
--- a/RecastDemo/Source/SampleInterfaces.cpp
+++ b/RecastDemo/Source/SampleInterfaces.cpp
@@ -184,7 +184,7 @@ class GLCheckerTexture
 		}
 	}
 };
-GLCheckerTexture g_tex;
+static GLCheckerTexture g_tex;
 
 
 void DebugDrawGL::depthMask(bool state)
diff --git a/RecastDemo/Source/Sample_TempObstacles.cpp b/RecastDemo/Source/Sample_TempObstacles.cpp
index 6c1367f20..4dd4e5f00 100644
--- a/RecastDemo/Source/Sample_TempObstacles.cpp
+++ b/RecastDemo/Source/Sample_TempObstacles.cpp
@@ -109,6 +109,8 @@ static int calcLayerBufferSize(const int gridWidth, const int gridHeight)
 
 struct FastLZCompressor : public dtTileCacheCompressor
 {
+	virtual ~FastLZCompressor();
+
 	virtual int maxCompressedSize(const int bufferSize)
 	{
 		return (int)(bufferSize* 1.05f);
@@ -129,6 +131,11 @@ struct FastLZCompressor : public dtTileCacheCompressor
 	}
 };
 
+FastLZCompressor::~FastLZCompressor()
+{
+	// Defined out of line to fix the weak v-tables warning
+}
+
 struct LinearAllocator : public dtTileCacheAlloc
 {
 	unsigned char* buffer;
@@ -141,10 +148,7 @@ struct LinearAllocator : public dtTileCacheAlloc
 		resize(cap);
 	}
 	
-	~LinearAllocator()
-	{
-		dtFree(buffer);
-	}
+	virtual ~LinearAllocator();
 
 	void resize(const size_t cap)
 	{
@@ -176,6 +180,12 @@ struct LinearAllocator : public dtTileCacheAlloc
 	}
 };
 
+LinearAllocator::~LinearAllocator()
+{
+	// Defined out of line to fix the weak v-tables warning
+	dtFree(buffer);
+}
+
 struct MeshProcess : public dtTileCacheMeshProcess
 {
 	InputGeom* m_geom;
@@ -184,6 +194,8 @@ struct MeshProcess : public dtTileCacheMeshProcess
 	{
 	}
 
+	virtual ~MeshProcess();
+
 	inline void init(InputGeom* geom)
 	{
 		m_geom = geom;
@@ -228,8 +240,10 @@ struct MeshProcess : public dtTileCacheMeshProcess
 	}
 };
 
-
-
+MeshProcess::~MeshProcess()
+{
+	// Defined out of line to fix the weak v-tables warning
+}
 
 static const int MAX_LAYERS = 32;
 
@@ -494,7 +508,7 @@ enum DrawDetailType
 	DRAWDETAIL_AREAS,
 	DRAWDETAIL_REGIONS,
 	DRAWDETAIL_CONTOURS,
-	DRAWDETAIL_MESH,
+	DRAWDETAIL_MESH
 };
 
 void drawDetail(duDebugDraw* dd, dtTileCache* tc, const int tx, const int ty, int type)
@@ -667,9 +681,6 @@ void drawObstacles(duDebugDraw* dd, const dtTileCache* tc)
 	}
 }
 
-
-
-
 class TempObstacleHilightTool : public SampleTool
 {
 	Sample_TempObstacles* m_sample;
@@ -687,9 +698,7 @@ class TempObstacleHilightTool : public SampleTool
 		m_hitPos[0] = m_hitPos[1] = m_hitPos[2] = 0;
 	}
 
-	virtual ~TempObstacleHilightTool()
-	{
-	}
+	virtual ~TempObstacleHilightTool();
 
 	virtual int type() { return TOOL_TILE_HIGHLIGHT; }
 
@@ -764,6 +773,10 @@ class TempObstacleHilightTool : public SampleTool
 	}
 };
 
+TempObstacleHilightTool::~TempObstacleHilightTool()
+{
+	// Defined out of line to fix the weak v-tables warning
+}
 
 class TempObstacleCreateTool : public SampleTool
 {
@@ -775,9 +788,7 @@ class TempObstacleCreateTool : public SampleTool
 	{
 	}
 	
-	virtual ~TempObstacleCreateTool()
-	{
-	}
+	virtual ~TempObstacleCreateTool();
 	
 	virtual int type() { return TOOL_TEMP_OBSTACLE; }
 	
@@ -819,9 +830,10 @@ class TempObstacleCreateTool : public SampleTool
 	virtual void handleRenderOverlay(double* /*proj*/, double* /*model*/, int* /*view*/) { }
 };
 
-
-
-
+TempObstacleCreateTool::~TempObstacleCreateTool()
+{
+	// Defined out of line to fix the weak v-tables warning
+}
 
 Sample_TempObstacles::Sample_TempObstacles() :
 	m_keepInterResults(false),
diff --git a/RecastDemo/Source/Sample_TileMesh.cpp b/RecastDemo/Source/Sample_TileMesh.cpp
index 1de558184..42fe3078b 100644
--- a/RecastDemo/Source/Sample_TileMesh.cpp
+++ b/RecastDemo/Source/Sample_TileMesh.cpp
@@ -87,9 +87,7 @@ class NavMeshTileTool : public SampleTool
 		m_hitPos[0] = m_hitPos[1] = m_hitPos[2] = 0;
 	}
 
-	virtual ~NavMeshTileTool()
-	{
-	}
+	virtual ~NavMeshTileTool();
 
 	virtual int type() { return TOOL_TILE_EDIT; }
 
@@ -172,8 +170,10 @@ class NavMeshTileTool : public SampleTool
 	}
 };
 
-
-
+NavMeshTileTool::~NavMeshTileTool()
+{
+	// Defined out of line to fix the weak v-tables warning
+}
 
 Sample_TileMesh::Sample_TileMesh() :
 	m_keepInterResults(false),
diff --git a/RecastDemo/Source/main.cpp b/RecastDemo/Source/main.cpp
index 1a31e75fc..90c6dbb3c 100644
--- a/RecastDemo/Source/main.cpp
+++ b/RecastDemo/Source/main.cpp
@@ -135,7 +135,6 @@ int main(int /*argc*/, char** /*argv*/)
 		return -1;
 	}
 	
-	float t = 0.0f;
 	float timeAcc = 0.0f;
 	Uint32 prevFrameTime = SDL_GetTicks();
 	int mousePos[2] = {0, 0};
@@ -354,8 +353,6 @@ int main(int /*argc*/, char** /*argv*/)
 		Uint32 time = SDL_GetTicks();
 		float dt = (time - prevFrameTime) / 1000.0f;
 		prevFrameTime = time;
-		
-		t += dt;
 
 		// Hit test mesh.
 		if (processHitTest && geom && sample)

From 17a19d0e826ac5454146db6f38485b684cdc8897 Mon Sep 17 00:00:00 2001
From: Graham Pentheny <grahamboree@users.noreply.github.com>
Date: Fri, 11 Nov 2022 21:04:29 -0500
Subject: [PATCH 41/51] Simplified macOS Build Process (#579)

This makes the default xcode project generated by premake work out of the box, and is generally easier for mac users.  Especially those who don't have permissions to modify /Library/Frameworks/

- Look for SDL in RecastDemo/Bin by default rather than /Library/Frameworks/
- Updated README build instructions
- Ignore SDL2.framework in RecastDemo/Bin
---
 README.md                 | 35 +++++++++++++++++------------------
 RecastDemo/Bin/.gitignore |  1 +
 RecastDemo/premake5.lua   |  7 ++-----
 3 files changed, 20 insertions(+), 23 deletions(-)

diff --git a/README.md b/README.md
index 6f8fae903..8fca544b9 100644
--- a/README.md
+++ b/README.md
@@ -24,20 +24,12 @@ the regions as simple polygons.
 2. The walkable areas described by the mold are divided into simple overlayed 2D regions. The resulting regions have only one non-overlapping contour, which simplifies the final step of the process tremendously.
 3. The navigation polygons are peeled off from the regions by first tracing the boundaries and then simplifying them. The resulting polygons are finally converted to convex polygons which makes them perfect for pathfinding and spatial reasoning about the level. 
 
-
 ## Detour
 
 Recast is accompanied with Detour, path-finding and spatial reasoning toolkit. You can use any navigation mesh with Detour, but of course the data generated with Recast fits perfectly.
 
 Detour offers simple static navigation mesh which is suitable for many simple cases, as well as tiled navigation mesh which allows you to plug in and out pieces of the mesh. The tiled mesh allows you to create systems where you stream new navigation data in and out as the player progresses the level, or you may regenerate tiles as the world changes. 
 
-## Installation through vcpkg
-
-If you are using the [vcpkg](https://github.com/Microsoft/vcpkg/) dependency manager you can download and install Recast with a single command:
-```
-vcpkg install recast
-```
-
 ## Recast Demo
 
 You can find a comprehensive demo project in RecastDemo folder. It is a kitchen sink demo containing all the functionality of the library. If you are new to Recast & Detour, check out [Sample_SoloMesh.cpp](/RecastDemo/Source/Sample_SoloMesh.cpp) to get started with building navmeshes and [NavMeshTesterTool.cpp](/RecastDemo/Source/NavMeshTesterTool.cpp) to see how Detour can be used to find paths.
@@ -49,24 +41,23 @@ RecastDemo uses [premake5](http://premake.github.io/) to build platform specific
 #### Linux
 
 - Install SDL2 and its dependencies according to your distro's guidelines.
-- run `premake5 gmake` from the `RecastDemo` folder.
-- `cd Build/gmake` then `make`
-- `cd RecastDemo/Bin` and then run `./RecastDemo`
+- Navigate to the `RecastDemo` folder and run `premake5 gmake2`
+- Navigate to `RecastDemo/Build/gmake2` and run `make`
+- Navigate to `RecastDemo/Bin` and run `./RecastDemo`
 
-#### OSX
+#### macOS
 
-- Grab the latest SDL2 development library dmg from [here](https://www.libsdl.org/download-2.0.php) and place `SDL2.framework` in `/Library/Frameworks/`
+- Grab the latest SDL2 development library dmg from [here](https://github.com/libsdl-org/SDL) and place `SDL2.framework` in `RecastDemo/Bin`
 - Navigate to the `RecastDemo` folder and run `premake5 xcode4`
 - Open `Build/xcode4/recastnavigation.xcworkspace`
-- Select the "RecastDemo" project in the left pane, go to the "BuildPhases" tab and expand "Link Binary With Libraries"
-- Remove the existing entry for SDL2 (it should have a white box icon) and re-add it by hitting the plus, selecting "Add Other", and selecting `/Library/Frameworks/SDL2.framework`.  It should now have a suitcase icon.
 - Set the RecastDemo project as the target and build.
 
 #### Windows
 
-- Grab the latest SDL2 development library release from [here](https://www.libsdl.org/download-2.0.php) and unzip it `RecastDemo\Contrib`.  Rename the SDL folder such that the path `RecastDemo\Contrib\SDL\lib\x86` is valid.
-- Run `"premake5" vs2019` from the `RecastDemo` folder
-- Open the solution, build, and run.
+- Grab the latest SDL2 development library release from [here](https://github.com/libsdl-org/SDL) and unzip it `RecastDemo\Contrib`.  Rename the SDL folder such that the path `RecastDemo\Contrib\SDL\lib\x86` is valid.
+- Navigate to the `RecastDemo` folder and run `premake5 vs2022`
+- Open `Build/vs2022/recastnavigation.sln`.
+- Set `RecastDemo` as the startup project, build, and run.
 
 ### Running Unit tests
 
@@ -78,6 +69,14 @@ RecastDemo uses [premake5](http://premake.github.io/) to build platform specific
 
 It is recommended to add the source directories `DebugUtils`, `Detour`, `DetourCrowd`, `DetourTileCache`, and `Recast` into your own project depending on which parts of the project you need. For example your level building tool could include `DebugUtils`, `Recast`, and `Detour`, and your game runtime could just include `Detour`.
 
+### Installation through vcpkg
+
+If you are using the [vcpkg](https://github.com/Microsoft/vcpkg/) dependency manager you can download and install Recast with:
+
+```
+vcpkg install recast
+```
+
 ## Contributing
 
 See the [Contributing document](CONTRIBUTING.md) for guidelines for making contributions.
diff --git a/RecastDemo/Bin/.gitignore b/RecastDemo/Bin/.gitignore
index c44262faf..f6861ba21 100644
--- a/RecastDemo/Bin/.gitignore
+++ b/RecastDemo/Bin/.gitignore
@@ -1 +1,2 @@
 Recast.app
+SDL2.framework
\ No newline at end of file
diff --git a/RecastDemo/premake5.lua b/RecastDemo/premake5.lua
index 8330b061e..52bbaf93b 100644
--- a/RecastDemo/premake5.lua
+++ b/RecastDemo/premake5.lua
@@ -188,7 +188,7 @@ project "RecastDemo"
 	-- mac includes and libs
 	filter "system:macosx"
 		kind "ConsoleApp" -- xcode4 failes to run the project if using WindowedApp
-		includedirs { "/Library/Frameworks/SDL2.framework/Headers" }
+		includedirs { "Bin/SDL2.framework/Headers" }
 		links { 
 			"OpenGL.framework", 
 			"SDL2.framework",
@@ -268,9 +268,6 @@ project "Tests"
 	-- mac includes and libs
 	filter "system:macosx"
 		kind "ConsoleApp"
-		includedirs { "/Library/Frameworks/SDL2.framework/Headers" }
-		links { 
-			"OpenGL.framework", 
-			"SDL2.framework",
+		links {
 			"Cocoa.framework",
 		}

From 3d0f0a3d9e27590e30d910d992188ccf370ac10b Mon Sep 17 00:00:00 2001
From: Graham Pentheny <grahamboree@users.noreply.github.com>
Date: Sat, 12 Nov 2022 13:27:46 -0500
Subject: [PATCH 42/51] Github Workflows based CI system to replace Appveyor
 and Travis (#580)

The goal here is to replace the current (slightly broken) Travis + Appveyor setup with something that covers more cases and is a bit better supported and easier to maintain. This hopefully helps us catch cross-platform issues quicker. For example, the linux and clang compilation issues that have existed for a while could have been caught if we were building those targets in CI.

This adds a build script that builds the following configurations for every repo commit and PR:

    macOS, premake, Debug
    macOS, premake, Release
    linux, premake, gcc, Debug
    linux, premake, gcc, Release
    linux, premake, clang, Debug
    linux, premake, clang, Release
    linux, cmake, Debug
    linux, cmake, Release
    windows, premake, vs2019, Debug
    windows, premake, vs2019, Release
    windows, premake, vs2022, Debug
    windows, premake, vs2022, Release
    windows, cmake, vs2019, Debug
    windows, cmake, vs2019, Release
    windows, cmake, vs2022, Debug
    windows, cmake, vs2022, Release

It also builds and runs the catch tests executable in the following configurations. A failed test will fail the build.

    macOS, premake, Debug
    linux, premake, clang, Debug
    windows, premake, vs2022, Debug

It doesn't currently build cmake on macOS because there is a one blocker there (#577). We could also add additional builds like cmake with both clang and gcc on linux, but for now this is much better coverage than we have currently.
---
 .github/workflows/Build.yaml | 190 +++++++++++++++++++++++++++++++++++
 .github/workflows/Tests.yaml | 107 ++++++++++++++++++++
 .travis.yml                  |  52 ----------
 appveyor.yml                 |  50 ---------
 4 files changed, 297 insertions(+), 102 deletions(-)
 create mode 100644 .github/workflows/Build.yaml
 create mode 100644 .github/workflows/Tests.yaml
 delete mode 100644 .travis.yml
 delete mode 100644 appveyor.yml

diff --git a/.github/workflows/Build.yaml b/.github/workflows/Build.yaml
new file mode 100644
index 000000000..eb45d5692
--- /dev/null
+++ b/.github/workflows/Build.yaml
@@ -0,0 +1,190 @@
+name: Build
+
+on:
+  push:
+    branches: [ "**" ]
+  pull_request:
+    branches: [ "**" ]
+
+jobs:
+  macOS-premake:
+    strategy:
+      matrix:
+        conf:
+          - Debug
+          - Release
+
+    runs-on: macos-latest
+    
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Download & install SDL
+      run: |
+        curl -L -o SDL2.dmg https://github.com/libsdl-org/SDL/releases/download/release-2.24.2/SDL2-2.24.2.dmg
+        hdiutil attach SDL2.dmg
+        cp -r /Volumes/SDL2/SDL2.framework RecastDemo/Bin
+        hdiutil detach /Volumes/SDL2
+        rm SDL2.dmg
+
+    - name: Download & install premake
+      working-directory: RecastDemo
+      run: |
+        curl -L -o premake.tar.gz https://github.com/premake/premake-core/releases/download/v5.0.0-beta2/premake-5.0.0-beta2-macosx.tar.gz
+        tar -xzf premake.tar.gz
+        rm premake.tar.gz
+
+    - name: Run premake
+      working-directory: RecastDemo
+      run: ./premake5 xcode4
+
+    - name: Build With Xcode
+      working-directory: RecastDemo/Build/xcode4/
+      run: xcodebuild -scheme RecastDemo -configuration ${{matrix.conf}} -project RecastDemo.xcodeproj build
+    
+    - name: Build Unit Tests With Xcode
+      working-directory: RecastDemo/Build/xcode4/
+      run: xcodebuild -scheme Tests -configuration ${{matrix.conf}} -project Tests.xcodeproj build
+  
+  linux-premake:
+    strategy:
+      matrix:
+        conf:
+          - debug
+          - release
+        compiler:
+          - clang
+          - gcc
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Install opengl and SDL
+      run: sudo apt-get install -y libgl1-mesa-dev libsdl2-dev
+
+    - name: Download & Install premake
+      working-directory: RecastDemo
+      run: |
+        curl -L -o premake.tar.gz https://github.com/premake/premake-core/releases/download/v5.0.0-beta2/premake-5.0.0-beta2-linux.tar.gz
+        tar -xzf premake.tar.gz
+        rm premake.tar.gz
+    
+    - name: Run premake
+      working-directory: RecastDemo
+      run: ./premake5 --cc=${{matrix.compiler}} gmake2
+    
+    - name: Build
+      working-directory: RecastDemo/Build/gmake2
+      run: make config=${{matrix.conf}} verbose=true
+    
+  linux-cmake:
+    strategy:
+      matrix:
+        conf:
+          - Debug
+          - Release
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Install opengl and SDL
+      run: sudo apt-get install -y libgl1-mesa-dev libsdl2-dev
+
+    - name: Configure CMake
+      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{matrix.conf}}
+
+    - name: Build
+      run: cmake --build ${{github.workspace}}/build --config ${{matrix.conf}}
+  
+  windows-premake:
+    strategy:
+      matrix:
+        conf:
+          - Debug
+          - Release
+        vs-version:
+          - vs2019
+          - vs2022
+        include:
+          - vs-version: vs2019
+            version-range: '16.0'
+            runner: windows-2019
+          - vs-version: vs2022
+            version-range: '17.0'
+            runner: windows-2022
+
+    runs-on: ${{matrix.runner}}
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Add msbuild to PATH
+      uses: microsoft/setup-msbuild@v1.1
+      with:
+        vs-version: ${{matrix.version-range}}
+
+    - name: Download and Install SDL
+      working-directory: RecastDemo/Contrib
+      shell: pwsh
+      run: |
+        (new-object System.Net.WebClient).DownloadFile("https://github.com/libsdl-org/SDL/releases/download/release-2.24.2/SDL2-devel-2.24.2-VC.zip","${{github.workspace}}/RecastDemo/Contrib/SDL.zip")
+        tar -xf SDL.zip
+        ren SDL2-2.24.2 SDL
+        del SDL.zip
+
+    - name: Download and Install Premake
+      working-directory: RecastDemo
+      shell: pwsh
+      run: |
+        (new-object System.Net.WebClient).DownloadFile("https://github.com/premake/premake-core/releases/download/v5.0.0-beta2/premake-5.0.0-beta2-windows.zip","${{github.workspace}}/RecastDemo/premake.zip")
+        tar -xf premake.zip
+        del premake.zip
+
+    - name: Run Premake
+      working-directory: RecastDemo
+      run: ./premake5.exe ${{matrix.vs-version}}
+
+    - name: Build
+      working-directory: RecastDemo/Build/${{matrix.vs-version}}
+      run: msbuild RecastDemo.vcxproj -property:Configuration=${{matrix.conf}}
+
+  windows-cmake:
+    strategy:
+      matrix:
+        conf:
+          - Debug
+          - Release
+        vs-version:
+          - vs2019
+          - vs2022
+        include:
+          - vs-version: vs2019
+            cmake-generator: Visual Studio 16 2019
+            runner: windows-2019
+          - vs-version: vs2022
+            cmake-generator: Visual Studio 17 2022
+            runner: windows-2022
+
+    runs-on: ${{matrix.runner}}
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Download and Install SDL
+      working-directory: RecastDemo/Contrib
+      shell: pwsh
+      run: |
+        (new-object System.Net.WebClient).DownloadFile("https://github.com/libsdl-org/SDL/releases/download/release-2.24.2/SDL2-devel-2.24.2-VC.zip","${{github.workspace}}/RecastDemo/Contrib/SDL.zip")
+        tar -xf SDL.zip
+        ren SDL2-2.24.2 SDL
+        del SDL.zip
+
+    - name: Configure CMake
+      run: cmake -G "${{matrix.cmake-generator}}" -B ${{github.workspace}}/build -D CMAKE_BUILD_TYPE=${{matrix.conf}} -D CMAKE_INSTALL_PREFIX=${{github.workspace}}/build
+
+    - name: Build with CMake
+      run: cmake --build ${{github.workspace}}/build --config ${{matrix.conf}}
diff --git a/.github/workflows/Tests.yaml b/.github/workflows/Tests.yaml
new file mode 100644
index 000000000..149fa01a9
--- /dev/null
+++ b/.github/workflows/Tests.yaml
@@ -0,0 +1,107 @@
+name: Tests
+
+on:
+  push:
+    branches: [ "**" ]
+  pull_request:
+    branches: [ "**" ]
+
+jobs:
+  macos-tests:
+    runs-on: macos-latest
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Download & install SDL
+      run: |
+        curl -L -o SDL2.dmg https://github.com/libsdl-org/SDL/releases/download/release-2.24.2/SDL2-2.24.2.dmg
+        hdiutil attach SDL2.dmg
+        cp -r /Volumes/SDL2/SDL2.framework RecastDemo/Bin
+        hdiutil detach /Volumes/SDL2
+        rm SDL2.dmg
+
+    - name: Download & install premake
+      working-directory: RecastDemo
+      run: |
+        curl -L -o premake.tar.gz https://github.com/premake/premake-core/releases/download/v5.0.0-beta2/premake-5.0.0-beta2-macosx.tar.gz
+        tar -xzf premake.tar.gz
+        rm premake.tar.gz
+
+    - name: Run premake
+      working-directory: RecastDemo
+      run: ./premake5 xcode4
+
+    - name: Build Unit Tests With Xcode
+      working-directory: RecastDemo/Build/xcode4/
+      run: xcodebuild -scheme Tests -configuration Debug -project Tests.xcodeproj build
+
+    - name: Run unit tests
+      working-directory: RecastDemo/Bin
+      run: ./Tests
+  
+  linux-tests:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Install opengl and SDL
+      run: sudo apt-get install -y libgl1-mesa-dev libsdl2-dev
+
+    - name: Download & Install premake
+      working-directory: RecastDemo
+      run: |
+        curl -L -o premake.tar.gz https://github.com/premake/premake-core/releases/download/v5.0.0-beta2/premake-5.0.0-beta2-linux.tar.gz
+        tar -xzf premake.tar.gz
+        rm premake.tar.gz
+    
+    - name: Run premake
+      working-directory: RecastDemo
+      run: ./premake5 --cc=clang gmake2
+    
+    - name: Build
+      working-directory: RecastDemo/Build/gmake2
+      run: make config=debug verbose=true
+    
+    - name: Run Tests
+      working-directory: RecastDemo/Bin
+      run: ./Tests
+  
+  windows-tests:
+    runs-on: windows-2022
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Add msbuild to PATH
+      uses: microsoft/setup-msbuild@v1.1
+
+    - name: Download and Install SDL
+      working-directory: RecastDemo/Contrib
+      shell: pwsh
+      run: |
+        (new-object System.Net.WebClient).DownloadFile("https://github.com/libsdl-org/SDL/releases/download/release-2.24.2/SDL2-devel-2.24.2-VC.zip","${{github.workspace}}/RecastDemo/Contrib/SDL.zip")
+        tar -xf SDL.zip
+        ren SDL2-2.24.2 SDL
+        del SDL.zip
+
+    - name: Download and Install Premake
+      working-directory: RecastDemo
+      shell: pwsh
+      run: |
+        (new-object System.Net.WebClient).DownloadFile("https://github.com/premake/premake-core/releases/download/v5.0.0-beta2/premake-5.0.0-beta2-windows.zip","${{github.workspace}}/RecastDemo/premake.zip")
+        tar -xf premake.zip
+        del premake.zip
+
+    - name: Run Premake
+      working-directory: RecastDemo
+      run: ./premake5.exe vs2022
+
+    - name: Build
+      working-directory: RecastDemo/Build/vs2022
+      run: msbuild Tests.vcxproj -property:Configuration=Debug
+
+    - name: Run Tests
+      working-directory: RecastDemo/Bin/
+      run: ./Tests.exe
\ No newline at end of file
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index 6cd8bbc2b..000000000
--- a/.travis.yml
+++ /dev/null
@@ -1,52 +0,0 @@
-language: cpp
-os: linux
-dist: bionic
-branches:
-  only:
-  - master
-  - coverity_scan
-  - /recast-.*$/
-
-sudo: false
-
-addons:
-  apt:
-    packages: [ build-essential, cmake, clang, clang-tools, libsdl2-dev ]
-
-matrix:
-  include:
-  - name: Recastnavigation on MacOS using XCode
-    os: osx
-    osx_image: xcode12.2
-    before_install:
-      - brew update
-      - brew install sdl2
-    if: branch != coverity_scan
-  - name: Recastnavigation on Ubuntu GCC
-    if: branch != coverity_scan
-  - name: Recastnavigation on Ubuntu GCC using Premake5
-    if: branch != coverity_scan
-    before_install:
-      - wget https://github.com/premake/premake-core/releases/download/v5.0.0-alpha12/premake-5.0.0-alpha12-linux.tar.gz -O premake.tar.gz
-      - tar -xf premake.tar.gz
-    env:
-      - PREMAKE=1
-  - name: Recastnavigation on Ubuntu Clang with Static Analysis
-    env:
-      - MATRIX_EVAL="CC=clang && CXX=clang++"
-      - ANALYZE="scan-build --force-analyze-debug-code --use-cc clang --use-c++ clang++"
-    if: branch != coverity_scan
-    compiler: clang
-  - name: Recastnavigation Coverity Scan
-    if: branch = coverity_scan
-
-before_script:
-  - if [ "${TRAVIS_OS_NAME}" = "linux" ]; then eval "${MATRIX_EVAL}"; fi
-  - if [ "${PREMAKE}" = "1" ]; then cd RecastDemo && ../premake5 gmake && cd ..; fi
-  - if [ "${PREMAKE}" != "1" ]; then mkdir -p build && cd build && ${ANALYZE} cmake ../ && cd ..; fi
-
-script:  # 2 CPUs on Travis-CI + 1 extra for IO bound process
-  - if [ "${PREMAKE}" = "1" ]; then make -C RecastDemo/Build/gmake -j3; fi
-  - if [ "${PREMAKE}" != "1" ]; then make -C build -j3; fi
-  - if [ "${PREMAKE}" = "1" ]; then RecastDemo/Bin/Tests; fi
-  - if [ "${PREMAKE}" != "1" ]; then cd build && ctest; fi
diff --git a/appveyor.yml b/appveyor.yml
deleted file mode 100644
index dd4e3ab2b..000000000
--- a/appveyor.yml
+++ /dev/null
@@ -1,50 +0,0 @@
-shallow_clone: true
-
-environment:
-  matrix:
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      PREMAKE_ACTION: vs2017
-      CMAKE_GENERATOR: Visual Studio 15 2017 Win64
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
-      PREMAKE_ACTION: vs2019
-      CMAKE_GENERATOR: Visual Studio 16 2019
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2022
-      PREMAKE_ACTION: vs2022
-      CMAKE_GENERATOR: Visual Studio 17 2022
-
-configuration:
-  - Debug
-  - Release
-
-platform:
-  - Win64
-
-install:
-  # Download Premake
-  - ps: Start-FileDownload 'https://github.com/premake/premake-core/releases/download/v5.0.0-beta2/premake-5.0.0-beta2-windows.zip' 'premake.zip'
-  
-  # Extract it in-place; premake5.exe is at the top level.
-  - 7z x premake.zip
-
-  # Download SDL.
-  - ps: Start-FileDownload 'https://www.libsdl.org/release/SDL2-devel-2.0.4-VC.zip' 'RecastDemo/Contrib/SDL.zip'
-
-  # Extract it, put it in the right place, and rename it.
-  - cd RecastDemo\Contrib && 7z x SDL.zip && ren SDL2-2.0.4 SDL && cd ..\..
-
-  # Generate solution files using premake.
-  - cd RecastDemo && "../premake5.exe" %PREMAKE_ACTION% && cd ..
-
-build:
-  project: RecastDemo/Build/$(PREMAKE_ACTION)/recastnavigation.sln
-
-after_build:
-  - mkdir build
-  - cd build
-  - cmake -G "%CMAKE_GENERATOR%" -DCMAKE_BUILD_TYPE="%CONFIGURATION%" -D CMAKE_INSTALL_PREFIX=. ..
-  - cmake --build . --config "%CONFIGURATION%" --target install -- /m:%NUMBER_OF_PROCESSORS%
-  - ctest -V
-  - cd ..
-
-after_test:
-  - RecastDemo\Bin\Tests.exe

From b1e04cf59c2df39faae7a3eebde5167e2f49ea00 Mon Sep 17 00:00:00 2001
From: Graham Pentheny <grahamboree@users.noreply.github.com>
Date: Sat, 12 Nov 2022 13:37:41 -0500
Subject: [PATCH 43/51] Updated build badges in Readme to use workflows

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 8fca544b9..8adba6b54 100644
--- a/README.md
+++ b/README.md
@@ -2,8 +2,8 @@
 Recast & Detour
 ===============
 
-[![Travis (Linux) Build Status](https://travis-ci.org/recastnavigation/recastnavigation.svg?branch=master)](https://travis-ci.org/recastnavigation/recastnavigation)
-[![Appveyor (Windows) Build  Status](https://ci.appveyor.com/api/projects/status/20w84u25b3f8h179/branch/master?svg=true)](https://ci.appveyor.com/project/recastnavigation/recastnavigation/branch/master)
+[![Build](https://github.com/recastnavigation/recastnavigation/actions/workflows/Build.yaml/badge.svg)](https://github.com/recastnavigation/recastnavigation/actions/workflows/Build.yaml)
+[![Tests](https://github.com/recastnavigation/recastnavigation/actions/workflows/Tests.yaml/badge.svg)](https://github.com/recastnavigation/recastnavigation/actions/workflows/Tests.yaml)
 
 ![screenshot of a navmesh baked with the sample program](/RecastDemo/screenshot.png?raw=true)
 

From 53f779fa8db103f9650461134f7d0b617c165ade Mon Sep 17 00:00:00 2001
From: SpaceIm <30052553+SpaceIm@users.noreply.github.com>
Date: Sun, 20 Nov 2022 21:42:04 +0100
Subject: [PATCH 44/51] install CMake config file with exported targets (#575)

---
 CMakeLists.txt                   | 33 ++++++++++++++++++++++++++++++++
 DebugUtils/CMakeLists.txt        |  5 +++--
 Detour/CMakeLists.txt            |  5 +++--
 DetourCrowd/CMakeLists.txt       |  5 +++--
 DetourTileCache/CMakeLists.txt   |  5 +++--
 Recast/CMakeLists.txt            |  5 +++--
 recastnavigation-config.cmake.in |  3 +++
 7 files changed, 51 insertions(+), 10 deletions(-)
 create mode 100644 recastnavigation-config.cmake.in

diff --git a/CMakeLists.txt b/CMakeLists.txt
index c3121c6ec..a3fe28d2e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -15,6 +15,7 @@ if(MSVC AND BUILD_SHARED_LIBS)
     set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
 endif()
 
+include(CMakePackageConfigHelpers)
 include(GNUInstallDirs)
 
 configure_file(
@@ -43,6 +44,38 @@ add_subdirectory(DetourCrowd)
 add_subdirectory(DetourTileCache)
 add_subdirectory(Recast)
 
+configure_package_config_file(
+    ${PROJECT_SOURCE_DIR}/recastnavigation-config.cmake.in
+    recastnavigation-config.cmake
+    INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/recastnavigation
+)
+
+write_basic_package_version_file(
+    recastnavigation-config-version.cmake
+    VERSION ${LIB_VERSION}
+    COMPATIBILITY AnyNewerVersion
+)
+
+export(
+    EXPORT recastnavigation-targets
+    NAMESPACE RecastNavigation::
+    FILE recastnavigation-targets.cmake
+)
+
+install(
+    EXPORT recastnavigation-targets
+    NAMESPACE RecastNavigation::
+    FILE recastnavigation-targets.cmake
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/recastnavigation
+)
+
+install(
+    FILES
+        ${PROJECT_BINARY_DIR}/recastnavigation-config.cmake
+        ${PROJECT_BINARY_DIR}/recastnavigation-config-version.cmake
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/recastnavigation
+)
+
 if (RECASTNAVIGATION_DEMO)
     add_subdirectory(RecastDemo)
 endif ()
diff --git a/DebugUtils/CMakeLists.txt b/DebugUtils/CMakeLists.txt
index f6325c4ac..b04e67d5d 100644
--- a/DebugUtils/CMakeLists.txt
+++ b/DebugUtils/CMakeLists.txt
@@ -24,10 +24,11 @@ set_target_properties(DebugUtils PROPERTIES
         )
 
 install(TARGETS DebugUtils
+        EXPORT recastnavigation-targets
         RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        COMPONENT library
+        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT library
+        INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} ${CMAKE_INSTALL_INCLUDEDIR}/recastnavigation
         )
 
 file(GLOB INCLUDES Include/*.h)
diff --git a/Detour/CMakeLists.txt b/Detour/CMakeLists.txt
index a3ca80858..0c1268311 100644
--- a/Detour/CMakeLists.txt
+++ b/Detour/CMakeLists.txt
@@ -18,10 +18,11 @@ set_target_properties(Detour PROPERTIES
         )
 
 install(TARGETS Detour
+        EXPORT recastnavigation-targets
         RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        COMPONENT library
+        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT library
+        INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} ${CMAKE_INSTALL_INCLUDEDIR}/recastnavigation
         )
 
 file(GLOB INCLUDES Include/*.h)
diff --git a/DetourCrowd/CMakeLists.txt b/DetourCrowd/CMakeLists.txt
index 1a5d2243d..6ecd0ddeb 100644
--- a/DetourCrowd/CMakeLists.txt
+++ b/DetourCrowd/CMakeLists.txt
@@ -22,10 +22,11 @@ set_target_properties(DetourCrowd PROPERTIES
         )
 
 install(TARGETS DetourCrowd
+        EXPORT recastnavigation-targets
         RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        COMPONENT library
+        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT library
+        INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} ${CMAKE_INSTALL_INCLUDEDIR}/recastnavigation
         )
 
 file(GLOB INCLUDES Include/*.h)
diff --git a/DetourTileCache/CMakeLists.txt b/DetourTileCache/CMakeLists.txt
index 7b835560c..fcd23d5b1 100644
--- a/DetourTileCache/CMakeLists.txt
+++ b/DetourTileCache/CMakeLists.txt
@@ -23,10 +23,11 @@ set_target_properties(DetourTileCache PROPERTIES
 
 
 install(TARGETS DetourTileCache
+        EXPORT recastnavigation-targets
         RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        COMPONENT library
+        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT library
+        INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} ${CMAKE_INSTALL_INCLUDEDIR}/recastnavigation
         )
 
 file(GLOB INCLUDES Include/*.h)
diff --git a/Recast/CMakeLists.txt b/Recast/CMakeLists.txt
index de88b8115..001430b59 100644
--- a/Recast/CMakeLists.txt
+++ b/Recast/CMakeLists.txt
@@ -18,10 +18,11 @@ set_target_properties(Recast PROPERTIES
         )
 
 install(TARGETS Recast
+        EXPORT recastnavigation-targets
         RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        COMPONENT library
+        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT library
+        INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} ${CMAKE_INSTALL_INCLUDEDIR}/recastnavigation
         )
 
 file(GLOB INCLUDES Include/*.h)
diff --git a/recastnavigation-config.cmake.in b/recastnavigation-config.cmake.in
new file mode 100644
index 000000000..c6e232b0d
--- /dev/null
+++ b/recastnavigation-config.cmake.in
@@ -0,0 +1,3 @@
+@PACKAGE_INIT@
+
+include("${CMAKE_CURRENT_LIST_DIR}/recastnavigation-targets.cmake")

From 2b0c244d127e8e1de743102f53416af2b482393c Mon Sep 17 00:00:00 2001
From: Graham Pentheny <grahamboree@users.noreply.github.com>
Date: Tue, 22 Nov 2022 21:13:38 -0800
Subject: [PATCH 45/51] Updated doxygen output (#581)

- Upgraded doxyfile to latest format
- Fixed a bunch of warnings and errors in docstrings that doxygen was complaining about
- Added the doxygen-awesome theme to modernize the output
- Removed a duplicate screenshot we'd had in the docs folder
- Moved the RecastDemo screenshot into the Docs/images folder
- Changed the doxygen main page to be the README.md since the dedicated main page file we had was nearly identical but out of date
- Added CONTRIBUTING.md so it's part of the generated doxygen output
- Removed duplicate license file to avoid confusion
- Combined the FAQ with the Recast_api.txt, since the FAQ was essentially just better docs for the members of `rcConfig`
---
 CONTRIBUTING.md                               |   26 +-
 DebugUtils/Include/DebugDraw.h                |    2 +
 Detour/Include/DetourCommon.h                 |    1 -
 Detour/Include/DetourNavMesh.h                |    4 +-
 Detour/Include/DetourNavMeshQuery.h           |    7 +-
 Docs/Conceptual/FAQ.md                        |   49 -
 Docs/Conceptual/license_c.txt                 |   27 -
 Docs/Conceptual/mainpage_c.txt                |  109 -
 Docs/DoxygenLayout.xml                        |    2 +-
 Docs/Extern/Recast_api.txt                    |  109 +-
 Docs/Images/recast_intro.png                  |  Bin 378480 -> 0 bytes
 {RecastDemo => Docs/Images}/screenshot.png    |  Bin
 Docs/Readme.txt                               |    5 -
 Docs/doxygen-awesome-css/LICENSE              |   21 +
 Docs/doxygen-awesome-css/README.md            |  124 +
 .../doxygen-awesome-darkmode-toggle.js        |  157 ++
 .../doxygen-awesome-fragment-copy-button.js   |   85 +
 .../doxygen-awesome-interactive-toc.js        |   81 +
 .../doxygen-awesome-paragraph-link.js         |   51 +
 ...n-awesome-sidebar-only-darkmode-toggle.css |   40 +
 .../doxygen-awesome-sidebar-only.css          |  115 +
 Docs/doxygen-awesome-css/doxygen-awesome.css  | 2405 +++++++++++++++++
 .../doxygen-custom/custom-alternative.css     |   54 +
 .../doxygen-custom/custom.css                 |  101 +
 .../doxygen-custom/header.html                |   88 +
 .../toggle-alternative-theme.js               |   12 +
 Docs/footer.html                              |    8 +-
 Doxyfile                                      |  918 ++++---
 README.md                                     |    2 +-
 Recast/Include/Recast.h                       |   17 +-
 30 files changed, 4061 insertions(+), 559 deletions(-)
 delete mode 100644 Docs/Conceptual/FAQ.md
 delete mode 100644 Docs/Conceptual/license_c.txt
 delete mode 100644 Docs/Conceptual/mainpage_c.txt
 delete mode 100644 Docs/Images/recast_intro.png
 rename {RecastDemo => Docs/Images}/screenshot.png (100%)
 create mode 100644 Docs/doxygen-awesome-css/LICENSE
 create mode 100644 Docs/doxygen-awesome-css/README.md
 create mode 100644 Docs/doxygen-awesome-css/doxygen-awesome-darkmode-toggle.js
 create mode 100644 Docs/doxygen-awesome-css/doxygen-awesome-fragment-copy-button.js
 create mode 100644 Docs/doxygen-awesome-css/doxygen-awesome-interactive-toc.js
 create mode 100644 Docs/doxygen-awesome-css/doxygen-awesome-paragraph-link.js
 create mode 100644 Docs/doxygen-awesome-css/doxygen-awesome-sidebar-only-darkmode-toggle.css
 create mode 100644 Docs/doxygen-awesome-css/doxygen-awesome-sidebar-only.css
 create mode 100644 Docs/doxygen-awesome-css/doxygen-awesome.css
 create mode 100644 Docs/doxygen-awesome-css/doxygen-custom/custom-alternative.css
 create mode 100644 Docs/doxygen-awesome-css/doxygen-custom/custom.css
 create mode 100644 Docs/doxygen-awesome-css/doxygen-custom/header.html
 create mode 100644 Docs/doxygen-awesome-css/doxygen-custom/toggle-alternative-theme.js

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 3cfdc2160..d46d138e0 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -3,30 +3,23 @@
 We'd love for you to contribute to our source code and to make Recast and Detour even better than they are
 today! Here are the guidelines we'd like you to follow:
 
- - [Code of Conduct](#coc)
- - [Question or Problem?](#question)
- - [Issues and Bugs](#issue)
- - [Feature Requests](#feature)
- - [Submission Guidelines](#submission-guidelines)
- - [Git Commit Guidelines](#git-commit-guidelines)
-
-## <a name="coc"></a> Code of Conduct
+## Code of Conduct
 This project adheres to the [Open Code of Conduct][code-of-conduct].
 By participating, you are expected to honor this code.
 
-## <a name="question"></a> Got a Question or Problem?
+## Got a Question or Problem?
 
 If you have questions about how to use Recast or Detour, please direct these to the [Google Group][groups]
 discussion list. We are also available on [Gitter][gitter].
 
-## <a name="issue"></a> Found an Issue?
+## Found an Issue?
 If you find a bug in the source code or a mistake in the documentation, you can help us by
 submitting an issue to our [GitHub Repository][github]. Even better you can submit a Pull Request
 with a fix.
 
 **Please see the Submission Guidelines below**.
 
-## <a name="feature"></a> Want a Feature?
+## Want a Feature?
 You can request a new feature by submitting an issue to our [GitHub Repository][github]. If you
 would like to implement a new feature then consider what kind of change it is:
 
@@ -78,8 +71,7 @@ Before you submit your pull request consider the following guidelines:
      ```
 
 * Implement your changes, **including appropriate tests if appropriate/possible**.
-* Commit your changes using a descriptive commit message that follows our
-  [commit message conventions](#commit-message-format).
+* Commit your changes using a descriptive commit message that follows our commit message conventions (see below).
 
      ```shell
      git commit -a
@@ -108,10 +100,10 @@ Before you submit your pull request consider the following guidelines:
 
 If you have rebased to squash commits together, you will need to force push to update the PR:
 
-    ```shell
-    git rebase master -i
-    git push origin my-fix-branch -f
-    ```
+```shell
+git rebase master -i
+git push origin my-fix-branch -f
+```
 
 That's it! Thank you for your contribution!
 
diff --git a/DebugUtils/Include/DebugDraw.h b/DebugUtils/Include/DebugDraw.h
index 1a6b3e74a..8ebe9eb24 100644
--- a/DebugUtils/Include/DebugDraw.h
+++ b/DebugUtils/Include/DebugDraw.h
@@ -57,11 +57,13 @@ struct duDebugDraw
 	/// Submit a vertex
 	///  @param pos [in] position of the verts.
 	///  @param color [in] color of the verts.
+	///  @param uv [in] the uv coordinates of the verts.
 	virtual void vertex(const float* pos, unsigned int color, const float* uv) = 0;
 	
 	/// Submit a vertex
 	///  @param x,y,z [in] position of the verts.
 	///  @param color [in] color of the verts.
+	///  @param u,v [in] the uv coordinates of the verts.
 	virtual void vertex(const float x, const float y, const float z, unsigned int color, const float u, const float v) = 0;
 	
 	/// End drawing primitives.
diff --git a/Detour/Include/DetourCommon.h b/Detour/Include/DetourCommon.h
index 9d247fe55..d54bc7edc 100644
--- a/Detour/Include/DetourCommon.h
+++ b/Detour/Include/DetourCommon.h
@@ -37,7 +37,6 @@ feature to find minor members.
 
 /// Used to ignore a function parameter.  VS complains about unused parameters
 /// and this silences the warning.
-///  @param [in] _ Unused parameter
 template<class T> void dtIgnoreUnused(const T&) { }
 
 /// Swaps the values of the two parameters.
diff --git a/Detour/Include/DetourNavMesh.h b/Detour/Include/DetourNavMesh.h
index 34819e1e8..4c1277d78 100644
--- a/Detour/Include/DetourNavMesh.h
+++ b/Detour/Include/DetourNavMesh.h
@@ -312,8 +312,8 @@ struct dtMeshTile
 };
 
 /// Get flags for edge in detail triangle.
-/// @param	triFlags[in]		The flags for the triangle (last component of detail vertices above).
-/// @param	edgeIndex[in]		The index of the first vertex of the edge. For instance, if 0,
+/// @param[in]	triFlags		The flags for the triangle (last component of detail vertices above).
+/// @param[in]	edgeIndex		The index of the first vertex of the edge. For instance, if 0,
 ///								returns flags for edge AB.
 inline int dtGetDetailTriEdgeFlags(unsigned char triFlags, int edgeIndex)
 {
diff --git a/Detour/Include/DetourNavMeshQuery.h b/Detour/Include/DetourNavMeshQuery.h
index fc5dec84e..101b3c852 100644
--- a/Detour/Include/DetourNavMeshQuery.h
+++ b/Detour/Include/DetourNavMeshQuery.h
@@ -175,7 +175,7 @@ class dtNavMeshQuery
 	dtStatus init(const dtNavMesh* nav, const int maxNodes);
 	
 	/// @name Standard Pathfinding Functions
-	// /@{
+	/// @{
 
 	/// Finds a path from the start polygon to the end polygon.
 	///  @param[in]		startRef	The refrence id of the start polygon.
@@ -396,9 +396,9 @@ class dtNavMeshQuery
 	///  @param[in]		startPos	A position within the start polygon representing 
 	///  							the start of the ray. [(x, y, z)]
 	///  @param[in]		endPos		The position to cast the ray toward. [(x, y, z)]
+	///  @param[in]		filter		The polygon filter to apply to the query.
 	///  @param[out]	t			The hit parameter. (FLT_MAX if no wall hit.)
 	///  @param[out]	hitNormal	The normal of the nearest wall hit. [(x, y, z)]
-	///  @param[in]		filter		The polygon filter to apply to the query.
 	///  @param[out]	path		The reference ids of the visited polygons. [opt]
 	///  @param[out]	pathCount	The number of visited polygons. [opt]
 	///  @param[in]		maxPath		The maximum number of polygons the @p path array can hold.
@@ -414,7 +414,7 @@ class dtNavMeshQuery
 	///  							the start of the ray. [(x, y, z)]
 	///  @param[in]		endPos		The position to cast the ray toward. [(x, y, z)]
 	///  @param[in]		filter		The polygon filter to apply to the query.
-	///  @param[in]		flags		govern how the raycast behaves. See dtRaycastOptions
+	///  @param[in]		options		govern how the raycast behaves. See dtRaycastOptions
 	///  @param[out]	hit			Pointer to a raycast hit structure which will be filled by the results.
 	///  @param[in]		prevRef		parent of start ref. Used during for cost calculation [opt]
 	/// @returns The status flags for the query.
@@ -465,6 +465,7 @@ class dtNavMeshQuery
 	/// The location is not exactly constrained by the circle, but it limits the visited polygons.
 	///  @param[in]		startRef		The reference id of the polygon where the search starts.
 	///  @param[in]		centerPos		The center of the search circle. [(x, y, z)]
+	///  @param[in]		maxRadius		The radius of the search circle. [Units: wu]
 	///  @param[in]		filter			The polygon filter to apply to the query.
 	///  @param[in]		frand			Function returning a random number [0..1).
 	///  @param[out]	randomRef		The reference id of the random location.
diff --git a/Docs/Conceptual/FAQ.md b/Docs/Conceptual/FAQ.md
deleted file mode 100644
index 232aef6ec..000000000
--- a/Docs/Conceptual/FAQ.md
+++ /dev/null
@@ -1,49 +0,0 @@
-# Configuring Recast with rcConfig
-The following describes best practices for configuring Recast.  They're broken down by the fields in `rcConfig` and are ordered by the sequence in which you should consider them.
-
-## Determine Agent Size
-First you should decide the size of your agent's logical cylinder. If your game world uses meters as units, a reasonable starting point for a human-sized agent might be a radius of `0.4` and a height of `2.0`.
-
-## cs
-The voxelization cell size `cs` defines the voxel size along both axes of the ground plane: x and z in Recast. This value is usually derived from the character radius `r`. A recommended starting value for `cs` is either `r/2` or `r/3`. Smaller values of `cs` will increase rasterization resolution and navmesh detail, but total generation time will increase exponentially.  In outdoor environments, `r/2` is often good enough.  For indoor scenes with tight spaces you might want the extra precision, so a value of `r/3` or smaller may give better results.
-
-The initial instinct is to reduce this value to something very close to zero to maximize the detail of the generated navmesh. This quickly becomes a case of diminishing returns, however. Beyond a certain point there's usually not much perceptable difference in the generated navmesh, but huge increases in generation time.  This hinders your ability to quickly iterate on level designs and provides little benefit.  The general recommendation here is to use as large a value for `cs` as you can get away with.
-
-## ch
-The voxelization cell height `ch` is defined separately in order to allow greater precision in height tests. A good starting point for `ch` is half the `cs` value. Smaller `ch` values ensure that the navmesh properly connects areas that are only separated by a small curb or ditch.  If small holes are generated in your navmesh around where there are discontinuities in height (for example, stairs or curbs), you may want to decrease the cell height value to increase the vertical rasterization precision of Recast.
-
-## walkableHeight
-This value defines the height `h` of the agent in voxels. This value should be calculated as `ceil(h / ch)`.  Note this is based on `ch` not `cs` since it's a height value.
-
-## walkableClimb
-The `walkableClimb` value defines the maximum height of ledges and steps that the agent can walk up. Given a designer-defined `maxClimb` distance in world units, this value should be calculated as `ceil(maxClimb / ch)`.  Again, note that this is using `ch` not `cs` because it's a height-based value.
-
-## walkableRadius
-The parameter `walkableRadius` defines the agent radius in voxels.  Most often, this value should be calculated as `ceil(r/cs)`. Note this is based on `cs` since the agent radius is always parallel to the ground plane.
-
-If the `walkableRadius` value is greater than zero, the edges of the navmesh will be pushed away from all obstacles by this amount.
-
-A non-zero `walkableRadius` allows for much simpler runtime navmesh collision checks. The game only needs to check that the center point of the agent is contained within a navmesh polygon.  Without this erosion, runtime navigation checks need to collide the geometric projection onto the navmesh of agent's logical cylinder with the boundary edges of the navmesh polygons.
-
-Navmesh erosion is performed on the voxelized world representation, so some precision can be lost there. This step allows simpler checks at runtime. 
-
-If you want to have tight-fitting navmesh, or want to reuse the same navmesh for multiple agents with differing radii, you can use a `walkableRadius` value of zero.
-
-## walkableSlopeAngle
-The parameter `walkableSlopeAngle` is to filter out areas of the world where the ground slope would be too steep for an agent to traverse. This value is defined as a maximum angle in degrees that the surface normal of a polgyon can differ from the world's up vector.  This value must be within the range `[0, 90]`.
-
-## maxEdgeLen
-In certain cases, long outer edges may decrease the quality of the resulting triangulation, creating very long thin triangles. This can sometimes be remedied by limiting the maximum edge length, causing the problematic long edges to be broken up into smaller segments. 
-
-The parameter `maxEdgeLen` defines the maximum edge length and is defined in terms of voxels. A good value for `maxEdgeLen` is something like `walkableRadius * 8`. A good way to adjust this value is to first set it really high and see if your data creates long edges. If it does, decrease `maxEdgeLen` until you find the largest value which improves the resulting tesselation.
-
-## maxSimplificationError
-When the rasterized areas are converted back to a vectorized representation, the `maxSimplificationError` describes how loosely the simplification is done.  The simplification process uses the [Ramer–Douglas-Peucker algorithm](https://en.wikipedia.org/wiki/Ramer–Douglas–Peucker_algorithm), and this value describes the max deviation in voxels. 
-
-Good values for `maxSimplificationError` are in the range `[1.1, 1.5]`.  A value of `1.3` is a good starting point and usually yields good results. If the value is less than `1.1`, some sawtoothing starts to appear at the generated edges.  If the value is more than `1.5`, the mesh simplification starts to cut some corners it shouldn't.
-
-## minRegionSize
-Watershed partitioning is really prone to noise in the input distance field. In order to get nicer areas, the areas are merged and small disconnected areas are removed after the water shed partitioning. The parameter `minRegionSize` describes the minimum isolated region size that is still kept. A region is removed if the number of voxels in the region is less than the square of `minRegionSize`.
-
-## mergeRegionSize
-The triangulation process works best with small, localized voxel regions. The parameter `mergeRegionSize` controls the maximum voxel area of a region that is allowed to be merged with another region.  If you see small patches missing here and there, you could lower the minRegionSize.
diff --git a/Docs/Conceptual/license_c.txt b/Docs/Conceptual/license_c.txt
deleted file mode 100644
index c2a3c1e85..000000000
--- a/Docs/Conceptual/license_c.txt
+++ /dev/null
@@ -1,27 +0,0 @@
-
-/** 
-@page License License
-
-<pre>
-Copyright (c) 2009-2011 Mikko Mononen memon@inside.org
-
-This software is provided 'as-is', without any express or implied
-warranty.  In no event will the authors be held liable for any damages
-arising from the use of this software.
-
-Permission is granted to anyone to use this software for any purpose,
-including commercial applications, and to alter it and redistribute it
-freely, subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not
-   claim that you wrote the original software. If you use this software
-   in a product, an acknowledgment in the product documentation would be
-   appreciated but is not required.
-
-2. Altered source versions must be plainly marked as such, and must not be
-   misrepresented as being the original software.
-
-3. This notice may not be removed or altered from any source distribution.
-</pre>
-
-*/
\ No newline at end of file
diff --git a/Docs/Conceptual/mainpage_c.txt b/Docs/Conceptual/mainpage_c.txt
deleted file mode 100644
index 14dd1cf8f..000000000
--- a/Docs/Conceptual/mainpage_c.txt
+++ /dev/null
@@ -1,109 +0,0 @@
-/// @mainpage Recast Navigation
-/// 
-/// @image html recast_intro.png 
-///
-/// <h2>Recast</h2>
-/// 
-/// _Recast_ is a state of the art navigation mesh construction toolset for 
-/// games.
-///
-/// - It is automatic, which means that you can throw any level 
-///   geometry at it and you will get a robust mesh out.
-/// - It is fast, which means swift turnaround times for level designers.
-/// - It is open source, so it comes with full source and you can 
-///   customize it to your hearts content.
-/// 
-/// The latest version can be found on 
-/// <a href="https://github.com/recastnavigation/recastnavigation">GitHub</a>.
-/// 
-/// The _Recast_ process starts with constructing a voxel mold from level
-/// geometry and then casting a navigation mesh over it. The process 
-/// consists of three steps: building the voxel mold, partitioning the
-/// mold into simple regions, and triangulating the regions as simple polygons.
-/// 
-/// -# The voxel mold is built from the input triangle mesh by 
-///    rasterizing the triangles into a multi-layer heightfield. Some 
-///    simple filters are then applied to the mold to prune out locations 
-///    where the character would not be able to move.
-/// -# The walkable areas described by the mold are divided into simple 
-///    overlayed 2D regions. The resulting regions have only one 
-///    non-overlapping contour, which simplifies the final step of the 
-///    process tremendously.
-/// -# The navigation polygons are generated from the regions by first 
-///    tracing the boundaries and then simplifying them. The resulting 
-///    polygons are finally converted to convex polygons which makes them 
-///    perfect for pathfinding and spatial reasoning about the level. 
-/// 
-/// <h2>Detour</h2>
-///
-/// _Recast_ is accompanied by _Detour_, a path-finding and spatial reasoning 
-/// toolkit. You can use any navigation mesh with _Detour_, but of course 
-/// the data generated by _Recast_ fits perfectly. 
-///
-/// _Detour_ offers a simple static navigation mesh that is suitable for 
-/// many simple cases, as well as a tiled navigation mesh that allows you 
-/// to add and remove pieces of the mesh. The tiled mesh allows you to 
-/// create systems where you stream new navigation data in and out as 
-/// the player progresses the level, or regenerate tiles as the 
-/// world changes. 
-///
-/// <h2>Recast Demo</h2>
-///
-/// You can find a comprehensive demo project in the `RecastDemo` folder. It 
-/// is a kitchen sink demo containing all the major functionality of the library. 
-/// If you are new to _Recast_ & _Detour_, check out 
-/// <a href="https://github.com/recastnavigation/recastnavigation/blob/master/RecastDemo/Source/Sample_SoloMesh.cpp">
-/// Sample_SoloMesh.cpp</a> to get started with building navmeshes and 
-/// <a href="https://github.com/recastnavigation/recastnavigation/blob/master/RecastDemo/Source/NavMeshTesterTool.cpp">
-/// NavMeshTesterTool.cpp</a> to see how _Detour_ can be used to find paths.
-///
-/// <h3>Building RecastDemo</h3>
-///
-/// RecastDemo uses [premake5](http://premake.github.io/) to build platform specific projects.
-/// Download it and make sure it's available on your path, or specify the path to it.
-///
-/// <h4>Linux</h4>
-/// 
-/// - Install SDl2 and its dependencies according to your distro's guidelines.
-/// - run `premake5 gmake` from the `RecastDemo` folder.
-/// - `cd Build/gmake` then `make`
-/// - Run `RecastDemo\Bin\RecastDemo`
-/// 
-/// <h4>OSX</h4>
-/// 
-/// - Grab the latest SDL2 development library dmg from [here](https://www.libsdl.org/download-2.0.php) and place `SDL2.framework` in `/Library/Frameworks/`
-/// - Navigate to the `RecastDemo` folder and run `premake5 xcode4`
-/// - Open `Build/xcode4/recastnavigation.xcworkspace`
-/// - Select the "RecastDemo" project in the left pane, go to the "BuildPhases" tab and expand "Link Binary With Libraries"
-/// - Remove the existing entry for SDL2 (it should have a white box icon) and re-add it by hitting the plus, selecting "Add Other", and selecting `/Library/Frameworks/SDL2.framework`.  It should now have a suitcase icon.
-/// - Set the RecastDemo project as the target and build.
-/// 
-/// <h4>Windows</h4>
-/// 
-/// - Grab the latest SDL2 development library release from [here](https://www.libsdl.org/download-2.0.php) and unzip it `RecastDemo\Contrib`.  Rename the SDL folder such that the path `RecastDemo\Contrib\SDL\lib\x86` is valid.
-/// - Run `"premake5" vs2015` from the `RecastDemo` folder
-/// - Open the solution, build, and run.
-/// 
-/// <h2>Integrating With Your Own Project</h2>
-///
-/// It is recommended to add the source directories `DebugUtils`, `Detour`,
-/// `DetourCrowd`, `DetourTileCache`, and `Recast` into your own project 
-/// depending on which parts of the project you need. For example your 
-/// level building tool could include `DebugUtils`, `Recast`, and `Detour`, 
-/// and your game runtime could just include `Detour`.
-///
-/// <h2>Contributing</h2>
-/// All development is centralized in github.  Check out the <a href="https://github.com/recastnavigation/recastnavigation/blob/master/CONTRIBUTING.md">Contributing Guidelines</a> for more information.
-///
-/// <h2>Discuss</h2>
-///
-/// - Discuss _Recast_ and _Detour_: 
-/// <a href="http://groups.google.com/group/recastnavigation">
-/// Recast Navigation Group</a>
-/// - Development Blog: 
-/// <a href="http://digestingduck.blogspot.com/">Digesting Duck</a>
-///
-/// <h2>License</h2>
-/// 
-/// _Recast Navigation_ is licensed under the ZLib license.
-///
diff --git a/Docs/DoxygenLayout.xml b/Docs/DoxygenLayout.xml
index b20079c91..db963bbaf 100644
--- a/Docs/DoxygenLayout.xml
+++ b/Docs/DoxygenLayout.xml
@@ -107,7 +107,7 @@
 
   <!-- Layout definition for a file page -->
   <file>
-    <briefdescription visible="Description"/>
+    <briefdescription visible="yes"/>
     <detaileddescription title=""/>    
     <includes visible="$SHOW_INCLUDE_FILES"/>
     <includegraph visible="$INCLUDE_GRAPH"/>
diff --git a/Docs/Extern/Recast_api.txt b/Docs/Extern/Recast_api.txt
index f6ff06444..6cd4c63f1 100644
--- a/Docs/Extern/Recast_api.txt
+++ b/Docs/Extern/Recast_api.txt
@@ -28,9 +28,6 @@ The general life-cycle of the main classes is as follows:
 -# Use the object as part of the pipeline.
 -# Free the object using the Recast allocator. (E.g. #rcFreeHeightField)
 
-@note This is a summary list of members.  Use the index or search 
-feature to find minor members.
-
 @struct rcConfig
 @par
 
@@ -51,6 +48,10 @@ the platform's floating point accuraccy as well as interdependencies between
 the values of multiple parameters.  See the individual parameter 
 documentation for details.
 
+@note First you should decide the size of your agent's logical cylinder. 
+If your game world uses meters as units, a reasonable starting point for 
+a human-sized agent might be a radius of `0.4` and a height of `2.0`.
+
 @var rcConfig::borderSize
 @par
 
@@ -66,7 +67,24 @@ This field is only used when building multi-tile meshes.
 @var rcConfig::cs
 @par
 
-@p cs and #ch define voxel/grid/cell size.  So their values have significant 
+The voxelization cell size #cs defines the voxel size along both axes of 
+the ground plane: x and z in Recast. This value is usually derived from the 
+character radius `r`. A recommended starting value for #cs is either `r/2` 
+or `r/3`. Smaller values of #cs will increase rasterization resolution and 
+navmesh detail, but total generation time will increase exponentially.  In 
+outdoor environments, `r/2` is often good enough.  For indoor scenes with 
+tight spaces you might want the extra precision, so a value of `r/3` or 
+smaller may give better results.
+
+The initial instinct is to reduce this value to something very close to zero 
+to maximize the detail of the generated navmesh. This quickly becomes a case 
+of diminishing returns, however. Beyond a certain point there's usually not 
+much perceptable difference in the generated navmesh, but huge increases in 
+generation time.  This hinders your ability to quickly iterate on level 
+designs and provides little benefit.  The general recommendation here is to 
+use as large a value for #cs as you can get away with.
+
+#cs and #ch define voxel/grid/cell size.  So their values have significant 
 side effects on all parameters defined in voxel units.
 
 The minimum value for this parameter depends on the platform's floating point 
@@ -75,7 +93,15 @@ accuracy, with the practical minimum usually around 0.05.
 @var rcConfig::ch
 @par
 
-#cs and @p ch define voxel/grid/cell size.  So their values have significant 
+The voxelization cell height #ch is defined separately in order to allow for 
+greater precision in height tests. A good starting point for #ch is half the 
+#cs value. Smaller #ch values ensure that the navmesh properly connects areas 
+that are only separated by a small curb or ditch.  If small holes are generated 
+in your navmesh around where there are discontinuities in height (for example, 
+stairs or curbs), you may want to decrease the cell height value to increase 
+the vertical rasterization precision of Recast.
+
+#cs and #ch define voxel/grid/cell size.  So their values have significant 
 side effects on all parameters defined in voxel units.
 
 The minimum value for this parameter depends on the platform's floating point 
@@ -84,44 +110,106 @@ accuracy, with the practical minimum usually around 0.05.
 @var rcConfig::walkableSlopeAngle
 @par
 
+The parameter #walkableSlopeAngle is to filter out areas of the world where 
+the ground slope would be too steep for an agent to traverse. This value is 
+defined as a maximum angle in degrees that the surface normal of a polgyon 
+can differ from the world's up vector.  This value must be within the range 
+`[0, 90]`.
+
 The practical upper limit for this parameter is usually around 85 degrees.
 
 @var rcConfig::walkableHeight
 @par
 
+This value defines the worldspace height `h` of the agent in voxels. Th value 
+of #walkableHeight should be calculated as `ceil(h / ch)`.  Note this is based 
+on #ch not #cs since it's a height value.
+
 Permits detection of overhangs in the source geometry that make the geometry
 below un-walkable. The value is usually set to the maximum agent height.
 
 @var rcConfig::walkableClimb
 @par
 
+The #walkableClimb value defines the maximum height of ledges and steps that 
+the agent can walk up. Given a designer-defined `maxClimb` distance in world 
+units, the value of #walkableClimb should be calculated as `ceil(maxClimb / ch)`.  
+Note that this is using #ch not #cs because it's a height-based value.
+
 Allows the mesh to flow over low lying obstructions such as curbs and 
 up/down stairways. The value is usually set to how far up/down an agent can step.
 
 @var rcConfig::walkableRadius
 @par
 
+The parameter #walkableRadius defines the worldspace agent radius `r` in voxels.  
+Most often, this value of #walkableRadius should be calculated as `ceil(r / cs)`. 
+Note this is based on #cs since the agent radius is always parallel to the ground 
+plane.
+
+If the #walkableRadius value is greater than zero, the edges of the navmesh will 
+be pushed away from all obstacles by this amount.
+
+A non-zero #walkableRadius allows for much simpler runtime navmesh collision checks.
+The game only needs to check that the center point of the agent is contained within 
+a navmesh polygon.  Without this erosion, runtime navigation checks need to collide
+the geometric projection of the agent's logical cylinder onto the navmesh with the 
+boundary edges of the navmesh polygons.
+
 In general, this is the closest any part of the final mesh should get to an 
 obstruction in the source geometry.  It is usually set to the maximum
 agent radius.
 
-While a value of zero is legal, it is not recommended and can result in
-odd edge case issues.
+If you want to have tight-fitting navmesh, or want to reuse the same navmesh for 
+multiple agents with differing radii, you can use a `walkableRadius` value of zero.
+Be advised though that you will need to perform your own collisions with the navmesh
+edges, and odd edge cases issues in the mesh generation can potentially occur.  For
+these reasons, specifying a radius of zero is allowed but is not recommended.
 
 @var rcConfig::maxEdgeLen
 @par
 
+In certain cases, long outer edges may decrease the quality of the resulting 
+triangulation, creating very long thin triangles. This can sometimes be 
+remedied by limiting the maximum edge length, causing the problematic long 
+edges to be broken up into smaller segments. 
+
+The parameter #maxEdgeLen defines the maximum edge length and is defined in 
+terms of voxels. A good value for #maxEdgeLen is something like 
+`walkableRadius * 8`. A good way to adjust this value is to first set it really 
+high and see if your data creates long edges. If it does, decrease #maxEdgeLen
+until you find the largest value which improves the resulting tesselation.
+
 Extra vertices will be inserted as needed to keep contour edges below this
 length. A value of zero effectively disables this feature.
 
 @var rcConfig::maxSimplificationError
 @par
 
+When the rasterized areas are converted back to a vectorized representation, 
+the #maxSimplificationError describes how loosely the simplification is done.
+The simplification process uses the 
+<a href="https://en.wikipedia.org/wiki/Ramer–Douglas–Peucker_algorithm">Ramer–Douglas-Peucker algorithm</a>,
+and this value describes the max deviation in voxels.
+
+Good values for #maxSimplificationError are in the range `[1.1, 1.5]`.  
+A value of `1.3` is a good starting point and usually yields good results. 
+If the value is less than `1.1`, some sawtoothing starts to appear at the 
+generated edges.  If the value is more than `1.5`, the mesh simplification 
+starts to cut some corners it shouldn't.
+
 The effect of this parameter only applies to the xz-plane.
 
 @var rcConfig::minRegionArea
 @par
 
+Watershed partitioning is really prone to noise in the input distance field. 
+In order to get nicer areas, the areas are merged and small disconnected areas 
+are removed after the water shed partitioning. The parameter #minRegionArea 
+describes the minimum isolated region size that is still kept. A region is 
+removed if the number of voxels in the region is less than the square of 
+#minRegionArea.
+
 Any regions that are smaller than this area will be marked as unwalkable.
 This is useful in removing useless regions that can sometimes form on 
 geometry such as table tops, box tops, etc.
@@ -132,6 +220,13 @@ geometry such as table tops, box tops, etc.
 If the mesh data is to be used to construct a Detour navigation mesh, then the upper limit
 is limited to <= #DT_VERTS_PER_POLYGON.
 
+@var rcConfig::mergeRegionArea
+@par
+
+The triangulation process works best with small, localized voxel regions. 
+The parameter #mergeRegionArea controls the maximum voxel area of a region 
+that is allowed to be merged with another region.  If you see small patches 
+missing here and there, you could lower the #minRegionArea value.
 
 @struct rcHeightfield
 @par
diff --git a/Docs/Images/recast_intro.png b/Docs/Images/recast_intro.png
deleted file mode 100644
index ad18ac610b32758f20616a3955160db1d493b237..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 378480
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%0DZ)2M6E@GW@y_s$xYPG7@7
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

diff --git a/RecastDemo/screenshot.png b/Docs/Images/screenshot.png
similarity index 100%
rename from RecastDemo/screenshot.png
rename to Docs/Images/screenshot.png
diff --git a/Docs/Readme.txt b/Docs/Readme.txt
index be153b94b..3bf89fa8d 100644
--- a/Docs/Readme.txt
+++ b/Docs/Readme.txt
@@ -7,11 +7,6 @@ Directory Layout
 
 	High level content and format files. (E.g. css, header, footer.)
 
-./Conceptual
-	
-	Conceptual (non-api) documentation such as overviews, how-to's, etc.
-	The main index page content is also in this directory.
-
 ./Extern
 
 	API documentation that is located outside the source files.
diff --git a/Docs/doxygen-awesome-css/LICENSE b/Docs/doxygen-awesome-css/LICENSE
new file mode 100644
index 000000000..1d8b99a95
--- /dev/null
+++ b/Docs/doxygen-awesome-css/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 jothepro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/Docs/doxygen-awesome-css/README.md b/Docs/doxygen-awesome-css/README.md
new file mode 100644
index 000000000..5b07c9239
--- /dev/null
+++ b/Docs/doxygen-awesome-css/README.md
@@ -0,0 +1,124 @@
+#  Doxygen Awesome
+
+[![GitHub release (latest by date)](https://img.shields.io/github/v/release/jothepro/doxygen-awesome-css)](https://github.com/jothepro/doxygen-awesome-css/releases/latest)
+[![GitHub](https://img.shields.io/github/license/jothepro/doxygen-awesome-css)](https://github.com/jothepro/doxygen-awesome-css/blob/main/LICENSE)
+![GitHub Repo stars](https://img.shields.io/github/stars/jothepro/doxygen-awesome-css)
+
+<div class="title_screenshot">
+
+![Screenshot of Doxygen Awesome CSS](img/screenshot.png)
+
+</div>
+
+**Doxygen Awesome** is a custom **CSS theme for Doxygen HTML-documentation** with lots of customization parameters.
+
+## Motivation
+
+I really like how the Doxygen HTML-documentation is structured! But IMHO it looks a bit outdated.
+
+This theme is an attempt to update the visuals of Doxygen without changing its overall layout too much.
+
+## Features
+
+- 🌈 Clean, modern design
+- 🚀 Heavily customizable by adjusting CSS-variables
+- 🧩 No changes to the HTML structure of Doxygen required
+- 📱 Improved mobile usability
+- 🌘 Dark mode support!
+- 🥇 Works best with **doxygen 1.9.1** - **1.9.4**
+
+## Examples
+
+Some websites using this theme:
+
+- [Documentation of this repository](https://jothepro.github.io/doxygen-awesome-css/)
+- [wxWidgets](https://docs.wxwidgets.org/3.2/)
+- [OpenCV 5.x](https://docs.opencv.org/5.x/)
+- [Zephyr](https://docs.zephyrproject.org/latest/doxygen/html/index.html)
+- [FELTOR](https://mwiesenberger.github.io/feltor/dg/html/modules.html)
+- [Spatial Audio Framework (SAF)](https://leomccormack.github.io/Spatial_Audio_Framework/index.html)
+- [libCloudSync](https://jothepro.github.io/libCloudSync/)
+- [libsl3](https://a4z.github.io/libsl3/)
+ 
+## Installation
+
+To use the theme in your documentation, copy the required CSS and JS files from this repository into your project or add the repository as submodule and check out the latest release:
+
+```bash
+git submodule add https://github.com/jothepro/doxygen-awesome-css.git
+cd doxygen-awesome-css
+git checkout v2.1.0
+```
+
+All theme files are located in the root of this repository and start with the prefix `doxygen-awesome-`. You may not need all of them. Follow the install instructions to figure out what files are required for your setup.
+
+### Choosing a layout
+
+There is two layout options. Choose one of them and configure Doxygen accordingly:
+
+<div class="darkmode_inverted_image">
+
+![Available theme variants](img/theme-variants.drawio.svg)
+
+</div>
+
+
+
+#### Base Theme (1)
+
+Comes with the typical Doxygen titlebar. Optionally the treeview in the sidebar can be enabled. 
+
+Required files: `doxygen-awesome.css`
+
+Required `Doxyfile` configuration:
+```
+GENERATE_TREEVIEW      = YES # optional. Also works without treeview
+DISABLE_INDEX = NO
+FULL_SIDEBAR = NO
+HTML_EXTRA_STYLESHEET  = doxygen-awesome-css/doxygen-awesome.css
+```
+
+#### Sidebar-Only Theme (2)
+
+Hides the top titlebar to give more space to the content. The treeview must be enabled in order for this theme to work.
+
+Required files: `doxygen-awesome.css`, `doxygen-awesome-sidebar-only.css`
+
+Required `Doxyfile` configuration:
+```
+GENERATE_TREEVIEW      = YES # required!
+DISABLE_INDEX          = NO
+FULL_SIDEBAR           = NO
+HTML_EXTRA_STYLESHEET  = doxygen-awesome-css/doxygen-awesome.css \
+                         doxygen-awesome-css/doxygen-awesome-sidebar-only.css
+```
+
+
+**Caution**: This theme is not compatible with the `FULL_SIDEBAR = YES` option provided by Doxygen!
+
+### Further installation instructions:
+
+- [Installing extensions](docs/extensions.md)
+- [Customizing the theme (colors, spacing, border-radius, ...)](docs/customization.md)
+- [Tips and Tricks for further configuration](docs/tricks.md)
+
+## Browser support
+
+Tested with
+
+- Chrome 104, Chrome 104 for Android, Chrome 103 for iOS
+- Safari 15, Safari for iOS 15
+- Firefox 103, Firefox 103 for Android, Firefox Daylight 102 for iOS
+- Edge 104
+
+The theme does not strive to be backwards compatible to (significantly) older browser versions.
+
+## Credits
+
+- This theme was initially inspired by the [vuepress](https://vuepress.vuejs.org/) static site generator default theme.
+- Thank you for all the bug reports, pull requests and inspiring feedback on github!
+
+<span class="next_section_button">
+
+Read Next: [Extensions](docs/extensions.md)
+</span>
\ No newline at end of file
diff --git a/Docs/doxygen-awesome-css/doxygen-awesome-darkmode-toggle.js b/Docs/doxygen-awesome-css/doxygen-awesome-darkmode-toggle.js
new file mode 100644
index 000000000..f2c5853f7
--- /dev/null
+++ b/Docs/doxygen-awesome-css/doxygen-awesome-darkmode-toggle.js
@@ -0,0 +1,157 @@
+/**
+
+Doxygen Awesome
+https://github.com/jothepro/doxygen-awesome-css
+
+MIT License
+
+Copyright (c) 2021 - 2022 jothepro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+*/
+
+class DoxygenAwesomeDarkModeToggle extends HTMLElement {
+    // SVG icons from https://fonts.google.com/icons
+    // Licensed under the Apache 2.0 license:
+    // https://www.apache.org/licenses/LICENSE-2.0.html
+    static lightModeIcon = `<svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24px" viewBox="0 0 24 24" width="24px" fill="#FCBF00"><rect fill="none" height="24" width="24"/><circle cx="12" cy="12" opacity=".3" r="3"/><path d="M12,9c1.65,0,3,1.35,3,3s-1.35,3-3,3s-3-1.35-3-3S10.35,9,12,9 M12,7c-2.76,0-5,2.24-5,5s2.24,5,5,5s5-2.24,5-5 S14.76,7,12,7L12,7z M2,13l2,0c0.55,0,1-0.45,1-1s-0.45-1-1-1l-2,0c-0.55,0-1,0.45-1,1S1.45,13,2,13z M20,13l2,0c0.55,0,1-0.45,1-1 s-0.45-1-1-1l-2,0c-0.55,0-1,0.45-1,1S19.45,13,20,13z M11,2v2c0,0.55,0.45,1,1,1s1-0.45,1-1V2c0-0.55-0.45-1-1-1S11,1.45,11,2z M11,20v2c0,0.55,0.45,1,1,1s1-0.45,1-1v-2c0-0.55-0.45-1-1-1C11.45,19,11,19.45,11,20z M5.99,4.58c-0.39-0.39-1.03-0.39-1.41,0 c-0.39,0.39-0.39,1.03,0,1.41l1.06,1.06c0.39,0.39,1.03,0.39,1.41,0s0.39-1.03,0-1.41L5.99,4.58z M18.36,16.95 c-0.39-0.39-1.03-0.39-1.41,0c-0.39,0.39-0.39,1.03,0,1.41l1.06,1.06c0.39,0.39,1.03,0.39,1.41,0c0.39-0.39,0.39-1.03,0-1.41 L18.36,16.95z M19.42,5.99c0.39-0.39,0.39-1.03,0-1.41c-0.39-0.39-1.03-0.39-1.41,0l-1.06,1.06c-0.39,0.39-0.39,1.03,0,1.41 s1.03,0.39,1.41,0L19.42,5.99z M7.05,18.36c0.39-0.39,0.39-1.03,0-1.41c-0.39-0.39-1.03-0.39-1.41,0l-1.06,1.06 c-0.39,0.39-0.39,1.03,0,1.41s1.03,0.39,1.41,0L7.05,18.36z"/></svg>`
+    static darkModeIcon = `<svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24px" viewBox="0 0 24 24" width="24px" fill="#FE9700"><rect fill="none" height="24" width="24"/><path d="M9.37,5.51C9.19,6.15,9.1,6.82,9.1,7.5c0,4.08,3.32,7.4,7.4,7.4c0.68,0,1.35-0.09,1.99-0.27 C17.45,17.19,14.93,19,12,19c-3.86,0-7-3.14-7-7C5,9.07,6.81,6.55,9.37,5.51z" opacity=".3"/><path d="M9.37,5.51C9.19,6.15,9.1,6.82,9.1,7.5c0,4.08,3.32,7.4,7.4,7.4c0.68,0,1.35-0.09,1.99-0.27C17.45,17.19,14.93,19,12,19 c-3.86,0-7-3.14-7-7C5,9.07,6.81,6.55,9.37,5.51z M12,3c-4.97,0-9,4.03-9,9s4.03,9,9,9s9-4.03,9-9c0-0.46-0.04-0.92-0.1-1.36 c-0.98,1.37-2.58,2.26-4.4,2.26c-2.98,0-5.4-2.42-5.4-5.4c0-1.81,0.89-3.42,2.26-4.4C12.92,3.04,12.46,3,12,3L12,3z"/></svg>`
+    static title = "Toggle Light/Dark Mode"
+
+    static prefersLightModeInDarkModeKey = "prefers-light-mode-in-dark-mode"
+    static prefersDarkModeInLightModeKey = "prefers-dark-mode-in-light-mode"
+
+    static _staticConstructor = function() {
+        DoxygenAwesomeDarkModeToggle.enableDarkMode(DoxygenAwesomeDarkModeToggle.userPreference)
+        // Update the color scheme when the browsers preference changes
+        // without user interaction on the website.
+        window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', event => {
+            DoxygenAwesomeDarkModeToggle.onSystemPreferenceChanged()
+        })
+        // Update the color scheme when the tab is made visible again.
+        // It is possible that the appearance was changed in another tab 
+        // while this tab was in the background.
+        document.addEventListener("visibilitychange", visibilityState => {
+            if (document.visibilityState === 'visible') {
+                DoxygenAwesomeDarkModeToggle.onSystemPreferenceChanged()
+            }
+        });
+    }()
+
+    static init() {
+        $(function() {
+            $(document).ready(function() {
+                const toggleButton = document.createElement('doxygen-awesome-dark-mode-toggle')
+                toggleButton.title = DoxygenAwesomeDarkModeToggle.title
+                toggleButton.updateIcon()
+
+                window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', event => {
+                    toggleButton.updateIcon()
+                })
+                document.addEventListener("visibilitychange", visibilityState => {
+                    if (document.visibilityState === 'visible') {
+                        toggleButton.updateIcon()
+                    }
+                });
+
+                $(document).ready(function(){
+                    document.getElementById("MSearchBox").parentNode.appendChild(toggleButton)
+                })
+                $(window).resize(function(){
+                    document.getElementById("MSearchBox").parentNode.appendChild(toggleButton)
+                })
+            })
+        })
+    }
+
+    constructor() {
+        super();
+        this.onclick=this.toggleDarkMode
+    }
+
+    /**
+     * @returns `true` for dark-mode, `false` for light-mode system preference
+     */
+    static get systemPreference() {
+        return window.matchMedia('(prefers-color-scheme: dark)').matches
+    }
+
+    /**
+     * @returns `true` for dark-mode, `false` for light-mode user preference
+     */
+    static get userPreference() {
+        return (!DoxygenAwesomeDarkModeToggle.systemPreference && localStorage.getItem(DoxygenAwesomeDarkModeToggle.prefersDarkModeInLightModeKey)) || 
+        (DoxygenAwesomeDarkModeToggle.systemPreference && !localStorage.getItem(DoxygenAwesomeDarkModeToggle.prefersLightModeInDarkModeKey))
+    }
+
+    static set userPreference(userPreference) {
+        DoxygenAwesomeDarkModeToggle.darkModeEnabled = userPreference
+        if(!userPreference) {
+            if(DoxygenAwesomeDarkModeToggle.systemPreference) {
+                localStorage.setItem(DoxygenAwesomeDarkModeToggle.prefersLightModeInDarkModeKey, true)
+            } else {
+                localStorage.removeItem(DoxygenAwesomeDarkModeToggle.prefersDarkModeInLightModeKey)
+            }
+        } else {
+            if(!DoxygenAwesomeDarkModeToggle.systemPreference) {
+                localStorage.setItem(DoxygenAwesomeDarkModeToggle.prefersDarkModeInLightModeKey, true)
+            } else {
+                localStorage.removeItem(DoxygenAwesomeDarkModeToggle.prefersLightModeInDarkModeKey)
+            }
+        }
+        DoxygenAwesomeDarkModeToggle.onUserPreferenceChanged()
+    }
+
+    static enableDarkMode(enable) {
+        if(enable) {
+            DoxygenAwesomeDarkModeToggle.darkModeEnabled = true
+            document.documentElement.classList.add("dark-mode")
+            document.documentElement.classList.remove("light-mode")
+        } else {
+            DoxygenAwesomeDarkModeToggle.darkModeEnabled = false
+            document.documentElement.classList.remove("dark-mode")
+            document.documentElement.classList.add("light-mode")
+        }
+    }
+
+    static onSystemPreferenceChanged() {
+        DoxygenAwesomeDarkModeToggle.darkModeEnabled = DoxygenAwesomeDarkModeToggle.userPreference
+        DoxygenAwesomeDarkModeToggle.enableDarkMode(DoxygenAwesomeDarkModeToggle.darkModeEnabled)
+    }
+
+    static onUserPreferenceChanged() {
+        DoxygenAwesomeDarkModeToggle.enableDarkMode(DoxygenAwesomeDarkModeToggle.darkModeEnabled)
+    }
+
+    toggleDarkMode() {
+        DoxygenAwesomeDarkModeToggle.userPreference = !DoxygenAwesomeDarkModeToggle.userPreference
+        this.updateIcon()
+    }
+
+    updateIcon() {
+        if(DoxygenAwesomeDarkModeToggle.darkModeEnabled) {
+            this.innerHTML = DoxygenAwesomeDarkModeToggle.darkModeIcon
+        } else {
+            this.innerHTML = DoxygenAwesomeDarkModeToggle.lightModeIcon
+        }
+    }
+}
+
+customElements.define("doxygen-awesome-dark-mode-toggle", DoxygenAwesomeDarkModeToggle);
diff --git a/Docs/doxygen-awesome-css/doxygen-awesome-fragment-copy-button.js b/Docs/doxygen-awesome-css/doxygen-awesome-fragment-copy-button.js
new file mode 100644
index 000000000..7d06b348d
--- /dev/null
+++ b/Docs/doxygen-awesome-css/doxygen-awesome-fragment-copy-button.js
@@ -0,0 +1,85 @@
+/**
+
+Doxygen Awesome
+https://github.com/jothepro/doxygen-awesome-css
+
+MIT License
+
+Copyright (c) 2022 jothepro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+*/
+
+class DoxygenAwesomeFragmentCopyButton extends HTMLElement {
+    constructor() {
+        super();
+        this.onclick=this.copyContent
+    }
+    static title = "Copy to clipboard"
+    static copyIcon = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24"><path d="M0 0h24v24H0V0z" fill="none"/><path d="M16 1H4c-1.1 0-2 .9-2 2v14h2V3h12V1zm3 4H8c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h11c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 16H8V7h11v14z"/></svg>`
+    static successIcon = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24"><path d="M0 0h24v24H0V0z" fill="none"/><path d="M9 16.17L4.83 12l-1.42 1.41L9 19 21 7l-1.41-1.41L9 16.17z"/></svg>`
+    static successDuration = 980
+    static init() {
+        $(function() {
+            $(document).ready(function() {
+                if(navigator.clipboard) {
+                    const fragments = document.getElementsByClassName("fragment")
+                    for(const fragment of fragments) {
+                        const fragmentWrapper = document.createElement("div")
+                        fragmentWrapper.className = "doxygen-awesome-fragment-wrapper"
+                        const fragmentCopyButton = document.createElement("doxygen-awesome-fragment-copy-button")
+                        fragmentCopyButton.innerHTML = DoxygenAwesomeFragmentCopyButton.copyIcon
+                        fragmentCopyButton.title = DoxygenAwesomeFragmentCopyButton.title
+                
+                        fragment.parentNode.replaceChild(fragmentWrapper, fragment)
+                        fragmentWrapper.appendChild(fragment)
+                        fragmentWrapper.appendChild(fragmentCopyButton)
+            
+                    }
+                }
+            })
+        })
+    }
+
+
+    copyContent() {
+        const content = this.previousSibling.cloneNode(true)
+        // filter out line number from file listings
+        content.querySelectorAll(".lineno, .ttc").forEach((node) => {
+            node.remove()
+        })
+        let textContent = content.textContent
+        // remove trailing newlines that appear in file listings
+        let numberOfTrailingNewlines = 0
+        while(textContent.charAt(textContent.length - (numberOfTrailingNewlines + 1)) == '\n') {
+            numberOfTrailingNewlines++;
+        }
+        textContent = textContent.substring(0, textContent.length - numberOfTrailingNewlines)
+        navigator.clipboard.writeText(textContent);
+        this.classList.add("success")
+        this.innerHTML = DoxygenAwesomeFragmentCopyButton.successIcon
+        window.setTimeout(() => {
+            this.classList.remove("success")
+            this.innerHTML = DoxygenAwesomeFragmentCopyButton.copyIcon
+        }, DoxygenAwesomeFragmentCopyButton.successDuration);
+    }
+}
+
+customElements.define("doxygen-awesome-fragment-copy-button", DoxygenAwesomeFragmentCopyButton)
diff --git a/Docs/doxygen-awesome-css/doxygen-awesome-interactive-toc.js b/Docs/doxygen-awesome-css/doxygen-awesome-interactive-toc.js
new file mode 100644
index 000000000..b049f5733
--- /dev/null
+++ b/Docs/doxygen-awesome-css/doxygen-awesome-interactive-toc.js
@@ -0,0 +1,81 @@
+/**
+
+Doxygen Awesome
+https://github.com/jothepro/doxygen-awesome-css
+
+MIT License
+
+Copyright (c) 2022 jothepro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+*/
+
+class DoxygenAwesomeInteractiveToc {
+    static topOffset = 38
+    static hideMobileMenu = true
+    static headers = []
+
+    static init() {
+        window.addEventListener("load", () => {
+            let toc = document.querySelector(".contents > .toc")
+            if(toc) {
+                toc.classList.add("interactive")
+                if(!DoxygenAwesomeInteractiveToc.hideMobileMenu) {
+                    toc.classList.add("open")
+                }
+                document.querySelector(".contents > .toc > h3")?.addEventListener("click", () => {
+                    if(toc.classList.contains("open")) {
+                        toc.classList.remove("open")
+                    } else {
+                        toc.classList.add("open")
+                    }
+                })
+
+                document.querySelectorAll(".contents > .toc > ul a").forEach((node) => {
+                    let id = node.getAttribute("href").substring(1)
+                    DoxygenAwesomeInteractiveToc.headers.push({
+                        node: node,
+                        headerNode: document.getElementById(id)
+                    })
+
+                    document.getElementById("doc-content")?.addEventListener("scroll", () => {
+                        DoxygenAwesomeInteractiveToc.update()
+                    })
+                })
+                DoxygenAwesomeInteractiveToc.update()
+            }
+        })
+    }
+
+    static update() {
+        let active = DoxygenAwesomeInteractiveToc.headers[0]?.node
+        DoxygenAwesomeInteractiveToc.headers.forEach((header) => {
+            let position = header.headerNode.getBoundingClientRect().top
+            header.node.classList.remove("active")
+            header.node.classList.remove("aboveActive")
+            if(position < DoxygenAwesomeInteractiveToc.topOffset) {
+                active = header.node
+                active?.classList.add("aboveActive")
+            }
+        })
+        active?.classList.add("active")
+        active?.classList.remove("aboveActive")
+    }
+}
\ No newline at end of file
diff --git a/Docs/doxygen-awesome-css/doxygen-awesome-paragraph-link.js b/Docs/doxygen-awesome-css/doxygen-awesome-paragraph-link.js
new file mode 100644
index 000000000..6424dbd42
--- /dev/null
+++ b/Docs/doxygen-awesome-css/doxygen-awesome-paragraph-link.js
@@ -0,0 +1,51 @@
+/**
+
+Doxygen Awesome
+https://github.com/jothepro/doxygen-awesome-css
+
+MIT License
+
+Copyright (c) 2022 jothepro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+*/
+
+class DoxygenAwesomeParagraphLink {
+    // Icon from https://fonts.google.com/icons
+    // Licensed under the Apache 2.0 license:
+    // https://www.apache.org/licenses/LICENSE-2.0.html
+    static icon = `<svg xmlns="http://www.w3.org/2000/svg" height="20px" viewBox="0 0 24 24" width="20px"><path d="M0 0h24v24H0V0z" fill="none"/><path d="M17 7h-4v2h4c1.65 0 3 1.35 3 3s-1.35 3-3 3h-4v2h4c2.76 0 5-2.24 5-5s-2.24-5-5-5zm-6 8H7c-1.65 0-3-1.35-3-3s1.35-3 3-3h4V7H7c-2.76 0-5 2.24-5 5s2.24 5 5 5h4v-2zm-3-4h8v2H8z"/></svg>`
+    static title = "Permanent Link"
+    static init() {
+        $(function() {
+            $(document).ready(function() {
+                document.querySelectorAll(".contents a.anchor[id], .contents .groupheader > a[id]").forEach((node) => {
+                    let anchorlink = document.createElement("a")
+                    anchorlink.setAttribute("href", `#${node.getAttribute("id")}`)
+                    anchorlink.setAttribute("title", DoxygenAwesomeParagraphLink.title)
+                    anchorlink.classList.add("anchorlink")
+                    node.classList.add("anchor")
+                    anchorlink.innerHTML = DoxygenAwesomeParagraphLink.icon
+                    node.parentElement.appendChild(anchorlink)
+                })
+            })
+        })
+    }
+}
diff --git a/Docs/doxygen-awesome-css/doxygen-awesome-sidebar-only-darkmode-toggle.css b/Docs/doxygen-awesome-css/doxygen-awesome-sidebar-only-darkmode-toggle.css
new file mode 100644
index 000000000..b988b6f05
--- /dev/null
+++ b/Docs/doxygen-awesome-css/doxygen-awesome-sidebar-only-darkmode-toggle.css
@@ -0,0 +1,40 @@
+
+/**
+
+Doxygen Awesome
+https://github.com/jothepro/doxygen-awesome-css
+
+MIT License
+
+Copyright (c) 2021 jothepro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+*/
+
+@media screen and (min-width: 768px) {
+
+    #MSearchBox {
+        width: calc(var(--side-nav-fixed-width) - calc(2 * var(--spacing-medium)) - var(--searchbar-height) - 1px);
+    }
+
+    #MSearchField {
+        width: calc(var(--side-nav-fixed-width) - calc(2 * var(--spacing-medium)) - 66px - var(--searchbar-height));
+    }
+}
diff --git a/Docs/doxygen-awesome-css/doxygen-awesome-sidebar-only.css b/Docs/doxygen-awesome-css/doxygen-awesome-sidebar-only.css
new file mode 100644
index 000000000..656ebbf43
--- /dev/null
+++ b/Docs/doxygen-awesome-css/doxygen-awesome-sidebar-only.css
@@ -0,0 +1,115 @@
+/**
+
+Doxygen Awesome
+https://github.com/jothepro/doxygen-awesome-css
+
+MIT License
+
+Copyright (c) 2021 jothepro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+ */
+
+html {
+    /* side nav width. MUST be = `TREEVIEW_WIDTH`.
+     * Make sure it is wide enough to contain the page title (logo + title + version)
+     */
+    --side-nav-fixed-width: 335px;
+    --menu-display: none;
+
+    --top-height: 120px;
+    --toc-sticky-top: -25px;
+    --toc-max-height: calc(100vh - 2 * var(--spacing-medium) - 25px);
+}
+
+#projectname {
+    white-space: nowrap;
+}
+
+
+@media screen and (min-width: 768px) {
+    html {
+        --searchbar-background: var(--page-background-color);
+    }
+
+    #side-nav {
+        min-width: var(--side-nav-fixed-width);
+        max-width: var(--side-nav-fixed-width);
+        top: var(--top-height);
+        overflow: visible;
+    }
+
+    #nav-tree, #side-nav {
+        height: calc(100vh - var(--top-height)) !important;
+    }
+
+    #nav-tree {
+        padding: 0;
+    }
+
+    #top {
+        display: block;
+        border-bottom: none;
+        height: var(--top-height);
+        margin-bottom: calc(0px - var(--top-height));
+        max-width: var(--side-nav-fixed-width);
+        overflow: hidden;
+        background: var(--side-nav-background);
+    }
+    #main-nav {
+        float: left;
+        padding-right: 0;
+    }
+
+    .ui-resizable-handle {
+        cursor: default;
+        width: 1px !important;
+        box-shadow: 0 calc(-2 * var(--top-height)) 0 0 var(--separator-color);
+    }
+
+    #nav-path {
+        position: fixed;
+        right: 0;
+        left: var(--side-nav-fixed-width);
+        bottom: 0;
+        width: auto;
+    }
+
+    #doc-content {
+        height: calc(100vh - 31px) !important;
+        padding-bottom: calc(3 * var(--spacing-large));
+        padding-top: calc(var(--top-height) - 80px);
+        box-sizing: border-box;
+        margin-left: var(--side-nav-fixed-width) !important;
+    }
+
+    #MSearchBox {
+        width: calc(var(--side-nav-fixed-width) - calc(2 * var(--spacing-medium)));
+    }
+
+    #MSearchField {
+        width: calc(var(--side-nav-fixed-width) - calc(2 * var(--spacing-medium)) - 65px);
+    }
+
+    #MSearchResultsWindow {
+        left: var(--spacing-medium) !important;
+        right: auto;
+    }
+}
diff --git a/Docs/doxygen-awesome-css/doxygen-awesome.css b/Docs/doxygen-awesome-css/doxygen-awesome.css
new file mode 100644
index 000000000..abd2893cc
--- /dev/null
+++ b/Docs/doxygen-awesome-css/doxygen-awesome.css
@@ -0,0 +1,2405 @@
+/**
+
+Doxygen Awesome
+https://github.com/jothepro/doxygen-awesome-css
+
+MIT License
+
+Copyright (c) 2021 - 2022 jothepro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+*/
+
+html {
+    /* primary theme color. This will affect the entire websites color scheme: links, arrows, labels, ... */
+    --primary-color: #1779c4;
+    --primary-dark-color: #335c80;
+    --primary-light-color: #70b1e9;
+
+    /* page base colors */
+    --page-background-color: #ffffff;
+    --page-foreground-color: #2f4153;
+    --page-secondary-foreground-color: #6f7e8e;
+
+    /* color for all separators on the website: hr, borders, ... */
+    --separator-color: #dedede;
+
+    /* border radius for all rounded components. Will affect many components, like dropdowns, memitems, codeblocks, ... */
+    --border-radius-large: 8px;
+    --border-radius-small: 4px;
+    --border-radius-medium: 6px;
+
+    /* default spacings. Most components reference these values for spacing, to provide uniform spacing on the page. */
+    --spacing-small: 5px;
+    --spacing-medium: 10px;
+    --spacing-large: 16px;
+
+    /* default box shadow used for raising an element above the normal content. Used in dropdowns, search result, ... */
+    --box-shadow: 0 2px 8px 0 rgba(0,0,0,.075);
+
+    --odd-color: rgba(0,0,0,.028);
+
+    /* font-families. will affect all text on the website
+     * font-family: the normal font for text, headlines, menus
+     * font-family-monospace: used for preformatted text in memtitle, code, fragments
+     */
+    --font-family: -apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Oxygen,Ubuntu,Cantarell,Fira Sans,Droid Sans,Helvetica Neue,sans-serif;
+    --font-family-monospace: ui-monospace,SFMono-Regular,SF Mono,Menlo,Consolas,Liberation Mono,monospace;
+
+    /* font sizes */
+    --page-font-size: 15.6px;
+    --navigation-font-size: 14.4px;
+    --toc-font-size: 13.4px;
+    --code-font-size: 14px; /* affects code, fragment */
+    --title-font-size: 22px;
+
+    /* content text properties. These only affect the page content, not the navigation or any other ui elements */
+    --content-line-height: 27px;
+    /* The content is centered and constraint in it's width. To make the content fill the whole page, set the variable to auto.*/
+    --content-maxwidth: 1050px;
+    --table-line-height: 24px;
+    --toc-sticky-top: var(--spacing-medium);
+    --toc-width: 200px;
+    --toc-max-height: calc(100vh - 2 * var(--spacing-medium) - 85px);
+
+    /* colors for various content boxes: @warning, @note, @deprecated @bug */
+    --warning-color: #f8d1cc;
+    --warning-color-dark: #b61825;
+    --warning-color-darker: #75070f;
+    --note-color: #faf3d8;
+    --note-color-dark: #f3a600;
+    --note-color-darker: #5f4204;
+    --todo-color: #e4f3ff;
+    --todo-color-dark: #1879C4;
+    --todo-color-darker: #274a5c;
+    --deprecated-color: #ecf0f3;
+    --deprecated-color-dark: #5b6269;
+    --deprecated-color-darker: #43454a;
+    --bug-color: #e4dafd;
+    --bug-color-dark: #5b2bdd;
+    --bug-color-darker: #2a0d72;
+    --invariant-color: #d8f1e3;
+    --invariant-color-dark: #44b86f;
+    --invariant-color-darker: #265532;
+
+    /* blockquote colors */
+    --blockquote-background: #f8f9fa;
+    --blockquote-foreground: #636568;
+
+    /* table colors */
+    --tablehead-background: #f1f1f1;
+    --tablehead-foreground: var(--page-foreground-color);
+
+    /* menu-display: block | none
+     * Visibility of the top navigation on screens >= 768px. On smaller screen the menu is always visible.
+     * `GENERATE_TREEVIEW` MUST be enabled!
+     */
+    --menu-display: block;
+
+    --menu-focus-foreground: var(--page-background-color);
+    --menu-focus-background: var(--primary-color);
+    --menu-selected-background: rgba(0,0,0,.05);
+
+
+    --header-background: var(--page-background-color);
+    --header-foreground: var(--page-foreground-color);
+
+    /* searchbar colors */
+    --searchbar-background: var(--side-nav-background);
+    --searchbar-foreground: var(--page-foreground-color);
+
+    /* searchbar size
+     * (`searchbar-width` is only applied on screens >= 768px.
+     * on smaller screens the searchbar will always fill the entire screen width) */
+    --searchbar-height: 33px;
+    --searchbar-width: 210px;
+    --searchbar-border-radius: var(--searchbar-height);
+
+    /* code block colors */
+    --code-background: #f5f5f5;
+    --code-foreground: var(--page-foreground-color);
+
+    /* fragment colors */
+    --fragment-background: #F8F9FA;
+    --fragment-foreground: #37474F;
+    --fragment-keyword: #bb6bb2;
+    --fragment-keywordtype: #8258b3;
+    --fragment-keywordflow: #d67c3b;
+    --fragment-token: #438a59;
+    --fragment-comment: #969696;
+    --fragment-link: #5383d6;
+    --fragment-preprocessor: #46aaa5;
+    --fragment-linenumber-color: #797979;
+    --fragment-linenumber-background: #f4f4f5;
+    --fragment-linenumber-border: #e3e5e7;
+    --fragment-lineheight: 20px;
+
+    /* sidebar navigation (treeview) colors */
+    --side-nav-background: #fbfbfb;
+    --side-nav-foreground: var(--page-foreground-color);
+    --side-nav-arrow-opacity: 0;
+    --side-nav-arrow-hover-opacity: 0.9;
+
+    --toc-background: var(--side-nav-background);
+    --toc-foreground: var(--side-nav-foreground);
+
+    /* height of an item in any tree / collapsable table */
+    --tree-item-height: 30px;
+
+    --memname-font-size: var(--code-font-size);
+    --memtitle-font-size: 18px;
+
+    --webkit-scrollbar-size: 7px;
+    --webkit-scrollbar-padding: 4px;
+    --webkit-scrollbar-color: var(--separator-color);
+}
+
+@media screen and (max-width: 767px) {
+    html {
+        --page-font-size: 16px;
+        --navigation-font-size: 16px;
+        --toc-font-size: 15px;
+        --code-font-size: 15px; /* affects code, fragment */
+        --title-font-size: 22px;
+    }
+}
+
+@media (prefers-color-scheme: dark) {
+    html:not(.light-mode) {
+        color-scheme: dark;
+
+        --primary-color: #1982d2;
+        --primary-dark-color: #86a9c4;
+        --primary-light-color: #4779ac;
+
+        --box-shadow: 0 2px 8px 0 rgba(0,0,0,.35);
+
+        --odd-color: rgba(100,100,100,.06);
+
+        --menu-selected-background: rgba(0,0,0,.4);
+
+        --page-background-color: #1C1D1F;
+        --page-foreground-color: #d2dbde;
+        --page-secondary-foreground-color: #859399;
+        --separator-color: #38393b;
+        --side-nav-background: #252628;
+
+        --code-background: #2a2c2f;
+
+        --tablehead-background: #2a2c2f;
+    
+        --blockquote-background: #222325;
+        --blockquote-foreground: #7e8c92;
+
+        --warning-color: #2e1917;
+        --warning-color-dark: #ad2617;
+        --warning-color-darker: #f5b1aa;
+        --note-color: #3b2e04;
+        --note-color-dark: #f1b602;
+        --note-color-darker: #ceb670;
+        --todo-color: #163750;
+        --todo-color-dark: #1982D2;
+        --todo-color-darker: #dcf0fa;
+        --deprecated-color: #2e323b;
+        --deprecated-color-dark: #738396;
+        --deprecated-color-darker: #abb0bd;
+        --bug-color: #2a2536;
+        --bug-color-dark: #7661b3;
+        --bug-color-darker: #ae9ed6;
+        --invariant-color: #303a35;
+        --invariant-color-dark: #76ce96;
+        --invariant-color-darker: #cceed5;
+
+        --fragment-background: #282c34;
+        --fragment-foreground: #dbe4eb;
+        --fragment-keyword: #cc99cd;
+        --fragment-keywordtype: #ab99cd;
+        --fragment-keywordflow: #e08000;
+        --fragment-token: #7ec699;
+        --fragment-comment: #999999;
+        --fragment-link: #98c0e3;
+        --fragment-preprocessor: #65cabe;
+        --fragment-linenumber-color: #cccccc;
+        --fragment-linenumber-background: #35393c;
+        --fragment-linenumber-border: #1f1f1f;
+    }
+}
+
+/* dark mode variables are defined twice, to support both the dark-mode without and with doxygen-awesome-darkmode-toggle.js */
+html.dark-mode {
+    color-scheme: dark;
+
+    --primary-color: #1982d2;
+    --primary-dark-color: #86a9c4;
+    --primary-light-color: #4779ac;
+
+    --box-shadow: 0 2px 8px 0 rgba(0,0,0,.30);
+
+    --odd-color: rgba(100,100,100,.06);
+
+    --menu-selected-background: rgba(0,0,0,.4);
+
+    --page-background-color: #1C1D1F;
+    --page-foreground-color: #d2dbde;
+    --page-secondary-foreground-color: #859399;
+    --separator-color: #38393b;
+    --side-nav-background: #252628;
+
+    --code-background: #2a2c2f;
+
+    --tablehead-background: #2a2c2f;
+
+    --blockquote-background: #222325;
+    --blockquote-foreground: #7e8c92;
+
+    --warning-color: #2e1917;
+    --warning-color-dark: #ad2617;
+    --warning-color-darker: #f5b1aa;
+    --note-color: #3b2e04;
+    --note-color-dark: #f1b602;
+    --note-color-darker: #ceb670;
+    --todo-color: #163750;
+    --todo-color-dark: #1982D2;
+    --todo-color-darker: #dcf0fa;
+    --deprecated-color: #2e323b;
+    --deprecated-color-dark: #738396;
+    --deprecated-color-darker: #abb0bd;
+    --bug-color: #2a2536;
+    --bug-color-dark: #7661b3;
+    --bug-color-darker: #ae9ed6;
+    --invariant-color: #303a35;
+    --invariant-color-dark: #76ce96;
+    --invariant-color-darker: #cceed5;
+
+    --fragment-background: #282c34;
+    --fragment-foreground: #dbe4eb;
+    --fragment-keyword: #cc99cd;
+    --fragment-keywordtype: #ab99cd;
+    --fragment-keywordflow: #e08000;
+    --fragment-token: #7ec699;
+    --fragment-comment: #999999;
+    --fragment-link: #98c0e3;
+    --fragment-preprocessor: #65cabe;
+    --fragment-linenumber-color: #cccccc;
+    --fragment-linenumber-background: #35393c;
+    --fragment-linenumber-border: #1f1f1f;
+}
+
+body {
+    color: var(--page-foreground-color);
+    background-color: var(--page-background-color);
+    font-size: var(--page-font-size);
+}
+
+body, table, div, p, dl, #nav-tree .label, .title,
+.sm-dox a, .sm-dox a:hover, .sm-dox a:focus, #projectname,
+.SelectItem, #MSearchField, .navpath li.navelem a,
+.navpath li.navelem a:hover, p.reference, p.definition {
+    font-family: var(--font-family);
+}
+
+h1, h2, h3, h4, h5 {
+    margin-top: .9em;
+    font-weight: 600;
+    line-height: initial;
+}
+
+p, div, table, dl, p.reference, p.definition {
+    font-size: var(--page-font-size);
+}
+
+p.reference, p.definition {
+    color: var(--page-secondary-foreground-color);
+}
+
+a:link, a:visited, a:hover, a:focus, a:active {
+    color: var(--primary-color) !important;
+    font-weight: 500;
+}
+
+a.anchor {
+    scroll-margin-top: var(--spacing-large);
+    display: block;
+}
+
+/*
+ Title and top navigation
+ */
+
+#top {
+    background: var(--header-background);
+    border-bottom: 1px solid var(--separator-color);
+}
+
+@media screen and (min-width: 768px) {
+    #top {
+        display: flex;
+        flex-wrap: wrap;
+        justify-content: space-between;
+        align-items: center;
+    }
+}
+
+#main-nav {
+    flex-grow: 5;
+    padding: var(--spacing-small) var(--spacing-medium);
+}
+
+#titlearea {
+    width: auto;
+    padding: var(--spacing-medium) var(--spacing-large);
+    background: none;
+    color: var(--header-foreground);
+    border-bottom: none;
+}
+
+@media screen and (max-width: 767px) {
+    #titlearea {
+        padding-bottom: var(--spacing-small);
+    }
+}
+
+#titlearea table tbody tr {
+    height: auto !important;
+}
+
+#projectname {
+    font-size: var(--title-font-size);
+    font-weight: 600;
+}
+
+#projectnumber {
+    font-family: inherit;
+    font-size: 60%;
+}
+
+#projectbrief {
+    font-family: inherit;
+    font-size: 80%;
+}
+
+#projectlogo {
+    vertical-align: middle;
+}
+
+#projectlogo img {
+    max-height: calc(var(--title-font-size) * 2);
+    margin-right: var(--spacing-small);
+}
+
+.sm-dox, .tabs, .tabs2, .tabs3 {
+    background: none;
+    padding: 0;
+}
+
+.tabs, .tabs2, .tabs3 {
+    border-bottom: 1px solid var(--separator-color);
+    margin-bottom: -1px;
+}
+
+.main-menu-btn-icon, .main-menu-btn-icon:before, .main-menu-btn-icon:after {
+    background: var(--page-secondary-foreground-color);
+}
+
+@media screen and (max-width: 767px) {
+    .sm-dox a span.sub-arrow {
+        background: var(--code-background);
+    }
+
+    #main-menu a.has-submenu span.sub-arrow {
+        color: var(--page-secondary-foreground-color);
+        border-radius: var(--border-radius-medium);
+    }
+
+    #main-menu a.has-submenu:hover span.sub-arrow {
+        color: var(--page-foreground-color);
+    }
+}
+
+@media screen and (min-width: 768px) {
+    .sm-dox li, .tablist li {
+        display: var(--menu-display);
+    }
+
+    .sm-dox a span.sub-arrow {
+        border-color: var(--header-foreground) transparent transparent transparent;
+    }
+
+    .sm-dox a:hover span.sub-arrow {
+        border-color: var(--menu-focus-foreground) transparent transparent transparent;
+    }
+
+    .sm-dox ul a span.sub-arrow {
+        border-color: transparent transparent transparent var(--page-foreground-color);
+    }
+
+    .sm-dox ul a:hover span.sub-arrow {
+        border-color: transparent transparent transparent var(--menu-focus-foreground);
+    }
+}
+
+.sm-dox ul {
+    background: var(--page-background-color);
+    box-shadow: var(--box-shadow);
+    border: 1px solid var(--separator-color);
+    border-radius: var(--border-radius-medium) !important;
+    padding: var(--spacing-small);
+    animation: ease-out 150ms slideInMenu;
+}
+
+@keyframes slideInMenu {
+    from {
+        opacity: 0;
+        transform: translate(0px, -2px);
+    }
+
+    to {
+        opacity: 1;
+        transform: translate(0px, 0px);
+    }
+}
+
+.sm-dox ul a {
+    color: var(--page-foreground-color) !important;
+    background: var(--page-background-color);
+    font-size: var(--navigation-font-size);
+}
+
+.sm-dox>li>ul:after {
+    border-bottom-color: var(--page-background-color) !important;
+}
+
+.sm-dox>li>ul:before {
+    border-bottom-color: var(--separator-color) !important;
+}
+
+.sm-dox ul a:hover, .sm-dox ul a:active, .sm-dox ul a:focus {
+    font-size: var(--navigation-font-size) !important;
+    color: var(--menu-focus-foreground) !important;
+    text-shadow: none;
+    background-color: var(--menu-focus-background);
+    border-radius: var(--border-radius-small) !important;
+}
+
+.sm-dox a, .sm-dox a:focus, .tablist li, .tablist li a, .tablist li.current a {
+    text-shadow: none;
+    background: transparent;
+    background-image: none !important;
+    color: var(--header-foreground) !important;
+    font-weight: normal;
+    font-size: var(--navigation-font-size);
+    border-radius: var(--border-radius-small) !important;
+}
+
+.sm-dox a:focus {
+    outline: auto;
+}
+
+.sm-dox a:hover, .sm-dox a:active, .tablist li a:hover {
+    text-shadow: none;
+    font-weight: normal;
+    background: var(--menu-focus-background);
+    color: var(--menu-focus-foreground) !important;
+    border-radius: var(--border-radius-small) !important;
+    font-size: var(--navigation-font-size);
+}
+
+.tablist li.current {
+    border-radius: var(--border-radius-small);
+    background: var(--menu-selected-background);
+}
+
+.tablist li {
+    margin: var(--spacing-small) 0 var(--spacing-small) var(--spacing-small);
+}
+
+.tablist a {
+    padding: 0 var(--spacing-large);
+}
+
+
+/*
+ Search box
+ */
+
+#MSearchBox {
+    height: var(--searchbar-height);
+    background: var(--searchbar-background);
+    border-radius: var(--searchbar-border-radius);
+    border: 1px solid var(--separator-color);
+    overflow: hidden;
+    width: var(--searchbar-width);
+    position: relative;
+    box-shadow: none;
+    display: block;
+    margin-top: 0;
+}
+
+/* until Doxygen 1.9.4 */
+.left img#MSearchSelect {
+    left: 0;
+    user-select: none;
+    padding-left: 8px;
+}
+
+/* Doxygen 1.9.5 */
+.left span#MSearchSelect {
+    left: 0;
+    user-select: none;
+    margin-left: 8px;
+    padding: 0;
+}
+
+.left #MSearchSelect[src$=".png"] {
+    padding-left: 0
+}
+
+.SelectionMark {
+    user-select: none;
+}
+
+.tabs .left #MSearchSelect {
+    padding-left: 0;
+}
+
+.tabs #MSearchBox {
+    position: absolute;
+    right: var(--spacing-medium);
+}
+
+@media screen and (max-width: 767px) {
+    .tabs #MSearchBox {
+        position: relative;
+        right: 0;
+        margin-left: var(--spacing-medium);
+        margin-top: 0;
+    }
+}
+
+#MSearchSelectWindow, #MSearchResultsWindow {
+    z-index: 9999;
+}
+
+#MSearchBox.MSearchBoxActive {
+    border-color: var(--primary-color);
+    box-shadow: inset 0 0 0 1px var(--primary-color);
+}
+
+#main-menu > li:last-child {
+    margin-right: 0;
+}
+
+@media screen and (max-width: 767px) {
+    #main-menu > li:last-child {
+        height: 50px;
+    }
+}
+
+#MSearchField {
+    font-size: var(--navigation-font-size);
+    height: calc(var(--searchbar-height) - 2px);
+    background: transparent;
+    width: calc(var(--searchbar-width) - 64px);
+}
+
+.MSearchBoxActive #MSearchField {
+    color: var(--searchbar-foreground);
+}
+
+#MSearchSelect {
+    top: calc(calc(var(--searchbar-height) / 2) - 11px);
+}
+
+#MSearchBox span.left, #MSearchBox span.right {
+    background: none;
+    background-image: none;
+}
+
+#MSearchBox span.right {
+    padding-top: calc(calc(var(--searchbar-height) / 2) - 12px);
+    position: absolute;
+    right: var(--spacing-small);
+}
+
+.tabs #MSearchBox span.right {
+    top: calc(calc(var(--searchbar-height) / 2) - 12px);
+}
+
+@keyframes slideInSearchResults {
+    from {
+        opacity: 0;
+        transform: translate(0, 15px);
+    }
+
+    to {
+        opacity: 1;
+        transform: translate(0, 20px);
+    }
+}
+
+#MSearchResultsWindow {
+    left: auto !important;
+    right: var(--spacing-medium);
+    border-radius: var(--border-radius-large);
+    border: 1px solid var(--separator-color);
+    transform: translate(0, 20px);
+    box-shadow: var(--box-shadow);
+    animation: ease-out 280ms slideInSearchResults;
+    background: var(--page-background-color);
+}
+
+iframe#MSearchResults {
+    margin: 4px;
+}
+
+iframe {
+    color-scheme: normal;
+}
+
+@media (prefers-color-scheme: dark) {
+    html:not(.light-mode) iframe#MSearchResults {
+        filter: invert() hue-rotate(180deg);
+    }
+}
+
+html.dark-mode iframe#MSearchResults {
+    filter: invert() hue-rotate(180deg);
+}
+
+#MSearchResults .SRPage {
+    background-color: transparent;
+}
+
+#MSearchResults .SRPage .SREntry {
+    font-size: 10pt;
+    padding: var(--spacing-small) var(--spacing-medium);
+}
+
+#MSearchSelectWindow {
+    border: 1px solid var(--separator-color);
+    border-radius: var(--border-radius-medium);
+    box-shadow: var(--box-shadow);
+    background: var(--page-background-color);
+    padding-top: var(--spacing-small);
+    padding-bottom: var(--spacing-small);
+}
+
+#MSearchSelectWindow a.SelectItem {
+    font-size: var(--navigation-font-size);
+    line-height: var(--content-line-height);
+    margin: 0 var(--spacing-small);
+    border-radius: var(--border-radius-small);
+    color: var(--page-foreground-color) !important;
+    font-weight: normal;
+}
+
+#MSearchSelectWindow a.SelectItem:hover {
+    background: var(--menu-focus-background);
+    color: var(--menu-focus-foreground) !important;
+}
+
+@media screen and (max-width: 767px) {
+    #MSearchBox {
+        margin-top: var(--spacing-medium);
+        margin-bottom: var(--spacing-medium);
+        width: calc(100vw - 30px);
+    }
+
+    #main-menu > li:last-child {
+        float: none !important;
+    }
+
+    #MSearchField {
+        width: calc(100vw - 110px);
+    }
+
+    @keyframes slideInSearchResultsMobile {
+        from {
+            opacity: 0;
+            transform: translate(0, 15px);
+        }
+
+        to {
+            opacity: 1;
+            transform: translate(0, 20px);
+        }
+    }
+
+    #MSearchResultsWindow {
+        left: var(--spacing-medium) !important;
+        right: var(--spacing-medium);
+        overflow: auto;
+        transform: translate(0, 20px);
+        animation: ease-out 280ms slideInSearchResultsMobile;
+        width: auto !important;
+    }
+
+    /*
+     * Overwrites for fixing the searchbox on mobile in doxygen 1.9.2
+     */
+    label.main-menu-btn ~ #searchBoxPos1 {
+        top: 3px !important;
+        right: 6px !important;
+        left: 45px;
+        display: flex;
+    }
+
+    label.main-menu-btn ~ #searchBoxPos1 > #MSearchBox {
+        margin-top: 0;
+        margin-bottom: 0;
+        flex-grow: 2;
+        float: left;
+    }
+}
+
+/*
+ Tree view
+ */
+
+#side-nav {
+    padding: 0 !important;
+    background: var(--side-nav-background);
+}
+
+@media screen and (max-width: 767px) {
+    #side-nav {
+        display: none;
+    }
+
+    #doc-content {
+        margin-left: 0 !important;
+    }
+}
+
+#nav-tree {
+    background: transparent;
+}
+
+#nav-tree .label {
+    font-size: var(--navigation-font-size);
+}
+
+#nav-tree .item {
+    height: var(--tree-item-height);
+    line-height: var(--tree-item-height);
+}
+
+#nav-sync {
+    bottom: 12px;
+    right: 12px;
+    top: auto !important;
+    user-select: none;
+}
+
+#nav-tree .selected {
+    text-shadow: none;
+    background-image: none;
+    background-color: transparent;
+    position: relative;
+}
+
+#nav-tree .selected::after {
+    content: "";
+    position: absolute;
+    top: 1px;
+    bottom: 1px;
+    left: 0;
+    width: 4px;
+    border-radius: 0 var(--border-radius-small) var(--border-radius-small) 0;
+    background: var(--primary-color);
+}
+
+
+#nav-tree a {
+    color: var(--side-nav-foreground) !important;
+    font-weight: normal;
+}
+
+#nav-tree a:focus {
+    outline-style: auto;
+}
+
+#nav-tree .arrow {
+    opacity: var(--side-nav-arrow-opacity);
+}
+
+.arrow {
+    color: inherit;
+    cursor: pointer;
+    font-size: 45%;
+    vertical-align: middle;
+    margin-right: 2px;
+    font-family: serif;
+    height: auto;
+    text-align: right;
+}
+
+#nav-tree div.item:hover .arrow, #nav-tree a:focus .arrow {
+    opacity: var(--side-nav-arrow-hover-opacity);
+}
+
+#nav-tree .selected a {
+    color: var(--primary-color) !important;
+    font-weight: bolder;
+    font-weight: 600;
+}
+
+.ui-resizable-e {
+    background: var(--separator-color);
+    width: 1px;
+}
+
+/*
+ Contents
+ */
+
+div.header {
+    border-bottom: 1px solid var(--separator-color);
+    background-color: var(--page-background-color);
+    background-image: none;
+}
+
+@media screen and (min-width: 1000px) {
+    #doc-content > div > div.contents,
+    .PageDoc > div.contents {
+        display: flex;
+        flex-direction: row-reverse;
+        flex-wrap: nowrap;
+        align-items: flex-start;
+    }
+    
+    div.contents .textblock {
+        min-width: 200px;
+        flex-grow: 1;
+    }
+}
+
+div.contents, div.header .title, div.header .summary {
+    max-width: var(--content-maxwidth);
+}
+
+div.contents, div.header .title  {
+    line-height: initial;
+    margin: calc(var(--spacing-medium) + .2em) auto var(--spacing-medium) auto;
+}
+
+div.header .summary {
+    margin: var(--spacing-medium) auto 0 auto;
+}
+
+div.headertitle {
+    padding: 0;
+}
+
+div.header .title {
+    font-weight: 600;
+    font-size: 225%;
+    padding: var(--spacing-medium) var(--spacing-large);
+    word-break: break-word;
+}
+
+div.header .summary {
+    width: auto;
+    display: block;
+    float: none;
+    padding: 0 var(--spacing-large);
+}
+
+td.memSeparator {
+    border-color: var(--separator-color);
+}
+
+span.mlabel {
+    background: var(--primary-color);
+    border: none;
+    padding: 4px 9px;
+    border-radius: 12px;
+    margin-right: var(--spacing-medium);
+}
+
+span.mlabel:last-of-type {
+    margin-right: 2px;
+}
+
+div.contents {
+    padding: 0 var(--spacing-large);
+}
+
+div.contents p, div.contents li {
+    line-height: var(--content-line-height);
+}
+
+div.contents div.dyncontent {
+    margin: var(--spacing-medium) 0;
+}
+
+@media (prefers-color-scheme: dark) {
+    html:not(.light-mode) div.contents div.dyncontent img,
+    html:not(.light-mode) div.contents center img,
+    html:not(.light-mode) div.contents > table img,
+    html:not(.light-mode) div.contents div.dyncontent iframe,
+    html:not(.light-mode) div.contents center iframe,
+    html:not(.light-mode) div.contents table iframe {
+        filter: hue-rotate(180deg) invert();
+    }
+}
+
+html.dark-mode div.contents div.dyncontent img,
+html.dark-mode div.contents center img,
+html.dark-mode div.contents > table img,
+html.dark-mode div.contents div.dyncontent iframe,
+html.dark-mode div.contents center iframe,
+html.dark-mode div.contents table iframe {
+    filter: hue-rotate(180deg) invert();
+}
+
+h2.groupheader {
+    border-bottom: 0px;
+    color: var(--page-foreground-color);
+    box-shadow: 
+        100px 0 var(--page-background-color), 
+        -100px 0 var(--page-background-color),
+        100px 0.75px var(--separator-color),
+        -100px 0.75px var(--separator-color),
+        500px 0 var(--page-background-color), 
+        -500px 0 var(--page-background-color),
+        500px 0.75px var(--separator-color),
+        -500px 0.75px var(--separator-color),
+        900px 0 var(--page-background-color), 
+        -900px 0 var(--page-background-color),
+        900px 0.75px var(--separator-color),
+        -900px 0.75px var(--separator-color),
+        1400px 0 var(--page-background-color),
+        -1400px 0 var(--page-background-color), 
+        1400px 0.75px var(--separator-color),
+        -1400px 0.75px var(--separator-color),
+        1900px 0 var(--page-background-color),
+        -1900px 0 var(--page-background-color),
+        1900px 0.75px var(--separator-color),
+        -1900px 0.75px var(--separator-color);
+}
+
+blockquote {
+    margin: 0 var(--spacing-medium) 0 var(--spacing-medium);
+    padding: var(--spacing-small) var(--spacing-large);
+    background: var(--blockquote-background);
+    color: var(--blockquote-foreground);
+    border-left: 0;
+    overflow: visible;
+    border-radius: var(--border-radius-medium);
+    overflow: visible;
+    position: relative;
+}
+
+blockquote::before, blockquote::after {
+    font-weight: bold;
+    font-family: serif;
+    font-size: 360%;
+    opacity: .15;
+    position: absolute;
+}
+
+blockquote::before {
+    content: "“";
+    left: -10px;
+    top: 4px;
+}
+
+blockquote::after {
+    content: "”";
+    right: -8px;
+    bottom: -25px;
+}
+
+blockquote p {
+    margin: var(--spacing-small) 0 var(--spacing-medium) 0;
+}
+.paramname {
+    font-weight: 600;
+    color: var(--primary-dark-color);
+}
+
+.paramname > code {
+    border: 0;
+}
+
+table.params .paramname {
+    font-weight: 600;
+    font-family: var(--font-family-monospace);
+    font-size: var(--code-font-size);
+    padding-right: var(--spacing-small);
+    line-height: var(--table-line-height);
+}
+
+h1.glow, h2.glow, h3.glow, h4.glow, h5.glow, h6.glow {
+    text-shadow: 0 0 15px var(--primary-light-color);
+}
+
+.alphachar a {
+    color: var(--page-foreground-color);
+}
+
+/*
+ Table of Contents
+ */
+
+div.contents .toc {
+    max-height: var(--toc-max-height);
+    min-width: var(--toc-width);
+    border: 0;
+    border-left: 1px solid var(--separator-color);
+    border-radius: 0;
+    background-color: transparent;
+    box-shadow: none;
+    position: sticky;
+    top: var(--toc-sticky-top);
+    padding: 0 var(--spacing-large);
+    margin: var(--spacing-small) 0 var(--spacing-large) var(--spacing-large);
+}
+
+div.toc h3 {
+    color: var(--toc-foreground);
+    font-size: var(--navigation-font-size);
+    margin: var(--spacing-large) 0 var(--spacing-medium) 0;
+}
+
+div.toc li {
+    padding: 0;
+    background: none;
+    line-height: var(--toc-font-size);
+    margin: var(--toc-font-size) 0 0 0;
+}
+
+div.toc li::before {
+    display: none;
+}
+
+div.toc ul {
+    margin-top: 0
+}
+
+div.toc li a {
+    font-size: var(--toc-font-size);
+    color: var(--page-foreground-color) !important;
+    text-decoration: none;
+}
+
+div.toc li a:hover, div.toc li a.active {
+    color: var(--primary-color) !important;
+}
+
+div.toc li a.aboveActive {
+    color: var(--page-secondary-foreground-color) !important;
+}
+
+
+@media screen and (max-width: 999px) {
+    div.contents .toc {
+        max-height: 45vh;
+        float: none;
+        width: auto;
+        margin: 0 0 var(--spacing-medium) 0;
+        position: relative;
+        top: 0;
+        position: relative;
+        border: 1px solid var(--separator-color);
+        border-radius: var(--border-radius-medium);
+        background-color: var(--toc-background);
+        box-shadow: var(--box-shadow);
+    }
+
+    div.contents .toc.interactive {
+        max-height: calc(var(--navigation-font-size) + 2 * var(--spacing-large));
+        overflow: hidden;
+    }
+
+    div.contents .toc > h3 {
+        -webkit-tap-highlight-color: transparent;
+        cursor: pointer;
+        position: sticky;
+        top: 0;
+        background-color: var(--toc-background);
+        margin: 0;
+        padding: var(--spacing-large) 0;
+        display: block;
+    }
+
+    div.contents .toc.interactive > h3::before {
+        content: "";
+        width: 0; 
+        height: 0; 
+        border-left: 4px solid transparent;
+        border-right: 4px solid transparent;
+        border-top: 5px solid var(--primary-color);
+        display: inline-block;
+        margin-right: var(--spacing-small);
+        margin-bottom: calc(var(--navigation-font-size) / 4);
+        transform: rotate(-90deg);
+        transition: transform 0.25s ease-out;
+    }
+
+    div.contents .toc.interactive.open > h3::before {
+        transform: rotate(0deg);
+    }
+
+    div.contents .toc.interactive.open {
+        max-height: 45vh;
+        overflow: auto;
+        transition: max-height 0.2s ease-in-out;
+    }
+
+    div.contents .toc a, div.contents .toc a.active {
+        color: var(--primary-color) !important;
+    }
+
+    div.contents .toc a:hover {
+        text-decoration: underline;
+    }
+}
+
+/*
+ Code & Fragments
+ */
+
+code, div.fragment, pre.fragment {
+    border-radius: var(--border-radius-small);
+    border: 1px solid var(--separator-color);
+    overflow: hidden;
+}
+
+code {
+    display: inline;
+    background: var(--code-background);
+    color: var(--code-foreground);
+    padding: 2px 6px;
+}
+
+div.fragment, pre.fragment {
+    margin: var(--spacing-medium) 0;
+    padding: calc(var(--spacing-large) - (var(--spacing-large) / 6)) var(--spacing-large);
+    background: var(--fragment-background);
+    color: var(--fragment-foreground);
+    overflow-x: auto;
+}
+
+@media screen and (max-width: 767px) {
+    div.fragment, pre.fragment {
+        border-top-right-radius: 0;
+        border-bottom-right-radius: 0;
+        border-right: 0;
+    }
+
+    .contents > div.fragment,
+    .textblock > div.fragment,
+    .textblock > pre.fragment,
+    .contents > .doxygen-awesome-fragment-wrapper > div.fragment,
+    .textblock > .doxygen-awesome-fragment-wrapper > div.fragment,
+    .textblock > .doxygen-awesome-fragment-wrapper > pre.fragment {
+        margin: var(--spacing-medium) calc(0px - var(--spacing-large));
+        border-radius: 0;
+        border-left: 0;
+    }
+
+    .textblock li > .fragment,
+    .textblock li > .doxygen-awesome-fragment-wrapper > .fragment {
+        margin: var(--spacing-medium) calc(0px - var(--spacing-large));
+    }
+
+    .memdoc li > .fragment,
+    .memdoc li > .doxygen-awesome-fragment-wrapper > .fragment {
+        margin: var(--spacing-medium) calc(0px - var(--spacing-medium));
+    }
+
+    .textblock ul, .memdoc ul {
+        overflow: initial;
+    }
+
+    .memdoc > div.fragment,
+    .memdoc > pre.fragment,
+    dl dd > div.fragment,
+    dl dd pre.fragment,
+    .memdoc > .doxygen-awesome-fragment-wrapper > div.fragment,
+    .memdoc > .doxygen-awesome-fragment-wrapper > pre.fragment,
+    dl dd > .doxygen-awesome-fragment-wrapper > div.fragment,
+    dl dd .doxygen-awesome-fragment-wrapper > pre.fragment {
+        margin: var(--spacing-medium) calc(0px - var(--spacing-medium));
+        border-radius: 0;
+        border-left: 0;
+    }
+}
+
+code, code a, pre.fragment, div.fragment, div.fragment .line, div.fragment span, div.fragment .line a, div.fragment .line span {
+    font-family: var(--font-family-monospace);
+    font-size: var(--code-font-size) !important;
+}
+
+div.line:after {
+    margin-right: var(--spacing-medium);
+}
+
+div.fragment .line, pre.fragment {
+    white-space: pre;
+    word-wrap: initial;
+    line-height: var(--fragment-lineheight);
+}
+
+div.fragment span.keyword {
+    color: var(--fragment-keyword);
+}
+
+div.fragment span.keywordtype {
+    color: var(--fragment-keywordtype);
+}
+
+div.fragment span.keywordflow {
+    color: var(--fragment-keywordflow);
+}
+
+div.fragment span.stringliteral {
+    color: var(--fragment-token)
+}
+
+div.fragment span.comment {
+    color: var(--fragment-comment);
+}
+
+div.fragment a.code {
+    color: var(--fragment-link) !important;
+}
+
+div.fragment span.preprocessor {
+    color: var(--fragment-preprocessor);
+}
+
+div.fragment span.lineno {
+    display: inline-block;
+    width: 27px;
+    border-right: none;
+    background: var(--fragment-linenumber-background);
+    color: var(--fragment-linenumber-color);
+}
+
+div.fragment span.lineno a {
+    background: none;
+    color: var(--fragment-link) !important;
+}
+
+div.fragment .line:first-child .lineno {
+    box-shadow: -999999px 0px 0 999999px var(--fragment-linenumber-background), -999998px 0px 0 999999px var(--fragment-linenumber-border);
+}
+
+div.line {
+    border-radius: var(--border-radius-small);
+}
+
+div.line.glow {
+    background-color: var(--primary-light-color);
+    box-shadow: none;
+}
+
+/*
+ dl warning, attention, note, deprecated, bug, ...
+ */
+
+dl.bug dt a, dl.deprecated dt a, dl.todo dt a {
+    font-weight: bold !important;
+}
+
+dl.warning, dl.attention, dl.note, dl.deprecated, dl.bug, dl.invariant, dl.pre, dl.todo, dl.remark {
+    padding: var(--spacing-medium);
+    margin: var(--spacing-medium) 0;
+    color: var(--page-background-color);
+    overflow: hidden;
+    margin-left: 0;
+    border-radius: var(--border-radius-small);
+}
+
+dl.section dd {
+    margin-bottom: 2px;
+}
+
+dl.warning, dl.attention {
+    background: var(--warning-color);
+    border-left: 8px solid var(--warning-color-dark);
+    color: var(--warning-color-darker);
+}
+
+dl.warning dt, dl.attention dt {
+    color: var(--warning-color-dark);
+}
+
+dl.note, dl.remark {
+    background: var(--note-color);
+    border-left: 8px solid var(--note-color-dark);
+    color: var(--note-color-darker);
+}
+
+dl.note dt, dl.remark dt {
+    color: var(--note-color-dark);
+}
+
+dl.todo {
+    background: var(--todo-color);
+    border-left: 8px solid var(--todo-color-dark);
+    color: var(--todo-color-darker);
+}
+
+dl.todo dt {
+    color: var(--todo-color-dark);
+}
+
+dl.bug dt a {
+    color: var(--todo-color-dark) !important;
+}
+
+dl.bug {
+    background: var(--bug-color);
+    border-left: 8px solid var(--bug-color-dark);
+    color: var(--bug-color-darker);
+}
+
+dl.bug dt a {
+    color: var(--bug-color-dark) !important;
+}
+
+dl.deprecated {
+    background: var(--deprecated-color);
+    border-left: 8px solid var(--deprecated-color-dark);
+    color: var(--deprecated-color-darker);
+}
+
+dl.deprecated dt a {
+    color: var(--deprecated-color-dark) !important;
+}
+
+dl.section dd, dl.bug dd, dl.deprecated dd, dl.todo dd {
+    margin-inline-start: 0px;
+}
+
+dl.invariant, dl.pre {
+    background: var(--invariant-color);
+    border-left: 8px solid var(--invariant-color-dark);
+    color: var(--invariant-color-darker);
+}
+
+dl.invariant dt, dl.pre dt {
+    color: var(--invariant-color-dark);
+}
+
+/*
+ memitem
+ */
+
+div.memdoc, div.memproto, h2.memtitle {
+    box-shadow: none;
+    background-image: none;
+    border: none;
+}
+
+div.memdoc {
+    padding: 0 var(--spacing-medium);
+    background: var(--page-background-color);
+}
+
+h2.memtitle, div.memitem {
+    border: 1px solid var(--separator-color);
+    box-shadow: var(--box-shadow);
+}
+
+h2.memtitle {
+    box-shadow: 0px var(--spacing-medium) 0 -1px var(--fragment-background), var(--box-shadow);
+}
+
+div.memitem {
+    transition: none;
+}
+
+div.memproto, h2.memtitle {
+    background: var(--fragment-background);
+}
+
+h2.memtitle {
+    font-weight: 500;
+    font-size: var(--memtitle-font-size);
+    font-family: var(--font-family-monospace);
+    border-bottom: none;
+    border-top-left-radius: var(--border-radius-medium);
+    border-top-right-radius: var(--border-radius-medium);
+    word-break: break-all;
+    position: relative;
+}
+
+h2.memtitle:after {
+    content: "";
+    display: block;
+    background: var(--fragment-background);
+    height: var(--spacing-medium);
+    bottom: calc(0px - var(--spacing-medium));
+    left: 0;
+    right: -14px;
+    position: absolute;
+    border-top-right-radius: var(--border-radius-medium);
+}
+
+h2.memtitle > span.permalink {
+    font-size: inherit;
+}
+
+h2.memtitle > span.permalink > a {
+    text-decoration: none;
+    padding-left: 3px;
+    margin-right: -4px;
+    user-select: none;
+    display: inline-block;
+    margin-top: -6px;
+}
+
+h2.memtitle > span.permalink > a:hover {
+    color: var(--primary-dark-color) !important;
+}
+
+a:target + h2.memtitle, a:target + h2.memtitle + div.memitem {
+    border-color: var(--primary-light-color);
+}
+
+div.memitem {
+    border-top-right-radius: var(--border-radius-medium);
+    border-bottom-right-radius: var(--border-radius-medium);
+    border-bottom-left-radius: var(--border-radius-medium);
+    overflow: hidden;
+    display: block !important;
+}
+
+div.memdoc {
+    border-radius: 0;
+}
+
+div.memproto {
+    border-radius: 0 var(--border-radius-small) 0 0;
+    overflow: auto;
+    border-bottom: 1px solid var(--separator-color);
+    padding: var(--spacing-medium);
+    margin-bottom: -1px;
+}
+
+div.memtitle {
+    border-top-right-radius: var(--border-radius-medium);
+    border-top-left-radius: var(--border-radius-medium);
+}
+
+div.memproto table.memname {
+    font-family: var(--font-family-monospace);
+    color: var(--page-foreground-color);
+    font-size: var(--memname-font-size);
+    text-shadow: none;
+}
+
+div.memproto div.memtemplate {
+    font-family: var(--font-family-monospace);
+    color: var(--primary-dark-color);
+    font-size: var(--memname-font-size);
+    margin-left: 2px;
+    text-shadow: none;
+}
+
+table.mlabels, table.mlabels > tbody {
+    display: block;
+}
+
+td.mlabels-left {
+    width: auto;
+}
+
+td.mlabels-right {
+    margin-top: 3px;
+    position: sticky;
+    left: 0;
+}
+
+table.mlabels > tbody > tr:first-child {
+    display: flex;
+    justify-content: space-between;
+    flex-wrap: wrap;
+}
+
+.memname, .memitem span.mlabels {
+    margin: 0
+}
+
+/*
+ reflist
+ */
+
+dl.reflist {
+    box-shadow: var(--box-shadow);
+    border-radius: var(--border-radius-medium);
+    border: 1px solid var(--separator-color);
+    overflow: hidden;
+    padding: 0;
+}
+
+
+dl.reflist dt, dl.reflist dd {
+    box-shadow: none;
+    text-shadow: none;
+    background-image: none;
+    border: none;
+    padding: 12px;
+}
+
+
+dl.reflist dt {
+    font-weight: 500;
+    border-radius: 0;
+    background: var(--code-background);
+    border-bottom: 1px solid var(--separator-color);
+    color: var(--page-foreground-color)
+}
+
+
+dl.reflist dd {
+    background: none;
+}
+
+/*
+ Table
+ */
+
+.contents table:not(.memberdecls):not(.mlabels):not(.fieldtable):not(.memname),
+.contents table:not(.memberdecls):not(.mlabels):not(.fieldtable):not(.memname) tbody {
+    display: inline-block;
+    max-width: 100%;
+}
+
+.contents > table:not(.memberdecls):not(.mlabels):not(.fieldtable):not(.memname):not(.classindex) {
+    margin-left: calc(0px - var(--spacing-large));
+    margin-right: calc(0px - var(--spacing-large));
+    max-width: calc(100% + 2 * var(--spacing-large));
+}
+
+table.fieldtable,
+table.markdownTable tbody,
+table.doxtable tbody {
+    border: none;
+    margin: var(--spacing-medium) 0;
+    box-shadow: 0 0 0 1px var(--separator-color);
+    border-radius: var(--border-radius-small);
+}
+
+table.doxtable caption {
+    display: block;
+}
+
+table.fieldtable {
+    border-collapse: collapse;
+    width: 100%;
+}
+
+th.markdownTableHeadLeft,
+th.markdownTableHeadRight,
+th.markdownTableHeadCenter,
+th.markdownTableHeadNone,
+table.doxtable th {
+    background: var(--tablehead-background);
+    color: var(--tablehead-foreground);
+    font-weight: 600;
+    font-size: var(--page-font-size);
+}
+
+th.markdownTableHeadLeft:first-child,
+th.markdownTableHeadRight:first-child,
+th.markdownTableHeadCenter:first-child,
+th.markdownTableHeadNone:first-child,
+table.doxtable tr th:first-child {
+    border-top-left-radius: var(--border-radius-small);
+}
+
+th.markdownTableHeadLeft:last-child,
+th.markdownTableHeadRight:last-child,
+th.markdownTableHeadCenter:last-child,
+th.markdownTableHeadNone:last-child,
+table.doxtable tr th:last-child {
+    border-top-right-radius: var(--border-radius-small);
+}
+
+table.markdownTable td,
+table.markdownTable th,
+table.fieldtable td,
+table.fieldtable th,
+table.doxtable td,
+table.doxtable th {
+    border: 1px solid var(--separator-color);
+    padding: var(--spacing-small) var(--spacing-medium);
+}
+
+table.markdownTable td:last-child,
+table.markdownTable th:last-child,
+table.fieldtable td:last-child,
+table.fieldtable th:last-child,
+table.doxtable td:last-child,
+table.doxtable th:last-child {
+    border-right: none;
+}
+
+table.markdownTable td:first-child,
+table.markdownTable th:first-child,
+table.fieldtable td:first-child,
+table.fieldtable th:first-child,
+table.doxtable td:first-child,
+table.doxtable th:first-child {
+    border-left: none;
+}
+
+table.markdownTable tr:first-child td,
+table.markdownTable tr:first-child th,
+table.fieldtable tr:first-child td,
+table.fieldtable tr:first-child th,
+table.doxtable tr:first-child td,
+table.doxtable tr:first-child th {
+    border-top: none;
+}
+
+table.markdownTable tr:last-child td,
+table.markdownTable tr:last-child th,
+table.fieldtable tr:last-child td,
+table.fieldtable tr:last-child th,
+table.doxtable tr:last-child td,
+table.doxtable tr:last-child th {
+    border-bottom: none;
+}
+
+table.markdownTable tr, table.doxtable tr {
+    border-bottom: 1px solid var(--separator-color);
+}
+
+table.markdownTable tr:last-child, table.doxtable tr:last-child {
+    border-bottom: none;
+}
+
+table.fieldtable th {
+    font-size: var(--page-font-size);
+    font-weight: 600;
+    background-image: none;
+    background-color: var(--tablehead-background);
+    color: var(--tablehead-foreground);
+}
+
+table.fieldtable td.fieldtype, .fieldtable td.fieldname, .fieldtable td.fielddoc, .fieldtable th {
+    border-bottom: 1px solid var(--separator-color);
+    border-right: 1px solid var(--separator-color);
+}
+
+table.fieldtable tr:last-child td:first-child {
+    border-bottom-left-radius: var(--border-radius-small);
+}
+
+table.fieldtable tr:last-child td:last-child {
+    border-bottom-right-radius: var(--border-radius-small);
+}
+
+.memberdecls td.glow, .fieldtable tr.glow {
+    background-color: var(--primary-light-color);
+    box-shadow: none;
+}
+
+table.memberdecls {
+    display: block;
+    -webkit-tap-highlight-color: transparent;
+}
+
+table.memberdecls tr[class^='memitem'] {
+    font-family: var(--font-family-monospace);
+    font-size: var(--code-font-size);
+}
+
+table.memberdecls tr[class^='memitem'] .memTemplParams {
+    font-family: var(--font-family-monospace);
+    font-size: var(--code-font-size);
+    color: var(--primary-dark-color);
+    white-space: normal;
+}
+
+table.memberdecls .memItemLeft,
+table.memberdecls .memItemRight,
+table.memberdecls .memTemplItemLeft,
+table.memberdecls .memTemplItemRight,
+table.memberdecls .memTemplParams {
+    transition: none;
+    padding-top: var(--spacing-small);
+    padding-bottom: var(--spacing-small);
+    border-top: 1px solid var(--separator-color);
+    border-bottom: 1px solid var(--separator-color);
+    background-color: var(--fragment-background);
+}
+
+table.memberdecls .memTemplItemLeft,
+table.memberdecls .memTemplItemRight {
+    padding-top: 2px;
+}
+
+table.memberdecls .memTemplParams {
+    border-bottom: 0;
+    border-left: 1px solid var(--separator-color);
+    border-right: 1px solid var(--separator-color);
+    border-radius: var(--border-radius-small) var(--border-radius-small) 0 0;
+    padding-bottom: var(--spacing-small);
+}
+
+table.memberdecls .memTemplItemLeft {
+    border-radius: 0 0 0 var(--border-radius-small);
+    border-left: 1px solid var(--separator-color);
+    border-top: 0;
+}
+
+table.memberdecls .memTemplItemRight {
+    border-radius: 0 0 var(--border-radius-small) 0;
+    border-right: 1px solid var(--separator-color);
+    padding-left: 0;
+    border-top: 0;
+}
+
+table.memberdecls .memItemLeft {
+    border-radius: var(--border-radius-small) 0 0 var(--border-radius-small);
+    border-left: 1px solid var(--separator-color);
+    padding-left: var(--spacing-medium);
+    padding-right: 0;
+}
+
+table.memberdecls .memItemRight  {
+    border-radius: 0 var(--border-radius-small) var(--border-radius-small) 0;
+    border-right: 1px solid var(--separator-color);
+    padding-right: var(--spacing-medium);
+    padding-left: 0;
+
+}
+
+table.memberdecls .mdescLeft, table.memberdecls .mdescRight {
+    background: none;
+    color: var(--page-foreground-color);
+    padding: var(--spacing-small) 0;
+}
+
+table.memberdecls .memItemLeft,
+table.memberdecls .memTemplItemLeft {
+    padding-right: var(--spacing-medium);
+}
+
+table.memberdecls .memSeparator {
+    background: var(--page-background-color);
+    height: var(--spacing-large);
+    border: 0;
+    transition: none;
+}
+
+table.memberdecls .groupheader {
+    margin-bottom: var(--spacing-large);
+}
+
+table.memberdecls .inherit_header td {
+    padding: 0 0 var(--spacing-medium) 0;
+    text-indent: -12px;
+    color: var(--page-secondary-foreground-color);
+}
+
+table.memberdecls img[src="closed.png"],
+table.memberdecls img[src="open.png"],
+div.dynheader img[src="open.png"],
+div.dynheader img[src="closed.png"] {
+    width: 0; 
+    height: 0; 
+    border-left: 4px solid transparent;
+    border-right: 4px solid transparent;
+    border-top: 5px solid var(--primary-color);
+    margin-top: 8px;
+    display: block;
+    float: left;
+    margin-left: -10px;
+    transition: transform 0.25s ease-out;
+}
+
+table.memberdecls img {
+    margin-right: 10px;
+}
+
+table.memberdecls img[src="closed.png"],
+div.dynheader img[src="closed.png"] {
+    transform: rotate(-90deg);
+    
+}
+
+.compoundTemplParams {
+    font-family: var(--font-family-monospace);
+    color: var(--primary-dark-color);
+    font-size: var(--code-font-size);
+}
+
+@media screen and (max-width: 767px) {
+
+    table.memberdecls .memItemLeft,
+    table.memberdecls .memItemRight,
+    table.memberdecls .mdescLeft,
+    table.memberdecls .mdescRight,
+    table.memberdecls .memTemplItemLeft,
+    table.memberdecls .memTemplItemRight,
+    table.memberdecls .memTemplParams {
+        display: block;
+        text-align: left;
+        padding-left: var(--spacing-large);
+        margin: 0 calc(0px - var(--spacing-large)) 0 calc(0px - var(--spacing-large));
+        border-right: none;
+        border-left: none;
+        border-radius: 0;
+        white-space: normal;
+    }
+
+    table.memberdecls .memItemLeft,
+    table.memberdecls .mdescLeft,
+    table.memberdecls .memTemplItemLeft {
+        border-bottom: 0;
+        padding-bottom: 0;
+    }
+
+    table.memberdecls .memTemplItemLeft {
+        padding-top: 0;
+    }
+
+    table.memberdecls .mdescLeft {
+        margin-bottom: calc(0px - var(--page-font-size));
+    }
+
+    table.memberdecls .memItemRight, 
+    table.memberdecls .mdescRight,
+    table.memberdecls .memTemplItemRight {
+        border-top: 0;
+        padding-top: 0;
+        padding-right: var(--spacing-large);
+        overflow-x: auto;
+    }
+
+    table.memberdecls tr[class^='memitem']:not(.inherit) {
+        display: block;
+        width: calc(100vw - 2 * var(--spacing-large));
+    }
+
+    table.memberdecls .mdescRight {
+        color: var(--page-foreground-color);
+    }
+
+    table.memberdecls tr.inherit {
+        visibility: hidden;
+    }
+
+    table.memberdecls tr[style="display: table-row;"] {
+        display: block !important;
+        visibility: visible;
+        width: calc(100vw - 2 * var(--spacing-large));
+        animation: fade .5s;
+    }
+
+    @keyframes fade {
+        0% {
+            opacity: 0;
+            max-height: 0;
+        }
+
+        100% {
+            opacity: 1;
+            max-height: 200px;
+        }
+    }
+}
+
+
+/*
+ Horizontal Rule
+ */
+
+hr {
+    margin-top: var(--spacing-large);
+    margin-bottom: var(--spacing-large);
+    height: 1px;
+    background-color: var(--separator-color);
+    border: 0;
+}
+
+.contents hr {
+    box-shadow: 100px 0 0 var(--separator-color),
+                -100px 0 0 var(--separator-color),
+                500px 0 0 var(--separator-color),
+                -500px 0 0 var(--separator-color),
+                1500px 0 0 var(--separator-color),
+                -1500px 0 0 var(--separator-color),
+                2000px 0 0 var(--separator-color),
+                -2000px 0 0 var(--separator-color);
+}
+
+.contents img, .contents .center, .contents center, .contents div.image object {
+    max-width: 100%;
+    overflow: auto;
+}
+
+@media screen and (max-width: 767px) {
+    .contents .dyncontent > .center, .contents > center {
+        margin-left: calc(0px - var(--spacing-large));
+        margin-right: calc(0px - var(--spacing-large));
+        max-width: calc(100% + 2 * var(--spacing-large));
+    }
+}
+
+/*
+ Directories
+ */
+div.directory {
+    border-top: 1px solid var(--separator-color);
+    border-bottom: 1px solid var(--separator-color);
+    width: auto;
+}
+
+table.directory {
+    font-family: var(--font-family);
+    font-size: var(--page-font-size);
+    font-weight: normal;
+    width: 100%;
+}
+
+table.directory td.entry, table.directory td.desc {
+    padding: calc(var(--spacing-small) / 2) var(--spacing-small);
+    line-height: var(--table-line-height);
+}
+
+table.directory tr.even td:last-child {
+    border-radius: 0 var(--border-radius-small) var(--border-radius-small) 0;
+}
+
+table.directory tr.even td:first-child {
+    border-radius: var(--border-radius-small) 0 0 var(--border-radius-small);
+}
+
+table.directory tr.even:last-child td:last-child {
+    border-radius: 0 var(--border-radius-small) 0 0;
+}
+
+table.directory tr.even:last-child td:first-child {
+    border-radius: var(--border-radius-small) 0 0 0;
+}
+
+table.directory td.desc {
+    min-width: 250px;
+}
+
+table.directory tr.even {
+    background-color: var(--odd-color);
+}
+
+table.directory tr.odd {
+    background-color: transparent;
+}
+
+.icona {
+    width: auto;
+    height: auto;
+    margin: 0 var(--spacing-small);
+}
+
+.icon {
+    background: var(--primary-color);
+    border-radius: var(--border-radius-small);
+    font-size: var(--page-font-size);
+    padding: calc(var(--page-font-size) / 5);
+    line-height: var(--page-font-size);
+    transform: scale(0.8);
+    height: auto;
+    width: var(--page-font-size);
+    user-select: none;
+}
+
+.iconfopen, .icondoc, .iconfclosed {
+    background-position: center;
+    margin-bottom: 0;
+    height: var(--table-line-height);
+}
+
+.icondoc {
+    filter: saturate(0.2);
+}
+
+@media screen and (max-width: 767px) {
+    div.directory {
+        margin-left: calc(0px - var(--spacing-large));
+        margin-right: calc(0px - var(--spacing-large));
+    }
+}
+
+@media (prefers-color-scheme: dark) {
+    html:not(.light-mode) .iconfopen, html:not(.light-mode) .iconfclosed {
+        filter: hue-rotate(180deg) invert();
+    }
+}
+
+html.dark-mode .iconfopen, html.dark-mode .iconfclosed {
+    filter: hue-rotate(180deg) invert();
+}
+
+/*
+ Class list
+ */
+
+.classindex dl.odd {
+    background: var(--odd-color);
+    border-radius: var(--border-radius-small);
+}
+
+.classindex dl.even {
+    background-color: transparent;
+}
+
+/* 
+ Class Index Doxygen 1.8 
+*/
+
+table.classindex {
+    margin-left: 0;
+    margin-right: 0;
+    width: 100%;
+}
+
+table.classindex table div.ah {
+    background-image: none;
+    background-color: initial;
+    border-color: var(--separator-color);
+    color: var(--page-foreground-color);
+    box-shadow: var(--box-shadow);
+    border-radius: var(--border-radius-large);
+    padding: var(--spacing-small);
+}
+
+div.qindex {
+    background-color: var(--odd-color);
+    border-radius: var(--border-radius-small);
+    border: 1px solid var(--separator-color);
+    padding: var(--spacing-small) 0;
+}
+
+/*
+  Footer and nav-path
+ */
+
+#nav-path {
+    width: 100%;
+}
+
+#nav-path ul {
+    background-image: none;
+    background: var(--page-background-color);
+    border: none;
+    border-top: 1px solid var(--separator-color);
+    border-bottom: 1px solid var(--separator-color);
+    border-bottom: 0;
+    box-shadow: 0 0.75px 0 var(--separator-color);
+    font-size: var(--navigation-font-size);
+}
+
+img.footer {
+    width: 60px;
+}
+
+.navpath li.footer {
+    color: var(--page-secondary-foreground-color);
+}
+
+address.footer {
+    color: var(--page-secondary-foreground-color);
+    margin-bottom: var(--spacing-large);
+}
+
+#nav-path li.navelem {
+    background-image: none;
+    display: flex;
+    align-items: center;
+}
+
+.navpath li.navelem a {
+    text-shadow: none;
+    display: inline-block;
+    color: var(--primary-color) !important;
+}
+
+.navpath li.navelem b {
+    color: var(--primary-dark-color);
+    font-weight: 500;
+}
+
+li.navelem {
+    padding: 0;
+    margin-left: -8px;
+}
+
+li.navelem:first-child {
+    margin-left: var(--spacing-large);
+}
+
+li.navelem:first-child:before {
+    display: none;
+}
+
+#nav-path li.navelem:after {
+    content: '';
+    border: 5px solid var(--page-background-color);
+    border-bottom-color: transparent;
+    border-right-color: transparent;
+    border-top-color: transparent;
+    transform: translateY(-1px) scaleY(4.2);
+    z-index: 10;
+    margin-left: 6px;
+}
+
+#nav-path li.navelem:before {
+    content: '';
+    border: 5px solid var(--separator-color);
+    border-bottom-color: transparent;
+    border-right-color: transparent;
+    border-top-color: transparent;
+    transform: translateY(-1px) scaleY(3.2);
+    margin-right: var(--spacing-small);
+}
+
+.navpath li.navelem a:hover {
+    color: var(--primary-color);
+}
+
+/*
+ Scrollbars for Webkit
+*/
+
+#nav-tree::-webkit-scrollbar,
+div.fragment::-webkit-scrollbar,
+pre.fragment::-webkit-scrollbar,
+div.memproto::-webkit-scrollbar,
+.contents center::-webkit-scrollbar,
+.contents .center::-webkit-scrollbar,
+.contents table:not(.memberdecls):not(.mlabels):not(.fieldtable):not(.memname) tbody::-webkit-scrollbar,
+div.contents .toc::-webkit-scrollbar {
+    background: transparent;
+    width: calc(var(--webkit-scrollbar-size) + var(--webkit-scrollbar-padding) + var(--webkit-scrollbar-padding));
+    height: calc(var(--webkit-scrollbar-size) + var(--webkit-scrollbar-padding) + var(--webkit-scrollbar-padding));
+}
+
+#nav-tree::-webkit-scrollbar-thumb,
+div.fragment::-webkit-scrollbar-thumb,
+pre.fragment::-webkit-scrollbar-thumb,
+div.memproto::-webkit-scrollbar-thumb,
+.contents center::-webkit-scrollbar-thumb,
+.contents .center::-webkit-scrollbar-thumb,
+.contents table:not(.memberdecls):not(.mlabels):not(.fieldtable):not(.memname) tbody::-webkit-scrollbar-thumb,
+div.contents .toc::-webkit-scrollbar-thumb {
+    background-color: transparent;
+    border: var(--webkit-scrollbar-padding) solid transparent;
+    border-radius: calc(var(--webkit-scrollbar-padding) + var(--webkit-scrollbar-padding));
+    background-clip: padding-box;  
+}
+
+#nav-tree:hover::-webkit-scrollbar-thumb,
+div.fragment:hover::-webkit-scrollbar-thumb,
+pre.fragment:hover::-webkit-scrollbar-thumb,
+div.memproto:hover::-webkit-scrollbar-thumb,
+.contents center:hover::-webkit-scrollbar-thumb,
+.contents .center:hover::-webkit-scrollbar-thumb,
+.contents table:not(.memberdecls):not(.mlabels):not(.fieldtable):not(.memname) tbody:hover::-webkit-scrollbar-thumb,
+div.contents .toc:hover::-webkit-scrollbar-thumb {
+    background-color: var(--webkit-scrollbar-color);
+}
+
+#nav-tree::-webkit-scrollbar-track,
+div.fragment::-webkit-scrollbar-track,
+pre.fragment::-webkit-scrollbar-track,
+div.memproto::-webkit-scrollbar-track,
+.contents center::-webkit-scrollbar-track,
+.contents .center::-webkit-scrollbar-track,
+.contents table:not(.memberdecls):not(.mlabels):not(.fieldtable):not(.memname) tbody::-webkit-scrollbar-track,
+div.contents .toc::-webkit-scrollbar-track {
+    background: transparent;
+}
+
+#nav-tree::-webkit-scrollbar-corner {
+    background-color: var(--side-nav-background);
+}
+
+#nav-tree,
+div.fragment,
+pre.fragment,
+div.memproto,
+.contents center,
+.contents .center,
+.contents table:not(.memberdecls):not(.mlabels):not(.fieldtable):not(.memname) tbody,
+div.contents .toc {
+    overflow-x: auto;
+    overflow-x: overlay;
+}
+
+#nav-tree {
+    overflow-x: auto;
+    overflow-y: auto;
+    overflow-y: overlay;
+}
+
+/*
+ Scrollbars for Firefox
+*/
+
+#nav-tree,
+div.fragment,
+pre.fragment,
+div.memproto,
+.contents center,
+.contents .center,
+.contents table:not(.memberdecls):not(.mlabels):not(.fieldtable):not(.memname) tbody,
+div.contents .toc {
+    scrollbar-width: thin;
+}
+
+/*
+  Optional Dark mode toggle button
+*/
+
+doxygen-awesome-dark-mode-toggle {
+    display: inline-block;
+    margin: 0 0 0 var(--spacing-small);
+    padding: 0;
+    width: var(--searchbar-height);
+    height: var(--searchbar-height);
+    background: none;
+    border: none;
+    border-radius: var(--searchbar-height);
+    vertical-align: middle;
+    text-align: center;
+    line-height: var(--searchbar-height);
+    font-size: 22px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    user-select: none;
+    cursor: pointer;
+}
+
+doxygen-awesome-dark-mode-toggle > svg {
+    transition: transform .1s ease-in-out;
+}
+
+doxygen-awesome-dark-mode-toggle:active > svg {
+    transform: scale(.5);
+}
+
+doxygen-awesome-dark-mode-toggle:hover {
+    background-color: rgba(0,0,0,.03);
+}
+
+html.dark-mode doxygen-awesome-dark-mode-toggle:hover {
+    background-color: rgba(0,0,0,.18);
+}
+
+/*
+ Optional fragment copy button
+*/
+.doxygen-awesome-fragment-wrapper {
+    position: relative;
+}
+
+doxygen-awesome-fragment-copy-button {
+    opacity: 0;
+    background: var(--fragment-background);
+    width: 28px;
+    height: 28px;
+    position: absolute;
+    right: calc(var(--spacing-large) - (var(--spacing-large) / 2.5));
+    top: calc(var(--spacing-large) - (var(--spacing-large) / 2.5));
+    border: 1px solid var(--fragment-foreground);
+    cursor: pointer;
+    border-radius: var(--border-radius-small);
+    display: flex;
+    justify-content: center;
+    align-items: center;
+}
+
+.doxygen-awesome-fragment-wrapper:hover doxygen-awesome-fragment-copy-button, doxygen-awesome-fragment-copy-button.success {
+    opacity: .28;
+}
+
+doxygen-awesome-fragment-copy-button:hover, doxygen-awesome-fragment-copy-button.success {
+    opacity: 1 !important;
+}
+
+doxygen-awesome-fragment-copy-button:active:not([class~=success]) svg {
+    transform: scale(.91);
+}
+
+doxygen-awesome-fragment-copy-button svg {
+    fill: var(--fragment-foreground);
+    width: 18px;
+    height: 18px;
+}
+
+doxygen-awesome-fragment-copy-button.success svg {
+    fill: rgb(14, 168, 14);
+}
+
+doxygen-awesome-fragment-copy-button.success {
+    border-color: rgb(14, 168, 14);
+}
+
+@media screen and (max-width: 767px) {
+    .textblock > .doxygen-awesome-fragment-wrapper > doxygen-awesome-fragment-copy-button,
+    .textblock li > .doxygen-awesome-fragment-wrapper > doxygen-awesome-fragment-copy-button,
+    .memdoc li > .doxygen-awesome-fragment-wrapper > doxygen-awesome-fragment-copy-button,
+    .memdoc > .doxygen-awesome-fragment-wrapper > doxygen-awesome-fragment-copy-button,
+    dl dd > .doxygen-awesome-fragment-wrapper > doxygen-awesome-fragment-copy-button {
+        right: 0;
+    }
+}
+
+/*
+ Optional paragraph link button
+*/
+
+a.anchorlink {
+    font-size: 90%;
+    margin-left: var(--spacing-small);
+    color: var(--page-foreground-color) !important;
+    text-decoration: none;
+    opacity: .15;
+    display: none;
+    transition: opacity .1s ease-in-out, color .1s ease-in-out;
+}
+
+a.anchorlink svg {
+    fill: var(--page-foreground-color);
+}
+
+h3 a.anchorlink svg, h4 a.anchorlink svg {
+    margin-bottom: -3px;
+    margin-top: -4px;
+}
+
+a.anchorlink:hover {
+    opacity: .45;
+}
+
+h2:hover a.anchorlink, h1:hover a.anchorlink, h3:hover a.anchorlink, h4:hover a.anchorlink  {
+    display: inline-block;
+}
diff --git a/Docs/doxygen-awesome-css/doxygen-custom/custom-alternative.css b/Docs/doxygen-awesome-css/doxygen-custom/custom-alternative.css
new file mode 100644
index 000000000..e66c1aee5
--- /dev/null
+++ b/Docs/doxygen-awesome-css/doxygen-custom/custom-alternative.css
@@ -0,0 +1,54 @@
+html.alternative {
+    /* primary theme color. This will affect the entire websites color scheme: links, arrows, labels, ... */
+    --primary-color: #AF7FE4;
+    --primary-dark-color: #9270E4;
+    --primary-light-color: #7aabd6;
+    --primary-lighter-color: #cae1f1;
+    --primary-lightest-color: #e9f1f8;
+
+    /* page base colors */
+    --page-background-color: white;
+    --page-foreground-color: #2c3e50;
+    --page-secondary-foreground-color: #67727e;
+
+
+    --border-radius-large: 22px;
+    --border-radius-small: 9px;
+    --border-radius-medium: 14px;
+    --spacing-small: 8px;
+    --spacing-medium: 14px;
+    --spacing-large: 19px;
+
+    --top-height: 125px;
+
+    --side-nav-background: #324067;
+    --side-nav-foreground: #F1FDFF;
+    --header-foreground: var(--side-nav-foreground);
+    --searchbar-background: var(--side-nav-foreground);
+    --searchbar-border-radius: var(--border-radius-medium);
+    --header-background: var(--side-nav-background);
+    --header-foreground: var(--side-nav-foreground);
+
+    --toc-background: rgb(243, 240, 252);
+    --toc-foreground: var(--page-foreground-color);
+}
+
+html.alternative.dark-mode {
+    color-scheme: dark;
+
+    --primary-color: #AF7FE4;
+    --primary-dark-color: #9270E4;
+    --primary-light-color: #4779ac;
+    --primary-lighter-color: #191e21;
+    --primary-lightest-color: #191a1c;
+
+    --page-background-color: #1C1D1F;
+    --page-foreground-color: #d2dbde;
+    --page-secondary-foreground-color: #859399;
+    --separator-color: #3a3246;
+    --side-nav-background: #171D32;
+    --side-nav-foreground: #F1FDFF;
+    --toc-background: #20142C;
+    --searchbar-background: var(--page-background-color);
+
+}
\ No newline at end of file
diff --git a/Docs/doxygen-awesome-css/doxygen-custom/custom.css b/Docs/doxygen-awesome-css/doxygen-custom/custom.css
new file mode 100644
index 000000000..0e694c0b5
--- /dev/null
+++ b/Docs/doxygen-awesome-css/doxygen-custom/custom.css
@@ -0,0 +1,101 @@
+.github-corner svg {
+    fill: var(--primary-light-color);
+    color: var(--page-background-color);
+    width: 72px;
+    height: 72px;
+}
+
+@media screen and (max-width: 767px) {
+    .github-corner svg {
+        width: 50px;
+        height: 50px;
+    }
+    #projectnumber {
+        margin-right: 22px;
+    }
+}
+
+.alter-theme-button {
+    display: inline-block;
+    cursor: pointer;
+    background: var(--primary-color);
+    color: var(--page-background-color) !important;
+    border-radius: var(--border-radius-medium);
+    padding: var(--spacing-small) var(--spacing-medium);
+    text-decoration: none;
+}
+
+.next_section_button {
+    display: block;
+    padding: var(--spacing-large) 0 var(--spacing-small) 0;
+    color: var(--page-background-color);
+    user-select: none;
+}
+
+.next_section_button::after {
+    /* clearfix */
+    content: "";
+    clear: both;
+    display: table;
+}
+
+.next_section_button a {
+    overflow: hidden;
+    float: right;
+    border: 1px solid var(--separator-color);
+    padding: var(--spacing-medium) calc(var(--spacing-large) / 2) var(--spacing-medium) var(--spacing-large);
+    border-radius: var(--border-radius-medium);
+    color: var(--page-secondary-foreground-color) !important;
+    text-decoration: none;
+    background-color: var(--page-background-color);
+    transition: color .08s ease-in-out, background-color .1s ease-in-out;
+}
+
+.next_section_button a:hover {
+    color: var(--page-foreground-color) !important;
+    background-color: var(--odd-color);
+}
+
+.next_section_button a::after {
+    content: '〉';
+    color: var(--page-secondary-foreground-color) !important;
+    padding-left: var(--spacing-large);
+    display: inline-block;
+    transition: color .08s ease-in-out, transform .09s ease-in-out;
+}
+
+.next_section_button a:hover::after {
+    color: var(--page-foreground-color) !important;
+    transform: translateX(3px);
+}
+
+.alter-theme-button:hover {
+    background: var(--primary-dark-color);
+}
+
+html.dark-mode .darkmode_inverted_image img, /* < doxygen 1.9.3 */
+html.dark-mode .darkmode_inverted_image object[type="image/svg+xml"] /* doxygen 1.9.3 */ {
+    filter: brightness(87%) hue-rotate(180deg) invert();
+}
+
+.bordered_image {
+    border-radius: var(--border-radius-small);
+    border: 1px solid var(--separator-color);
+    display: inline-block;
+    overflow: hidden;
+}
+
+html.dark-mode .bordered_image img, /* < doxygen 1.9.3 */
+html.dark-mode .bordered_image object[type="image/svg+xml"] /* doxygen 1.9.3 */ {
+    border-radius: var(--border-radius-small);
+}
+
+.title_screenshot {
+    filter: drop-shadow(0px 3px 10px rgba(0,0,0,0.22));
+    max-width: 500px;
+    margin: var(--spacing-large) 0;
+}
+
+.title_screenshot .caption {
+    display: none;
+}
\ No newline at end of file
diff --git a/Docs/doxygen-awesome-css/doxygen-custom/header.html b/Docs/doxygen-awesome-css/doxygen-custom/header.html
new file mode 100644
index 000000000..1fc73c5a4
--- /dev/null
+++ b/Docs/doxygen-awesome-css/doxygen-custom/header.html
@@ -0,0 +1,88 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen $doxygenversion"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+
+<!-- BEGIN opengraph metadata -->
+<meta property="og:title" content="Doxygen Awesome" />
+<meta property="og:image" content="https://repository-images.githubusercontent.com/348492097/4f16df80-88fb-11eb-9d31-4015ff22c452" />
+<meta property="og:description" content="Custom CSS theme for doxygen html-documentation with lots of customization parameters." />
+<meta property="og:url" content="https://jothepro.github.io/doxygen-awesome-css/" />
+<!-- END opengraph metadata -->
+
+<!-- BEGIN twitter metadata -->
+<meta name="twitter:image:src" content="https://repository-images.githubusercontent.com/348492097/4f16df80-88fb-11eb-9d31-4015ff22c452" />
+<meta name="twitter:title" content="Doxygen Awesome" />
+<meta name="twitter:description" content="Custom CSS theme for doxygen html-documentation with lots of customization parameters." />
+<!-- END twitter metadata -->
+
+<!--BEGIN PROJECT_NAME--><title>$projectname: $title</title><!--END PROJECT_NAME-->
+<!--BEGIN !PROJECT_NAME--><title>$title</title><!--END !PROJECT_NAME-->
+<link href="$relpath^tabs.css" rel="stylesheet" type="text/css"/>
+<link rel="icon" type="image/svg+xml" href="logo.drawio.svg"/>
+<script type="text/javascript" src="$relpath^jquery.js"></script>
+<script type="text/javascript" src="$relpath^dynsections.js"></script>
+<script type="text/javascript" src="$relpath^doxygen-awesome-darkmode-toggle.js"></script>
+<script type="text/javascript" src="$relpath^doxygen-awesome-fragment-copy-button.js"></script>
+<script type="text/javascript" src="$relpath^doxygen-awesome-paragraph-link.js"></script>
+<script type="text/javascript" src="$relpath^doxygen-awesome-interactive-toc.js"></script>
+<script type="text/javascript" src="$relpath^toggle-alternative-theme.js"></script>
+<script type="text/javascript">
+    DoxygenAwesomeFragmentCopyButton.init()
+    DoxygenAwesomeDarkModeToggle.init()
+    DoxygenAwesomeParagraphLink.init()
+    DoxygenAwesomeInteractiveToc.init()
+</script>
+$treeview
+$search
+$mathjax
+<link href="$relpath^$stylesheet" rel="stylesheet" type="text/css" />
+$extrastylesheet
+</head>
+<body>
+
+<!-- https://tholman.com/github-corners/ -->
+<a href="https://github.com/jothepro/doxygen-awesome-css" class="github-corner" title="View source on GitHub" target="_blank">
+    <svg viewBox="0 0 250 250" width="40" height="40" style="position: absolute; top: 0; border: 0; right: 0; z-index: 99;" aria-hidden="true">
+    <path d="M0,0 L115,115 L130,115 L142,142 L250,250 L250,0 Z"></path><path d="M128.3,109.0 C113.8,99.7 119.0,89.6 119.0,89.6 C122.0,82.7 120.5,78.6 120.5,78.6 C119.2,72.0 123.4,76.3 123.4,76.3 C127.3,80.9 125.5,87.3 125.5,87.3 C122.9,97.6 130.6,101.9 134.4,103.2" fill="currentColor" style="transform-origin: 130px 106px;" class="octo-arm"></path><path d="M115.0,115.0 C114.9,115.1 118.7,116.5 119.8,115.4 L133.7,101.6 C136.9,99.2 139.9,98.4 142.2,98.6 C133.8,88.0 127.5,74.4 143.8,58.0 C148.5,53.4 154.0,51.2 159.7,51.0 C160.3,49.4 163.2,43.6 171.4,40.1 C171.4,40.1 176.1,42.5 178.8,56.2 C183.1,58.6 187.2,61.8 190.9,65.4 C194.5,69.0 197.7,73.2 200.1,77.6 C213.8,80.2 216.3,84.9 216.3,84.9 C212.7,93.1 206.9,96.0 205.4,96.6 C205.1,102.4 203.0,107.8 198.3,112.5 C181.9,128.9 168.3,122.5 157.7,114.1 C157.9,116.9 156.7,120.9 152.7,124.9 L141.0,136.5 C139.8,137.7 141.6,141.9 141.8,141.8 Z" fill="currentColor" class="octo-body"></path></svg></a><style>.github-corner:hover .octo-arm{animation:octocat-wave 560ms ease-in-out}@keyframes octocat-wave{0%,100%{transform:rotate(0)}20%,60%{transform:rotate(-25deg)}40%,80%{transform:rotate(10deg)}}@media (max-width:500px){.github-corner:hover .octo-arm{animation:none}.github-corner .octo-arm{animation:octocat-wave 560ms ease-in-out}}</style>
+
+
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+
+<!--BEGIN TITLEAREA-->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <!--BEGIN PROJECT_LOGO-->
+  <td id="projectlogo"><img alt="Logo" src="$relpath^$projectlogo"/></td>
+  <!--END PROJECT_LOGO-->
+  <!--BEGIN PROJECT_NAME-->
+  <td id="projectalign" style="padding-left: 0.5em;">
+   <div id="projectname">$projectname
+   <!--BEGIN PROJECT_NUMBER-->&#160;<span id="projectnumber">$projectnumber</span><!--END PROJECT_NUMBER-->
+   </div>
+   <!--BEGIN PROJECT_BRIEF--><div id="projectbrief">$projectbrief</div><!--END PROJECT_BRIEF-->
+  </td>
+  <!--END PROJECT_NAME-->
+  <!--BEGIN !PROJECT_NAME-->
+   <!--BEGIN PROJECT_BRIEF-->
+    <td style="padding-left: 0.5em;">
+    <div id="projectbrief">$projectbrief</div>
+    </td>
+   <!--END PROJECT_BRIEF-->
+  <!--END !PROJECT_NAME-->
+  <!--BEGIN DISABLE_INDEX-->
+   <!--BEGIN SEARCHENGINE-->
+   <td>$searchbox</td>
+   <!--END SEARCHENGINE-->
+  <!--END DISABLE_INDEX-->
+ </tr>
+ </tbody>
+</table>
+</div>
+<!--END TITLEAREA-->
+<!-- end header part -->
diff --git a/Docs/doxygen-awesome-css/doxygen-custom/toggle-alternative-theme.js b/Docs/doxygen-awesome-css/doxygen-custom/toggle-alternative-theme.js
new file mode 100644
index 000000000..72c373172
--- /dev/null
+++ b/Docs/doxygen-awesome-css/doxygen-custom/toggle-alternative-theme.js
@@ -0,0 +1,12 @@
+
+let original_theme_active = true;
+
+function toggle_alternative_theme() {
+    if(original_theme_active) {
+        document.documentElement.classList.add("alternative")
+        original_theme_active = false;
+    } else {
+        document.documentElement.classList.remove("alternative")
+        original_theme_active = true;
+    }
+}
\ No newline at end of file
diff --git a/Docs/footer.html b/Docs/footer.html
index 5bd570ad1..d67b2be18 100644
--- a/Docs/footer.html
+++ b/Docs/footer.html
@@ -5,16 +5,16 @@
   <ul>
     $navpath
       &nbsp;&nbsp;<a href="https://github.com/recastnavigation/recastnavigation">Project Home</a> 
-      | <a href="./License.html">Licence: ZLib</a>
-      | Copyright (c) 2009-2014 Mikko Mononen
+      | <a href="./License.txt">Licence (ZLib)</a>
+      | Copyright 2009 Mikko Mononen
   </ul>
 </div>
 <!--END GENERATE_TREEVIEW-->
 <!--BEGIN !GENERATE_TREEVIEW-->
 <hr class="footer"/><address class="footer"><small>
   &nbsp;&nbsp;<a href="https://github.com/recastnavigation/recastnavigation">Project Home</a> 
-  | <a href="./License.html">Licence: ZLib</a>
-  | Copyright (c) 2009-2014 Mikko Mononen
+  | <a href="./License.txt">Licence (ZLib)</a>
+  | Copyright 2009 Mikko Mononen
 </small></address>
 <!--END !GENERATE_TREEVIEW-->
 </body>
diff --git a/Doxyfile b/Doxyfile
index e175a45cc..dd7f5ed2f 100644
--- a/Doxyfile
+++ b/Doxyfile
@@ -1,4 +1,4 @@
-# Doxyfile 1.8.10
+# Doxyfile 1.9.5
 
 # This file describes the settings to be used by the documentation system
 # doxygen (www.doxygen.org) for a project.
@@ -12,16 +12,26 @@
 # For lists, items can also be appended using:
 # TAG += value [value, ...]
 # Values that contain spaces should be placed between quotes (\" \").
+#
+# Note:
+#
+# Use doxygen to compare the used configuration file with the template
+# configuration file:
+# doxygen -x [configFile]
+# Use doxygen to compare the used configuration file with the template
+# configuration file without replacing the environment variables or CMake type
+# replacement variables:
+# doxygen -x_noenv [configFile]
 
 #---------------------------------------------------------------------------
 # Project related configuration options
 #---------------------------------------------------------------------------
 
-# This tag specifies the encoding used for all characters in the config file
-# that follow. The default is UTF-8 which is also the encoding used for all text
-# before the first occurrence of this tag. Doxygen uses libiconv (or the iconv
-# built into libc) for the transcoding. See http://www.gnu.org/software/libiconv
-# for the list of possible encodings.
+# This tag specifies the encoding used for all characters in the configuration
+# file that follow. The default is UTF-8 which is also the encoding used for all
+# text before the first occurrence of this tag. Doxygen uses libiconv (or the
+# iconv built into libc) for the transcoding. See
+# https://www.gnu.org/software/libiconv/ for the list of possible encodings.
 # The default value is: UTF-8.
 
 DOXYFILE_ENCODING      = UTF-8
@@ -38,7 +48,7 @@ PROJECT_NAME           = "Recast Navigation"
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = 
+PROJECT_NUMBER         =
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a
@@ -51,7 +61,7 @@ PROJECT_BRIEF          = "Navigation-mesh Toolset for Games"
 # pixels and the maximum width should not exceed 200 pixels. Doxygen will copy
 # the logo to the output directory.
 
-PROJECT_LOGO           = 
+PROJECT_LOGO           =
 
 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
 # into which the generated documentation will be written. If a relative path is
@@ -60,16 +70,28 @@ PROJECT_LOGO           =
 
 OUTPUT_DIRECTORY       = Docs
 
-# If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub-
-# directories (in 2 levels) under the output directory of each output format and
-# will distribute the generated files over these directories. Enabling this
+# If the CREATE_SUBDIRS tag is set to YES then doxygen will create up to 4096
+# sub-directories (in 2 levels) under the output directory of each output format
+# and will distribute the generated files over these directories. Enabling this
 # option can be useful when feeding doxygen a huge amount of source files, where
 # putting all generated files in the same directory would otherwise causes
-# performance problems for the file system.
+# performance problems for the file system. Adapt CREATE_SUBDIRS_LEVEL to
+# control the number of sub-directories.
 # The default value is: NO.
 
 CREATE_SUBDIRS         = NO
 
+# Controls the number of sub-directories that will be created when
+# CREATE_SUBDIRS tag is set to YES. Level 0 represents 16 directories, and every
+# level increment doubles the number of directories, resulting in 4096
+# directories at level 8 which is the default and also the maximum value. The
+# sub-directories are organized in 2 levels, the first level always has a fixed
+# numer of 16 directories.
+# Minimum value: 0, maximum value: 8, default value: 8.
+# This tag requires that the tag CREATE_SUBDIRS is set to YES.
+
+CREATE_SUBDIRS_LEVEL   = 8
+
 # If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII
 # characters to appear in the names of generated files. If set to NO, non-ASCII
 # characters will be escaped, for example _xE3_x81_x84 will be used for Unicode
@@ -81,14 +103,14 @@ ALLOW_UNICODE_NAMES    = NO
 # The OUTPUT_LANGUAGE tag is used to specify the language in which all
 # documentation generated by doxygen is written. Doxygen will use this
 # information to generate all constant output in the proper language.
-# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese,
-# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States),
-# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian,
-# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages),
-# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian,
-# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian,
-# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish,
-# Ukrainian and Vietnamese.
+# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Bulgarian,
+# Catalan, Chinese, Chinese-Traditional, Croatian, Czech, Danish, Dutch, English
+# (United States), Esperanto, Farsi (Persian), Finnish, French, German, Greek,
+# Hindi, Hungarian, Indonesian, Italian, Japanese, Japanese-en (Japanese with
+# English messages), Korean, Korean-en (Korean with English messages), Latvian,
+# Lithuanian, Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese,
+# Romanian, Russian, Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish,
+# Swedish, Turkish, Ukrainian and Vietnamese.
 # The default value is: English.
 
 OUTPUT_LANGUAGE        = English
@@ -162,7 +184,7 @@ FULL_PATH_NAMES        = NO
 # will be relative from the directory where doxygen is started.
 # This tag requires that the tag FULL_PATH_NAMES is set to YES.
 
-STRIP_FROM_PATH        = 
+STRIP_FROM_PATH        =
 
 # The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the
 # path mentioned in the documentation of a class, which tells the reader which
@@ -171,7 +193,7 @@ STRIP_FROM_PATH        =
 # specify the list of include paths that are normally passed to the compiler
 # using the -I flag.
 
-STRIP_FROM_INC_PATH    = 
+STRIP_FROM_INC_PATH    =
 
 # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but
 # less readable) file names. This can be useful is your file systems doesn't
@@ -189,6 +211,16 @@ SHORT_NAMES            = NO
 
 JAVADOC_AUTOBRIEF      = YES
 
+# If the JAVADOC_BANNER tag is set to YES then doxygen will interpret a line
+# such as
+# /***************
+# as being the beginning of a Javadoc-style comment "banner". If set to NO, the
+# Javadoc-style will behave just like regular comments and it will not be
+# interpreted by doxygen.
+# The default value is: NO.
+
+JAVADOC_BANNER         = NO
+
 # If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
 # line (until the first dot) of a Qt-style comment as the brief description. If
 # set to NO, the Qt-style will behave just like regular Qt-style comments (thus
@@ -209,6 +241,14 @@ QT_AUTOBRIEF           = NO
 
 MULTILINE_CPP_IS_BRIEF = NO
 
+# By default Python docstrings are displayed as preformatted text and doxygen's
+# special commands cannot be used. By setting PYTHON_DOCSTRING to NO the
+# doxygen's special commands can be used and the contents of the docstring
+# documentation blocks is shown as doxygen documentation.
+# The default value is: YES.
+
+PYTHON_DOCSTRING       = YES
+
 # If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
 # documentation from any documented member that it re-implements.
 # The default value is: YES.
@@ -232,19 +272,18 @@ TAB_SIZE               = 4
 # the documentation. An alias has the form:
 # name=value
 # For example adding
-# "sideeffect=@par Side Effects:\n"
+# "sideeffect=@par Side Effects:^^"
 # will allow you to put the command \sideeffect (or @sideeffect) in the
 # documentation, which will result in a user-defined paragraph with heading
-# "Side Effects:". You can put \n's in the value part of an alias to insert
-# newlines.
+# "Side Effects:". Note that you cannot put \n's in the value part of an alias
+# to insert newlines (in the resulting output). You can put ^^ in the value part
+# of an alias to insert a newline as if a physical newline was in the original
+# file. When you need a literal { or } or , in the value part of an alias you
+# have to escape them by means of a backslash (\), this can lead to conflicts
+# with the commands \{ and \} for these it is advised to use the version @{ and
+# @} or use a double escape (\\{ and \\})
 
-ALIASES                = 
-
-# This tag can be used to specify a number of word-keyword mappings (TCL only).
-# A mapping has the form "name=value". For example adding "class=itcl::class"
-# will allow you to use the command class in the itcl::class meaning.
-
-TCL_SUBST              = 
+ALIASES                =
 
 # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
 # only. Doxygen will then generate output that is more tailored for C. For
@@ -274,28 +313,40 @@ OPTIMIZE_FOR_FORTRAN   = NO
 
 OPTIMIZE_OUTPUT_VHDL   = NO
 
+# Set the OPTIMIZE_OUTPUT_SLICE tag to YES if your project consists of Slice
+# sources only. Doxygen will then generate output that is more tailored for that
+# language. For instance, namespaces will be presented as modules, types will be
+# separated into more groups, etc.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_SLICE  = NO
+
 # Doxygen selects the parser to use depending on the extension of the files it
 # parses. With this tag you can assign which parser to use for a given
 # extension. Doxygen has a built-in mapping, but you can override or extend it
 # using this tag. The format is ext=language, where ext is a file extension, and
-# language is one of the parsers supported by doxygen: IDL, Java, Javascript,
-# C#, C, C++, D, PHP, Objective-C, Python, Fortran (fixed format Fortran:
-# FortranFixed, free formatted Fortran: FortranFree, unknown formatted Fortran:
-# Fortran. In the later case the parser tries to guess whether the code is fixed
-# or free formatted code, this is the default for Fortran type files), VHDL. For
-# instance to make doxygen treat .inc files as Fortran files (default is PHP),
-# and .f files as C (default is Fortran), use: inc=Fortran f=C.
+# language is one of the parsers supported by doxygen: IDL, Java, JavaScript,
+# Csharp (C#), C, C++, Lex, D, PHP, md (Markdown), Objective-C, Python, Slice,
+# VHDL, Fortran (fixed format Fortran: FortranFixed, free formatted Fortran:
+# FortranFree, unknown formatted Fortran: Fortran. In the later case the parser
+# tries to guess whether the code is fixed or free formatted code, this is the
+# default for Fortran type files). For instance to make doxygen treat .inc files
+# as Fortran files (default is PHP), and .f files as C (default is Fortran),
+# use: inc=Fortran f=C.
 #
 # Note: For files without extension you can use no_extension as a placeholder.
 #
 # Note that for custom extensions you also need to set FILE_PATTERNS otherwise
-# the files are not read by doxygen.
+# the files are not read by doxygen. When specifying no_extension you should add
+# * to the FILE_PATTERNS.
+#
+# Note see also the list of default file extension mappings.
 
-EXTENSION_MAPPING      = 
+EXTENSION_MAPPING      =
 
 # If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
 # according to the Markdown format, which allows for more readable
-# documentation. See http://daringfireball.net/projects/markdown/ for details.
+# documentation. See https://daringfireball.net/projects/markdown/ for details.
 # The output of markdown processing is further processed by doxygen, so you can
 # mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
 # case of backward compatibilities issues.
@@ -303,6 +354,15 @@ EXTENSION_MAPPING      =
 
 MARKDOWN_SUPPORT       = YES
 
+# When the TOC_INCLUDE_HEADINGS tag is set to a non-zero value, all headings up
+# to that level are automatically included in the table of contents, even if
+# they do not have an id attribute.
+# Note: This feature currently applies only to Markdown headings.
+# Minimum value: 0, maximum value: 99, default value: 5.
+# This tag requires that the tag MARKDOWN_SUPPORT is set to YES.
+
+TOC_INCLUDE_HEADINGS   = 5
+
 # When enabled doxygen tries to link words that correspond to documented
 # classes, or namespaces to their corresponding documentation. Such a link can
 # be prevented in individual cases by putting a % sign in front of the word or
@@ -328,7 +388,7 @@ BUILTIN_STL_SUPPORT    = NO
 CPP_CLI_SUPPORT        = NO
 
 # Set the SIP_SUPPORT tag to YES if your project consists of sip (see:
-# http://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen
+# https://www.riverbankcomputing.com/software/sip/intro) sources only. Doxygen
 # will parse them like normal C++ but will assume all classes use public instead
 # of private inheritance when no explicit protection keyword is present.
 # The default value is: NO.
@@ -414,6 +474,19 @@ TYPEDEF_HIDES_STRUCT   = NO
 
 LOOKUP_CACHE_SIZE      = 0
 
+# The NUM_PROC_THREADS specifies the number of threads doxygen is allowed to use
+# during processing. When set to 0 doxygen will based this on the number of
+# cores available in the system. You can set it explicitly to a value larger
+# than 0 to get more control over the balance between CPU load and processing
+# speed. At this moment only the input processing can be done using multiple
+# threads. Since this is still an experimental feature the default is set to 1,
+# which effectively disables parallel processing. Please report any issues you
+# encounter. Generating dot graphs in parallel is controlled by the
+# DOT_NUM_THREADS setting.
+# Minimum value: 0, maximum value: 32, default value: 1.
+
+NUM_PROC_THREADS       = 1
+
 #---------------------------------------------------------------------------
 # Build related configuration options
 #---------------------------------------------------------------------------
@@ -434,6 +507,12 @@ EXTRACT_ALL            = YES
 
 EXTRACT_PRIVATE        = NO
 
+# If the EXTRACT_PRIV_VIRTUAL tag is set to YES, documented private virtual
+# methods of a class will be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PRIV_VIRTUAL   = NO
+
 # If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal
 # scope will be included in the documentation.
 # The default value is: NO.
@@ -471,6 +550,13 @@ EXTRACT_LOCAL_METHODS  = NO
 
 EXTRACT_ANON_NSPACES   = NO
 
+# If this flag is set to YES, the name of an unnamed parameter in a declaration
+# will be determined by the corresponding definition. By default unnamed
+# parameters remain unnamed in the output.
+# The default value is: YES.
+
+RESOLVE_UNNAMED_PARAMS = YES
+
 # If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
 # undocumented members inside documented classes or files. If set to NO these
 # members will be included in the various overviews, but no documentation
@@ -488,8 +574,8 @@ HIDE_UNDOC_MEMBERS     = NO
 HIDE_UNDOC_CLASSES     = NO
 
 # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
-# (class|struct|union) declarations. If set to NO, these declarations will be
-# included in the documentation.
+# declarations. If set to NO, these declarations will be included in the
+# documentation.
 # The default value is: NO.
 
 HIDE_FRIEND_COMPOUNDS  = NO
@@ -508,12 +594,20 @@ HIDE_IN_BODY_DOCS      = NO
 
 INTERNAL_DOCS          = NO
 
-# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file
-# names in lower-case letters. If set to YES, upper-case letters are also
-# allowed. This is useful if you have classes or files whose names only differ
-# in case and if your file system supports case sensitive file names. Windows
-# and Mac users are advised to set this option to NO.
-# The default value is: system dependent.
+# With the correct setting of option CASE_SENSE_NAMES doxygen will better be
+# able to match the capabilities of the underlying filesystem. In case the
+# filesystem is case sensitive (i.e. it supports files in the same directory
+# whose names only differ in casing), the option must be set to YES to properly
+# deal with such files in case they appear in the input. For filesystems that
+# are not case sensitive the option should be set to NO to properly deal with
+# output files written for symbols that only differ in casing, such as for two
+# classes, one named CLASS and the other named Class, and to also support
+# references to files without having to specify the exact matching casing. On
+# Windows (including Cygwin) and MacOS, users should typically set this option
+# to NO, whereas on Linux or other Unix flavors it should typically be set to
+# YES.
+# Possible values are: SYSTEM, NO and YES.
+# The default value is: SYSTEM.
 
 CASE_SENSE_NAMES       = YES
 
@@ -531,6 +625,12 @@ HIDE_SCOPE_NAMES       = NO
 
 HIDE_COMPOUND_REFERENCE= NO
 
+# If the SHOW_HEADERFILE tag is set to YES then the documentation for a class
+# will show which file needs to be included to use the class.
+# The default value is: YES.
+
+SHOW_HEADERFILE        = YES
+
 # If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
 # the files that are included by a file in the documentation of that file.
 # The default value is: YES.
@@ -639,7 +739,7 @@ GENERATE_DEPRECATEDLIST= YES
 # sections, marked by \if <section_label> ... \endif and \cond <section_label>
 # ... \endcond blocks.
 
-ENABLED_SECTIONS       = 
+ENABLED_SECTIONS       =
 
 # The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the
 # initial value of a variable or macro / define can have for it to appear in the
@@ -681,14 +781,15 @@ SHOW_NAMESPACES        = YES
 # by doxygen. Whatever the program writes to standard output is used as the file
 # version. For an example see the documentation.
 
-FILE_VERSION_FILTER    = 
+FILE_VERSION_FILTER    =
 
 # The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
 # by doxygen. The layout file controls the global structure of the generated
 # output files in an output format independent way. To create the layout file
 # that represents doxygen's defaults, run doxygen with the -l option. You can
 # optionally specify a file name after the option, if omitted DoxygenLayout.xml
-# will be used as the name of the layout file.
+# will be used as the name of the layout file. See also section "Changing the
+# layout of pages" for information.
 #
 # Note that if you run doxygen from a directory containing a file called
 # DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
@@ -699,12 +800,12 @@ LAYOUT_FILE            = Docs/DoxygenLayout.xml
 # The CITE_BIB_FILES tag can be used to specify one or more bib files containing
 # the reference definitions. This must be a list of .bib files. The .bib
 # extension is automatically appended if omitted. This requires the bibtex tool
-# to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info.
+# to be installed. See also https://en.wikipedia.org/wiki/BibTeX for more info.
 # For LaTeX the style of the bibliography can be controlled using
 # LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
 # search path. See also \cite for info how to create references.
 
-CITE_BIB_FILES         = 
+CITE_BIB_FILES         =
 
 #---------------------------------------------------------------------------
 # Configuration options related to warning and progress messages
@@ -734,36 +835,68 @@ WARNINGS               = YES
 WARN_IF_UNDOCUMENTED   = YES
 
 # If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for
-# potential errors in the documentation, such as not documenting some parameters
-# in a documented function, or documenting parameters that don't exist or using
-# markup commands wrongly.
+# potential errors in the documentation, such as documenting some parameters in
+# a documented function twice, or documenting parameters that don't exist or
+# using markup commands wrongly.
 # The default value is: YES.
 
 WARN_IF_DOC_ERROR      = YES
 
+# If WARN_IF_INCOMPLETE_DOC is set to YES, doxygen will warn about incomplete
+# function parameter documentation. If set to NO, doxygen will accept that some
+# parameters have no documentation without warning.
+# The default value is: YES.
+
+WARN_IF_INCOMPLETE_DOC = YES
+
 # This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
 # are documented, but have no documentation for their parameters or return
-# value. If set to NO, doxygen will only warn about wrong or incomplete
-# parameter documentation, but not about the absence of documentation.
+# value. If set to NO, doxygen will only warn about wrong parameter
+# documentation, but not about the absence of documentation. If EXTRACT_ALL is
+# set to YES then this flag will automatically be disabled. See also
+# WARN_IF_INCOMPLETE_DOC
 # The default value is: NO.
 
 WARN_NO_PARAMDOC       = NO
 
+# If the WARN_AS_ERROR tag is set to YES then doxygen will immediately stop when
+# a warning is encountered. If the WARN_AS_ERROR tag is set to FAIL_ON_WARNINGS
+# then doxygen will continue running as if WARN_AS_ERROR tag is set to NO, but
+# at the end of the doxygen process doxygen will return with a non-zero status.
+# Possible values are: NO, YES and FAIL_ON_WARNINGS.
+# The default value is: NO.
+
+WARN_AS_ERROR          = NO
+
 # The WARN_FORMAT tag determines the format of the warning messages that doxygen
 # can produce. The string should contain the $file, $line, and $text tags, which
 # will be replaced by the file and line number from which the warning originated
 # and the warning text. Optionally the format may contain $version, which will
 # be replaced by the version of the file (if it could be obtained via
 # FILE_VERSION_FILTER)
+# See also: WARN_LINE_FORMAT
 # The default value is: $file:$line: $text.
 
 WARN_FORMAT            = "$file:$line: $text"
 
+# In the $text part of the WARN_FORMAT command it is possible that a reference
+# to a more specific place is given. To make it easier to jump to this place
+# (outside of doxygen) the user can define a custom "cut" / "paste" string.
+# Example:
+# WARN_LINE_FORMAT = "'vi $file +$line'"
+# See also: WARN_FORMAT
+# The default value is: at line $line of file $file.
+
+WARN_LINE_FORMAT       = "at line $line of file $file"
+
 # The WARN_LOGFILE tag can be used to specify a file to which warning and error
 # messages should be written. If left blank the output is written to standard
-# error (stderr).
+# error (stderr). In case the file specified cannot be opened for writing the
+# warning and error messages are written to standard error. When as file - is
+# specified the warning and error messages are written to standard output
+# (stdout).
 
-WARN_LOGFILE           = 
+WARN_LOGFILE           =
 
 #---------------------------------------------------------------------------
 # Configuration options related to the input files
@@ -776,21 +909,33 @@ WARN_LOGFILE           =
 # Note: If this tag is empty the current directory is searched.
 
 INPUT                  = . \
+                         README.md \
+                         CONTRIBUTING.md \
                          DetourCrowd \
                          DetourTileCache \
                          Recast \
-                         Docs/Conceptual \
                          Docs/Extern
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
 # libiconv (or the iconv built into libc) for the transcoding. See the libiconv
-# documentation (see: http://www.gnu.org/software/libiconv) for the list of
-# possible encodings.
+# documentation (see:
+# https://www.gnu.org/software/libiconv/) for the list of possible encodings.
+# See also: INPUT_FILE_ENCODING
 # The default value is: UTF-8.
 
 INPUT_ENCODING         = UTF-8
 
+# This tag can be used to specify the character encoding of the source files
+# that doxygen parses The INPUT_FILE_ENCODING tag can be used to specify
+# character encoding on a per file pattern basis. Doxygen will compare the file
+# name with each pattern and apply the encoding instead of the default
+# INPUT_ENCODING) if there is a match. The character encodings are a list of the
+# form: pattern=encoding (like *.php=ISO-8859-1). See cfg_input_encoding
+# "INPUT_ENCODING" for further information on supported encodings.
+
+INPUT_FILE_ENCODING    =
+
 # If the value of the INPUT tag contains directories, you can use the
 # FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and
 # *.h) to filter out the source-files in the directories.
@@ -799,11 +944,15 @@ INPUT_ENCODING         = UTF-8
 # need to set EXTENSION_MAPPING for the extension otherwise the files are not
 # read by doxygen.
 #
+# Note the list of default checked file patterns might differ from the list of
+# default file extension mappings.
+#
 # If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp,
 # *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h,
-# *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc,
-# *.m, *.markdown, *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd,
-# *.vhdl, *.ucf, *.qsf, *.as and *.js.
+# *.hh, *.hxx, *.hpp, *.h++, *.l, *.cs, *.d, *.php, *.php4, *.php5, *.phtml,
+# *.inc, *.m, *.markdown, *.md, *.mm, *.dox (to be provided as doxygen C
+# comment), *.py, *.pyw, *.f90, *.f95, *.f03, *.f08, *.f18, *.f, *.for, *.vhd,
+# *.vhdl, *.ucf, *.qsf and *.ice.
 
 FILE_PATTERNS          = *.cpp \
                          *.h \
@@ -829,7 +978,8 @@ EXCLUDE                = Doxyfile \
                          TODO.txt \
                          RecastDemo/Contrib \
                          RecastDemo/Build \
-                         RecastDemo/Bin
+                         RecastDemo/Bin \
+                         Tests
 
 # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
 # directories that are symbolic links (a Unix file system feature) are excluded
@@ -851,25 +1001,25 @@ EXCLUDE_PATTERNS       = CMakeLists.txt
 # (namespaces, classes, functions, etc.) that should be excluded from the
 # output. The symbol name can be a fully qualified name, a word, or if the
 # wildcard * is used, a substring. Examples: ANamespace, AClass,
-# AClass::ANamespace, ANamespace::*Test
+# ANamespace::AClass, ANamespace::*Test
 #
 # Note that the wildcards are matched against the file with absolute path, so to
 # exclude all test directories use the pattern */test/*
 
-EXCLUDE_SYMBOLS        = 
+EXCLUDE_SYMBOLS        =
 
 # The EXAMPLE_PATH tag can be used to specify one or more files or directories
 # that contain example code fragments that are included (see the \include
 # command).
 
-EXAMPLE_PATH           = 
+EXAMPLE_PATH           =
 
 # If the value of the EXAMPLE_PATH tag contains directories, you can use the
 # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and
 # *.h) to filter out the source-files in the directories. If left blank all
 # files are included.
 
-EXAMPLE_PATTERNS       = 
+EXAMPLE_PATTERNS       =
 
 # If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
 # searched for input files to be used with the \include or \dontinclude commands
@@ -898,8 +1048,17 @@ IMAGE_PATH             = Docs/Images
 # Note that the filter must not add or remove lines; it is applied before the
 # code is scanned, but not when the output code is generated. If lines are added
 # or removed, the anchors will not be placed correctly.
+#
+# Note that doxygen will use the data processed and written to standard output
+# for further processing, therefore nothing else, like debug statements or used
+# commands (so in case of a Windows batch file always use @echo OFF), should be
+# written to standard output.
+#
+# Note that for custom extensions or not directly supported extensions you also
+# need to set EXTENSION_MAPPING for the extension otherwise the files are not
+# properly processed by doxygen.
 
-INPUT_FILTER           = 
+INPUT_FILTER           =
 
 # The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
 # basis. Doxygen will compare the file name with each pattern and apply the
@@ -907,8 +1066,12 @@ INPUT_FILTER           =
 # (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how
 # filters are used. If the FILTER_PATTERNS tag is empty or if none of the
 # patterns match the file name, INPUT_FILTER is applied.
+#
+# Note that for custom extensions or not directly supported extensions you also
+# need to set EXTENSION_MAPPING for the extension otherwise the files are not
+# properly processed by doxygen.
 
-FILTER_PATTERNS        = 
+FILTER_PATTERNS        =
 
 # If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
 # INPUT_FILTER) will also be used to filter the input files that are used for
@@ -923,14 +1086,23 @@ FILTER_SOURCE_FILES    = NO
 # *.ext= (so without naming a filter).
 # This tag requires that the tag FILTER_SOURCE_FILES is set to YES.
 
-FILTER_SOURCE_PATTERNS = 
+FILTER_SOURCE_PATTERNS =
 
 # If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that
 # is part of the input, its contents will be placed on the main page
 # (index.html). This can be useful if you have a project on for instance GitHub
 # and want to reuse the introduction page also for the doxygen output.
 
-USE_MDFILE_AS_MAINPAGE = 
+USE_MDFILE_AS_MAINPAGE = ./README.md
+
+# The Fortran standard specifies that for fixed formatted Fortran code all
+# characters from position 72 are to be considered as comment. A common
+# extension is to allow longer lines before the automatic comment starts. The
+# setting FORTRAN_COMMENT_AFTER will also make it possible that longer lines can
+# be processed before the automatic comment starts.
+# Minimum value: 7, maximum value: 10000, default value: 72.
+
+FORTRAN_COMMENT_AFTER  = 72
 
 #---------------------------------------------------------------------------
 # Configuration options related to source browsing
@@ -959,7 +1131,7 @@ INLINE_SOURCES         = NO
 STRIP_CODE_COMMENTS    = YES
 
 # If the REFERENCED_BY_RELATION tag is set to YES then for each documented
-# function all documented functions referencing it will be listed.
+# entity all documented functions referencing it will be listed.
 # The default value is: NO.
 
 REFERENCED_BY_RELATION = NO
@@ -991,12 +1163,12 @@ SOURCE_TOOLTIPS        = YES
 # If the USE_HTAGS tag is set to YES then the references to source code will
 # point to the HTML generated by the htags(1) tool instead of doxygen built-in
 # source browser. The htags tool is part of GNU's global source tagging system
-# (see http://www.gnu.org/software/global/global.html). You will need version
+# (see https://www.gnu.org/software/global/global.html). You will need version
 # 4.8.6 or higher.
 #
 # To use it do the following:
 # - Install the latest version of global
-# - Enable SOURCE_BROWSER and USE_HTAGS in the config file
+# - Enable SOURCE_BROWSER and USE_HTAGS in the configuration file
 # - Make sure the INPUT points to the root of the source tree
 # - Run doxygen as normal
 #
@@ -1018,25 +1190,6 @@ USE_HTAGS              = NO
 
 VERBATIM_HEADERS       = YES
 
-# If the CLANG_ASSISTED_PARSING tag is set to YES then doxygen will use the
-# clang parser (see: http://clang.llvm.org/) for more accurate parsing at the
-# cost of reduced performance. This can be particularly helpful with template
-# rich C++ code for which doxygen's built-in parser lacks the necessary type
-# information.
-# Note: The availability of this option depends on whether or not doxygen was
-# compiled with the --with-libclang option.
-# The default value is: NO.
-
-CLANG_ASSISTED_PARSING = NO
-
-# If clang assisted parsing is enabled you can provide the compiler with command
-# line options that you would normally use when invoking the compiler. Note that
-# the include paths will already be set by doxygen for the files and directories
-# specified with INPUT and INCLUDE_PATH.
-# This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES.
-
-CLANG_OPTIONS          = 
-
 #---------------------------------------------------------------------------
 # Configuration options related to the alphabetical class index
 #---------------------------------------------------------------------------
@@ -1048,20 +1201,13 @@ CLANG_OPTIONS          =
 
 ALPHABETICAL_INDEX     = YES
 
-# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in
-# which the alphabetical index list will be split.
-# Minimum value: 1, maximum value: 20, default value: 5.
-# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
-
-COLS_IN_ALPHA_INDEX    = 5
-
 # In case all classes in a project start with a common prefix, all classes will
 # be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
 # can be used to specify a prefix (or a list of prefixes) that should be ignored
 # while generating the index headers.
 # This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
 
-IGNORE_PREFIX          = 
+IGNORE_PREFIX          =
 
 #---------------------------------------------------------------------------
 # Configuration options related to the HTML output
@@ -1105,7 +1251,7 @@ HTML_FILE_EXTENSION    = .html
 # of the possible markers and block names see the documentation.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-HTML_HEADER            = 
+HTML_HEADER            =
 
 # The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each
 # generated HTML page. If the tag is left blank doxygen will generate a standard
@@ -1127,7 +1273,7 @@ HTML_FOOTER            = Docs/footer.html
 # obsolete.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-HTML_STYLESHEET        = 
+HTML_STYLESHEET        =
 
 # The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined
 # cascading style sheets that are included after the standard style sheets
@@ -1140,7 +1286,8 @@ HTML_STYLESHEET        =
 # list). For an example see the documentation.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-HTML_EXTRA_STYLESHEET  = 
+HTML_EXTRA_STYLESHEET  = Docs/doxygen-awesome-css/doxygen-awesome.css \
+                         Docs/doxygen-awesome-css/doxygen-awesome-sidebar-only.css
 
 # The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
 # other source files which should be copied to the HTML output directory. Note
@@ -1150,12 +1297,29 @@ HTML_EXTRA_STYLESHEET  =
 # files will be copied as-is; there are no commands or markers available.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-HTML_EXTRA_FILES       = 
+HTML_EXTRA_FILES       = License.txt
+
+# The HTML_COLORSTYLE tag can be used to specify if the generated HTML output
+# should be rendered with a dark or light theme. Default setting AUTO_LIGHT
+# enables light output unless the user preference is dark output. Other options
+# are DARK to always use dark mode, LIGHT to always use light mode, AUTO_DARK to
+# default to dark mode unless the user prefers light mode, and TOGGLE to let the
+# user toggle between dark and light mode via a button.
+# Possible values are: LIGHT Always generate light output., DARK Always generate
+# dark output., AUTO_LIGHT Automatically set the mode according to the user
+# preference, use light mode if no preference is set (the default)., AUTO_DARK
+# Automatically set the mode according to the user preference, use dark mode if
+# no preference is set. and TOGGLE Allow to user to switch between light and
+# dark mode via a button..
+# The default value is: AUTO_LIGHT.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE        = AUTO_LIGHT
 
 # The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
 # will adjust the colors in the style sheet and background images according to
-# this color. Hue is specified as an angle on a colorwheel, see
-# http://en.wikipedia.org/wiki/Hue for more information. For instance the value
+# this color. Hue is specified as an angle on a color-wheel, see
+# https://en.wikipedia.org/wiki/Hue for more information. For instance the value
 # 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
 # purple, and 360 is red again.
 # Minimum value: 0, maximum value: 359, default value: 220.
@@ -1164,7 +1328,7 @@ HTML_EXTRA_FILES       =
 HTML_COLORSTYLE_HUE    = 220
 
 # The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
-# in the HTML output. For a value of 0 the output will use grayscales only. A
+# in the HTML output. For a value of 0 the output will use gray-scales only. A
 # value of 255 will produce the most vivid colors.
 # Minimum value: 0, maximum value: 255, default value: 100.
 # This tag requires that the tag GENERATE_HTML is set to YES.
@@ -1191,6 +1355,17 @@ HTML_COLORSTYLE_GAMMA  = 80
 
 HTML_TIMESTAMP         = YES
 
+# If the HTML_DYNAMIC_MENUS tag is set to YES then the generated HTML
+# documentation will contain a main index with vertical navigation menus that
+# are dynamically created via JavaScript. If disabled, the navigation index will
+# consists of multiple levels of tabs that are statically embedded in every HTML
+# page. Disable this option to support browsers that do not have JavaScript,
+# like the Qt help browser.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_DYNAMIC_MENUS     = YES
+
 # If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
 # documentation will contain sections that can be hidden and shown after the
 # page has loaded.
@@ -1214,13 +1389,14 @@ HTML_INDEX_NUM_ENTRIES = 100
 
 # If the GENERATE_DOCSET tag is set to YES, additional index files will be
 # generated that can be used as input for Apple's Xcode 3 integrated development
-# environment (see: http://developer.apple.com/tools/xcode/), introduced with
-# OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a
-# Makefile in the HTML output directory. Running make will produce the docset in
-# that directory and running make install will install the docset in
+# environment (see:
+# https://developer.apple.com/xcode/), introduced with OSX 10.5 (Leopard). To
+# create a documentation set, doxygen will generate a Makefile in the HTML
+# output directory. Running make will produce the docset in that directory and
+# running make install will install the docset in
 # ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
-# startup. See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
-# for more information.
+# startup. See https://developer.apple.com/library/archive/featuredarticles/Doxy
+# genXcode/_index.html for more information.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
@@ -1234,6 +1410,13 @@ GENERATE_DOCSET        = NO
 
 DOCSET_FEEDNAME        = "Doxygen generated docs"
 
+# This tag determines the URL of the docset feed. A documentation feed provides
+# an umbrella under which multiple documentation sets from a single provider
+# (such as a company or product suite) can be grouped.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_FEEDURL         =
+
 # This tag specifies a string that should uniquely identify the documentation
 # set bundle. This should be a reverse domain-name style string, e.g.
 # com.mycompany.MyDocSet. Doxygen will append .docset to the name.
@@ -1259,8 +1442,12 @@ DOCSET_PUBLISHER_NAME  = Publisher
 # If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
 # additional HTML index files: index.hhp, index.hhc, and index.hhk. The
 # index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
-# (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on
-# Windows.
+# on Windows. In the beginning of 2021 Microsoft took the original page, with
+# a.o. the download links, offline the HTML help workshop was already many years
+# in maintenance mode). You can download the HTML help workshop from the web
+# archives at Installation executable (see:
+# http://web.archive.org/web/20160201063255/http://download.microsoft.com/downlo
+# ad/0/A/9/0A939EF6-E31C-430F-A3DF-DFAE7960D564/htmlhelp.exe).
 #
 # The HTML Help Workshop contains a compiler that can convert all HTML output
 # generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
@@ -1279,7 +1466,7 @@ GENERATE_HTMLHELP      = NO
 # written to the html output directory.
 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.
 
-CHM_FILE               = 
+CHM_FILE               =
 
 # The HHC_LOCATION tag can be used to specify the location (absolute path
 # including file name) of the HTML help compiler (hhc.exe). If non-empty,
@@ -1287,10 +1474,10 @@ CHM_FILE               =
 # The file has to be specified with full path.
 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.
 
-HHC_LOCATION           = 
+HHC_LOCATION           =
 
 # The GENERATE_CHI flag controls if a separate .chi index file is generated
-# (YES) or that it should be included in the master .chm file (NO).
+# (YES) or that it should be included in the main .chm file (NO).
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.
 
@@ -1300,7 +1487,7 @@ GENERATE_CHI           = NO
 # and project file content.
 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.
 
-CHM_INDEX_ENCODING     = 
+CHM_INDEX_ENCODING     =
 
 # The BINARY_TOC flag controls whether a binary table of contents is generated
 # (YES) or a normal table of contents (NO) in the .chm file. Furthermore it
@@ -1331,11 +1518,12 @@ GENERATE_QHP           = NO
 # the HTML output folder.
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
-QCH_FILE               = 
+QCH_FILE               =
 
 # The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
 # Project output. For more information please see Qt Help Project / Namespace
-# (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace).
+# (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#namespace).
 # The default value is: org.doxygen.Project.
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
@@ -1343,8 +1531,8 @@ QHP_NAMESPACE          = org.doxygen.Project
 
 # The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
 # Help Project output. For more information please see Qt Help Project / Virtual
-# Folders (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual-
-# folders).
+# Folders (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#virtual-folders).
 # The default value is: doc.
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
@@ -1352,33 +1540,33 @@ QHP_VIRTUAL_FOLDER     = doc
 
 # If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
 # filter to add. For more information please see Qt Help Project / Custom
-# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
-# filters).
+# Filters (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-filters).
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
-QHP_CUST_FILTER_NAME   = 
+QHP_CUST_FILTER_NAME   =
 
 # The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
 # custom filter to add. For more information please see Qt Help Project / Custom
-# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
-# filters).
+# Filters (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-filters).
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
-QHP_CUST_FILTER_ATTRS  = 
+QHP_CUST_FILTER_ATTRS  =
 
 # The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
 # project's filter section matches. Qt Help Project / Filter Attributes (see:
-# http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes).
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#filter-attributes).
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
-QHP_SECT_FILTER_ATTRS  = 
+QHP_SECT_FILTER_ATTRS  =
 
-# The QHG_LOCATION tag can be used to specify the location of Qt's
-# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the
-# generated .qhp file.
+# The QHG_LOCATION tag can be used to specify the location (absolute path
+# including file name) of Qt's qhelpgenerator. If non-empty doxygen will try to
+# run qhelpgenerator on the generated .qhp file.
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
-QHG_LOCATION           = 
+QHG_LOCATION           =
 
 # If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be
 # generated, together with the HTML files, they form an Eclipse help plugin. To
@@ -1418,16 +1606,28 @@ DISABLE_INDEX          = NO
 # to work a browser that supports JavaScript, DHTML, CSS and frames is required
 # (i.e. any modern browser). Windows users are probably better off using the
 # HTML help feature. Via custom style sheets (see HTML_EXTRA_STYLESHEET) one can
-# further fine-tune the look of the index. As an example, the default style
-# sheet generated by doxygen has an example that shows how to put an image at
-# the root of the tree instead of the PROJECT_NAME. Since the tree basically has
-# the same information as the tab index, you could consider setting
-# DISABLE_INDEX to YES when enabling this option.
+# further fine tune the look of the index (see "Fine-tuning the output"). As an
+# example, the default style sheet generated by doxygen has an example that
+# shows how to put an image at the root of the tree instead of the PROJECT_NAME.
+# Since the tree basically has the same information as the tab index, you could
+# consider setting DISABLE_INDEX to YES when enabling this option.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 GENERATE_TREEVIEW      = YES
 
+# When both GENERATE_TREEVIEW and DISABLE_INDEX are set to YES, then the
+# FULL_SIDEBAR option determines if the side bar is limited to only the treeview
+# area (value NO) or if it should extend to the full height of the window (value
+# YES). Setting this to YES gives a layout similar to
+# https://docs.readthedocs.io with more room for contents, but less room for the
+# project logo, title, and description. If either GENERATE_TREEVIEW or
+# DISABLE_INDEX is set to NO, this option has no effect.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+FULL_SIDEBAR           = NO
+
 # The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
 # doxygen will group on one line in the generated HTML documentation.
 #
@@ -1452,6 +1652,24 @@ TREEVIEW_WIDTH         = 250
 
 EXT_LINKS_IN_WINDOW    = NO
 
+# If the OBFUSCATE_EMAILS tag is set to YES, doxygen will obfuscate email
+# addresses.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+OBFUSCATE_EMAILS       = YES
+
+# If the HTML_FORMULA_FORMAT option is set to svg, doxygen will use the pdf2svg
+# tool (see https://github.com/dawbarton/pdf2svg) or inkscape (see
+# https://inkscape.org) to generate formulas as SVG images instead of PNGs for
+# the HTML output. These images will generally look nicer at scaled resolutions.
+# Possible values are: png (the default) and svg (looks nicer but requires the
+# pdf2svg or inkscape tool).
+# The default value is: png.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_FORMULA_FORMAT    = png
+
 # Use this tag to change the font size of LaTeX formulas included as images in
 # the HTML documentation. When you change the font size after a successful
 # doxygen run you need to manually remove any form_*.png images from the HTML
@@ -1461,19 +1679,14 @@ EXT_LINKS_IN_WINDOW    = NO
 
 FORMULA_FONTSIZE       = 10
 
-# Use the FORMULA_TRANPARENT tag to determine whether or not the images
-# generated for formulas are transparent PNGs. Transparent PNGs are not
-# supported properly for IE 6.0, but are supported on all modern browsers.
-#
-# Note that when changing this option you need to delete any form_*.png files in
-# the HTML output directory before the changes have effect.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_HTML is set to YES.
+# The FORMULA_MACROFILE can contain LaTeX \newcommand and \renewcommand commands
+# to create new LaTeX commands to be used in formulas as building blocks. See
+# the section "Including formulas" for details.
 
-FORMULA_TRANSPARENT    = YES
+FORMULA_MACROFILE      =
 
 # Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
-# http://www.mathjax.org) which uses client side Javascript for the rendering
+# https://www.mathjax.org) which uses client side JavaScript for the rendering
 # instead of using pre-rendered bitmaps. Use this if you do not have LaTeX
 # installed or if you want to formulas look prettier in the HTML output. When
 # enabled you may also need to install MathJax separately and configure the path
@@ -1483,11 +1696,29 @@ FORMULA_TRANSPARENT    = YES
 
 USE_MATHJAX            = NO
 
+# With MATHJAX_VERSION it is possible to specify the MathJax version to be used.
+# Note that the different versions of MathJax have different requirements with
+# regards to the different settings, so it is possible that also other MathJax
+# settings have to be changed when switching between the different MathJax
+# versions.
+# Possible values are: MathJax_2 and MathJax_3.
+# The default value is: MathJax_2.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_VERSION        = MathJax_2
+
 # When MathJax is enabled you can set the default output format to be used for
-# the MathJax output. See the MathJax site (see:
-# http://docs.mathjax.org/en/latest/output.html) for more details.
+# the MathJax output. For more details about the output format see MathJax
+# version 2 (see:
+# http://docs.mathjax.org/en/v2.7-latest/output.html) and MathJax version 3
+# (see:
+# http://docs.mathjax.org/en/latest/web/components/output.html).
 # Possible values are: HTML-CSS (which is slower, but has the best
-# compatibility), NativeMML (i.e. MathML) and SVG.
+# compatibility. This is the name for Mathjax version 2, for MathJax version 3
+# this will be translated into chtml), NativeMML (i.e. MathML. Only supported
+# for NathJax 2. For MathJax version 3 chtml will be used instead.), chtml (This
+# is the name for Mathjax version 3, for MathJax version 2 this will be
+# translated into HTML-CSS) and SVG.
 # The default value is: HTML-CSS.
 # This tag requires that the tag USE_MATHJAX is set to YES.
 
@@ -1500,26 +1731,33 @@ MATHJAX_FORMAT         = HTML-CSS
 # MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax
 # Content Delivery Network so you can quickly see the result without installing
 # MathJax. However, it is strongly recommended to install a local copy of
-# MathJax from http://www.mathjax.org before deployment.
-# The default value is: http://cdn.mathjax.org/mathjax/latest.
+# MathJax from https://www.mathjax.org before deployment. The default value is:
+# - in case of MathJax version 2: https://cdn.jsdelivr.net/npm/mathjax@2
+# - in case of MathJax version 3: https://cdn.jsdelivr.net/npm/mathjax@3
 # This tag requires that the tag USE_MATHJAX is set to YES.
 
 MATHJAX_RELPATH        = http://www.mathjax.org/mathjax
 
 # The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
 # extension names that should be enabled during MathJax rendering. For example
+# for MathJax version 2 (see
+# https://docs.mathjax.org/en/v2.7-latest/tex.html#tex-and-latex-extensions):
 # MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
+# For example for MathJax version 3 (see
+# http://docs.mathjax.org/en/latest/input/tex/extensions/index.html):
+# MATHJAX_EXTENSIONS = ams
 # This tag requires that the tag USE_MATHJAX is set to YES.
 
-MATHJAX_EXTENSIONS     = 
+MATHJAX_EXTENSIONS     =
 
 # The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
 # of code that will be used on startup of the MathJax code. See the MathJax site
-# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an
+# (see:
+# http://docs.mathjax.org/en/v2.7-latest/output.html) for more details. For an
 # example see the documentation.
 # This tag requires that the tag USE_MATHJAX is set to YES.
 
-MATHJAX_CODEFILE       = 
+MATHJAX_CODEFILE       =
 
 # When the SEARCHENGINE tag is enabled doxygen will generate a search box for
 # the HTML output. The underlying search engine uses javascript and DHTML and
@@ -1543,7 +1781,7 @@ MATHJAX_CODEFILE       =
 SEARCHENGINE           = YES
 
 # When the SERVER_BASED_SEARCH tag is enabled the search engine will be
-# implemented using a web server instead of a web client using Javascript. There
+# implemented using a web server instead of a web client using JavaScript. There
 # are two flavors of web server based searching depending on the EXTERNAL_SEARCH
 # setting. When disabled, doxygen will generate a PHP script for searching and
 # an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing
@@ -1562,7 +1800,8 @@ SERVER_BASED_SEARCH    = NO
 #
 # Doxygen ships with an example indexer (doxyindexer) and search engine
 # (doxysearch.cgi) which are based on the open source search engine library
-# Xapian (see: http://xapian.org/).
+# Xapian (see:
+# https://xapian.org/).
 #
 # See the section "External Indexing and Searching" for details.
 # The default value is: NO.
@@ -1575,11 +1814,12 @@ EXTERNAL_SEARCH        = NO
 #
 # Doxygen ships with an example indexer (doxyindexer) and search engine
 # (doxysearch.cgi) which are based on the open source search engine library
-# Xapian (see: http://xapian.org/). See the section "External Indexing and
-# Searching" for details.
+# Xapian (see:
+# https://xapian.org/). See the section "External Indexing and Searching" for
+# details.
 # This tag requires that the tag SEARCHENGINE is set to YES.
 
-SEARCHENGINE_URL       = 
+SEARCHENGINE_URL       =
 
 # When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
 # search data is written to a file for indexing by an external tool. With the
@@ -1595,7 +1835,7 @@ SEARCHDATA_FILE        = searchdata.xml
 # projects and redirect the results back to the right project.
 # This tag requires that the tag SEARCHENGINE is set to YES.
 
-EXTERNAL_SEARCH_ID     = 
+EXTERNAL_SEARCH_ID     =
 
 # The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
 # projects other than the one defined by this configuration file, but that are
@@ -1605,7 +1845,7 @@ EXTERNAL_SEARCH_ID     =
 # EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ...
 # This tag requires that the tag SEARCHENGINE is set to YES.
 
-EXTRA_SEARCH_MAPPINGS  = 
+EXTRA_SEARCH_MAPPINGS  =
 
 #---------------------------------------------------------------------------
 # Configuration options related to the LaTeX output
@@ -1627,21 +1867,35 @@ LATEX_OUTPUT           = latex
 # The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
 # invoked.
 #
-# Note that when enabling USE_PDFLATEX this option is only used for generating
-# bitmaps for formulas in the HTML output, but not in the Makefile that is
-# written to the output directory.
-# The default file is: latex.
+# Note that when not enabling USE_PDFLATEX the default is latex when enabling
+# USE_PDFLATEX the default is pdflatex and when in the later case latex is
+# chosen this is overwritten by pdflatex. For specific output languages the
+# default can have been set differently, this depends on the implementation of
+# the output language.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
 LATEX_CMD_NAME         = latex
 
 # The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
 # index for LaTeX.
+# Note: This tag is used in the Makefile / make.bat.
+# See also: LATEX_MAKEINDEX_CMD for the part in the generated output file
+# (.tex).
 # The default file is: makeindex.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
 MAKEINDEX_CMD_NAME     = makeindex
 
+# The LATEX_MAKEINDEX_CMD tag can be used to specify the command name to
+# generate index for LaTeX. In case there is no backslash (\) as first character
+# it will be automatically added in the LaTeX code.
+# Note: This tag is used in the generated output file (.tex).
+# See also: MAKEINDEX_CMD_NAME for the part in the Makefile / make.bat.
+# The default value is: makeindex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_MAKEINDEX_CMD    = makeindex
+
 # If the COMPACT_LATEX tag is set to YES, doxygen generates more compact LaTeX
 # documents. This may be useful for small projects and may help to save some
 # trees in general.
@@ -1657,7 +1911,7 @@ COMPACT_LATEX          = NO
 # The default value is: a4.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
-PAPER_TYPE             = a4wide
+PAPER_TYPE             = a4
 
 # The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
 # that should be included in the LaTeX output. The package can be specified just
@@ -1669,34 +1923,36 @@ PAPER_TYPE             = a4wide
 # If left blank no extra packages will be included.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
-EXTRA_PACKAGES         = 
+EXTRA_PACKAGES         =
 
-# The LATEX_HEADER tag can be used to specify a personal LaTeX header for the
-# generated LaTeX document. The header should contain everything until the first
-# chapter. If it is left blank doxygen will generate a standard header. See
-# section "Doxygen usage" for information on how to let doxygen write the
-# default header to a separate file.
+# The LATEX_HEADER tag can be used to specify a user-defined LaTeX header for
+# the generated LaTeX document. The header should contain everything until the
+# first chapter. If it is left blank doxygen will generate a standard header. It
+# is highly recommended to start with a default header using
+# doxygen -w latex new_header.tex new_footer.tex new_stylesheet.sty
+# and then modify the file new_header.tex. See also section "Doxygen usage" for
+# information on how to generate the default header that doxygen normally uses.
 #
-# Note: Only use a user-defined header if you know what you are doing! The
-# following commands have a special meaning inside the header: $title,
-# $datetime, $date, $doxygenversion, $projectname, $projectnumber,
-# $projectbrief, $projectlogo. Doxygen will replace $title with the empty
-# string, for the replacement values of the other commands the user is referred
-# to HTML_HEADER.
+# Note: Only use a user-defined header if you know what you are doing!
+# Note: The header is subject to change so you typically have to regenerate the
+# default header when upgrading to a newer version of doxygen. The following
+# commands have a special meaning inside the header (and footer): For a
+# description of the possible markers and block names see the documentation.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
-LATEX_HEADER           = 
+LATEX_HEADER           =
 
-# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the
-# generated LaTeX document. The footer should contain everything after the last
-# chapter. If it is left blank doxygen will generate a standard footer. See
+# The LATEX_FOOTER tag can be used to specify a user-defined LaTeX footer for
+# the generated LaTeX document. The footer should contain everything after the
+# last chapter. If it is left blank doxygen will generate a standard footer. See
 # LATEX_HEADER for more information on how to generate a default footer and what
-# special commands can be used inside the footer.
-#
-# Note: Only use a user-defined footer if you know what you are doing!
+# special commands can be used inside the footer. See also section "Doxygen
+# usage" for information on how to generate the default footer that doxygen
+# normally uses. Note: Only use a user-defined footer if you know what you are
+# doing!
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
-LATEX_FOOTER           = 
+LATEX_FOOTER           =
 
 # The LATEX_EXTRA_STYLESHEET tag can be used to specify additional user-defined
 # LaTeX style sheets that are included after the standard style sheets created
@@ -1707,7 +1963,7 @@ LATEX_FOOTER           =
 # list).
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
-LATEX_EXTRA_STYLESHEET = 
+LATEX_EXTRA_STYLESHEET =
 
 # The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or
 # other source files which should be copied to the LATEX_OUTPUT output
@@ -1715,7 +1971,7 @@ LATEX_EXTRA_STYLESHEET =
 # markers available.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
-LATEX_EXTRA_FILES      = 
+LATEX_EXTRA_FILES      =
 
 # If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is
 # prepared for conversion to PDF (using ps2pdf or pdflatex). The PDF file will
@@ -1726,9 +1982,11 @@ LATEX_EXTRA_FILES      =
 
 PDF_HYPERLINKS         = NO
 
-# If the USE_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
-# the PDF file directly from the LaTeX files. Set this option to YES, to get a
-# higher quality PDF documentation.
+# If the USE_PDFLATEX tag is set to YES, doxygen will use the engine as
+# specified with LATEX_CMD_NAME to generate the PDF file directly from the LaTeX
+# files. Set this option to YES, to get a higher quality PDF documentation.
+#
+# See also section LATEX_CMD_NAME for selecting the engine.
 # The default value is: YES.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
@@ -1736,8 +1994,7 @@ USE_PDFLATEX           = NO
 
 # If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode
 # command to the generated LaTeX files. This will instruct LaTeX to keep running
-# if errors occur, instead of asking the user for help. This option is also used
-# when generating formulas in HTML.
+# if errors occur, instead of asking the user for help.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
@@ -1750,24 +2007,30 @@ LATEX_BATCHMODE        = NO
 
 LATEX_HIDE_INDICES     = NO
 
-# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
-# code with syntax highlighting in the LaTeX output.
-#
-# Note that which sources are shown also depends on other settings such as
-# SOURCE_BROWSER.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_SOURCE_CODE      = NO
-
 # The LATEX_BIB_STYLE tag can be used to specify the style to use for the
 # bibliography, e.g. plainnat, or ieeetr. See
-# http://en.wikipedia.org/wiki/BibTeX and \cite for more info.
+# https://en.wikipedia.org/wiki/BibTeX and \cite for more info.
 # The default value is: plain.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
 LATEX_BIB_STYLE        = plain
 
+# If the LATEX_TIMESTAMP tag is set to YES then the footer of each generated
+# page will contain the date and time when the page was generated. Setting this
+# to NO can help when comparing the output of multiple runs.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_TIMESTAMP        = NO
+
+# The LATEX_EMOJI_DIRECTORY tag is used to specify the (relative or absolute)
+# path from which the emoji images will be read. If a relative path is entered,
+# it will be relative to the LATEX_OUTPUT directory. If left blank the
+# LATEX_OUTPUT directory will be used.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EMOJI_DIRECTORY  =
+
 #---------------------------------------------------------------------------
 # Configuration options related to the RTF output
 #---------------------------------------------------------------------------
@@ -1807,32 +2070,22 @@ COMPACT_RTF            = NO
 
 RTF_HYPERLINKS         = NO
 
-# Load stylesheet definitions from file. Syntax is similar to doxygen's config
-# file, i.e. a series of assignments. You only have to provide replacements,
-# missing definitions are set to their default value.
+# Load stylesheet definitions from file. Syntax is similar to doxygen's
+# configuration file, i.e. a series of assignments. You only have to provide
+# replacements, missing definitions are set to their default value.
 #
 # See also section "Doxygen usage" for information on how to generate the
 # default style sheet that doxygen normally uses.
 # This tag requires that the tag GENERATE_RTF is set to YES.
 
-RTF_STYLESHEET_FILE    = 
+RTF_STYLESHEET_FILE    =
 
 # Set optional variables used in the generation of an RTF document. Syntax is
-# similar to doxygen's config file. A template extensions file can be generated
-# using doxygen -e rtf extensionFile.
+# similar to doxygen's configuration file. A template extensions file can be
+# generated using doxygen -e rtf extensionFile.
 # This tag requires that the tag GENERATE_RTF is set to YES.
 
-RTF_EXTENSIONS_FILE    = 
-
-# If the RTF_SOURCE_CODE tag is set to YES then doxygen will include source code
-# with syntax highlighting in the RTF output.
-#
-# Note that which sources are shown also depends on other settings such as
-# SOURCE_BROWSER.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_SOURCE_CODE        = NO
+RTF_EXTENSIONS_FILE    =
 
 #---------------------------------------------------------------------------
 # Configuration options related to the man page output
@@ -1867,7 +2120,7 @@ MAN_EXTENSION          = .3dbus
 # MAN_EXTENSION with the initial . removed.
 # This tag requires that the tag GENERATE_MAN is set to YES.
 
-MAN_SUBDIR             = 
+MAN_SUBDIR             =
 
 # If the MAN_LINKS tag is set to YES and doxygen generates man output, then it
 # will generate one additional man file for each entity documented in the real
@@ -1905,6 +2158,13 @@ XML_OUTPUT             = xml
 
 XML_PROGRAMLISTING     = YES
 
+# If the XML_NS_MEMB_FILE_SCOPE tag is set to YES, doxygen will include
+# namespace members in file scope as well, matching the HTML output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_NS_MEMB_FILE_SCOPE = NO
+
 #---------------------------------------------------------------------------
 # Configuration options related to the DOCBOOK output
 #---------------------------------------------------------------------------
@@ -1923,23 +2183,14 @@ GENERATE_DOCBOOK       = NO
 
 DOCBOOK_OUTPUT         = docbook
 
-# If the DOCBOOK_PROGRAMLISTING tag is set to YES, doxygen will include the
-# program listings (including syntax highlighting and cross-referencing
-# information) to the DOCBOOK output. Note that enabling this will significantly
-# increase the size of the DOCBOOK output.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
-
-DOCBOOK_PROGRAMLISTING = NO
-
 #---------------------------------------------------------------------------
 # Configuration options for the AutoGen Definitions output
 #---------------------------------------------------------------------------
 
 # If the GENERATE_AUTOGEN_DEF tag is set to YES, doxygen will generate an
-# AutoGen Definitions (see http://autogen.sf.net) file that captures the
-# structure of the code including all documentation. Note that this feature is
-# still experimental and incomplete at the moment.
+# AutoGen Definitions (see http://autogen.sourceforge.net/) file that captures
+# the structure of the code including all documentation. Note that this feature
+# is still experimental and incomplete at the moment.
 # The default value is: NO.
 
 GENERATE_AUTOGEN_DEF   = NO
@@ -1980,7 +2231,7 @@ PERLMOD_PRETTY         = YES
 # overwrite each other's variables.
 # This tag requires that the tag GENERATE_PERLMOD is set to YES.
 
-PERLMOD_MAKEVAR_PREFIX = 
+PERLMOD_MAKEVAR_PREFIX =
 
 #---------------------------------------------------------------------------
 # Configuration options related to the preprocessor
@@ -2018,10 +2269,11 @@ SEARCH_INCLUDES        = YES
 
 # The INCLUDE_PATH tag can be used to specify one or more directories that
 # contain include files that are not input files but should be processed by the
-# preprocessor.
+# preprocessor. Note that the INCLUDE_PATH is not recursive, so the setting of
+# RECURSIVE has no effect here.
 # This tag requires that the tag SEARCH_INCLUDES is set to YES.
 
-INCLUDE_PATH           = 
+INCLUDE_PATH           =
 
 # You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
 # patterns (like *.h and *.hpp) to filter out the header-files in the
@@ -2029,7 +2281,7 @@ INCLUDE_PATH           =
 # used.
 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
-INCLUDE_FILE_PATTERNS  = 
+INCLUDE_FILE_PATTERNS  =
 
 # The PREDEFINED tag can be used to specify one or more macro names that are
 # defined before the preprocessor is started (similar to the -D option of e.g.
@@ -2039,7 +2291,7 @@ INCLUDE_FILE_PATTERNS  =
 # recursively expanded use the := operator instead of the = operator.
 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
-PREDEFINED             = 
+PREDEFINED             =
 
 # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
 # tag can be used to specify a list of macro names that should be expanded. The
@@ -2048,7 +2300,7 @@ PREDEFINED             =
 # definition found in the source code.
 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
-EXPAND_AS_DEFINED      = 
+EXPAND_AS_DEFINED      =
 
 # If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will
 # remove all references to function-like macros that are alone on a line, have
@@ -2077,13 +2329,13 @@ SKIP_FUNCTION_MACROS   = YES
 # the path). If a tag file is not located in the directory in which doxygen is
 # run, you must also specify the path to the tagfile here.
 
-TAGFILES               = 
+TAGFILES               =
 
 # When a file name is specified after GENERATE_TAGFILE, doxygen will create a
 # tag file that is based on the input files it reads. See section "Linking to
 # external documentation" for more information about the usage of tag files.
 
-GENERATE_TAGFILE       = 
+GENERATE_TAGFILE       =
 
 # If the ALLEXTERNALS tag is set to YES, all external class will be listed in
 # the class index. If set to NO, only the inherited external classes will be
@@ -2106,40 +2358,16 @@ EXTERNAL_GROUPS        = YES
 
 EXTERNAL_PAGES         = YES
 
-# The PERL_PATH should be the absolute path and name of the perl script
-# interpreter (i.e. the result of 'which perl').
-# The default file (with absolute path) is: /usr/bin/perl.
-
-PERL_PATH              = /usr/bin/perl
-
 #---------------------------------------------------------------------------
 # Configuration options related to the dot tool
 #---------------------------------------------------------------------------
 
-# If the CLASS_DIAGRAMS tag is set to YES, doxygen will generate a class diagram
-# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
-# NO turns the diagrams off. Note that this option also works with HAVE_DOT
-# disabled, but it is recommended to install and use dot, since it yields more
-# powerful graphs.
-# The default value is: YES.
-
-CLASS_DIAGRAMS         = YES
-
-# You can define message sequence charts within doxygen comments using the \msc
-# command. Doxygen will then run the mscgen tool (see:
-# http://www.mcternan.me.uk/mscgen/)) to produce the chart and insert it in the
-# documentation. The MSCGEN_PATH tag allows you to specify the directory where
-# the mscgen tool resides. If left empty the tool is assumed to be found in the
-# default search path.
-
-MSCGEN_PATH            = 
-
 # You can include diagrams made with dia in doxygen documentation. Doxygen will
 # then run dia to produce the diagram and insert it in the documentation. The
 # DIA_PATH tag allows you to specify the directory where the dia binary resides.
 # If left empty dia is assumed to be found in the default search path.
 
-DIA_PATH               = 
+DIA_PATH               =
 
 # If set to YES the inheritance and collaboration graphs will hide inheritance
 # and usage relations if the target is undocumented or is not a class.
@@ -2166,36 +2394,51 @@ HAVE_DOT               = NO
 
 DOT_NUM_THREADS        = 0
 
-# When you want a differently looking font in the dot files that doxygen
-# generates you can specify the font name using DOT_FONTNAME. You need to make
-# sure dot is able to find the font, which can be done by putting it in a
-# standard location or by setting the DOTFONTPATH environment variable or by
-# setting DOT_FONTPATH to the directory containing the font.
-# The default value is: Helvetica.
+# DOT_COMMON_ATTR is common attributes for nodes, edges and labels of
+# subgraphs. When you want a differently looking font in the dot files that
+# doxygen generates you can specify fontname, fontcolor and fontsize attributes.
+# For details please see <a href=https://graphviz.org/doc/info/attrs.html>Node,
+# Edge and Graph Attributes specification</a> You need to make sure dot is able
+# to find the font, which can be done by putting it in a standard location or by
+# setting the DOTFONTPATH environment variable or by setting DOT_FONTPATH to the
+# directory containing the font. Default graphviz fontsize is 14.
+# The default value is: fontname=Helvetica,fontsize=10.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
-DOT_FONTNAME           = Helvetica
+DOT_COMMON_ATTR        = "fontname=Helvetica,fontsize=10"
 
-# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
-# dot graphs.
-# Minimum value: 4, maximum value: 24, default value: 10.
+# DOT_EDGE_ATTR is concatenated with DOT_COMMON_ATTR. For elegant style you can
+# add 'arrowhead=open, arrowtail=open, arrowsize=0.5'. <a
+# href=https://graphviz.org/doc/info/arrows.html>Complete documentation about
+# arrows shapes.</a>
+# The default value is: labelfontname=Helvetica,labelfontsize=10.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
-DOT_FONTSIZE           = 10
+DOT_EDGE_ATTR          = "labelfontname=Helvetica,labelfontsize=10"
 
-# By default doxygen will tell dot to use the default font as specified with
-# DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
-# the path where dot can find it using this tag.
+# DOT_NODE_ATTR is concatenated with DOT_COMMON_ATTR. For view without boxes
+# around nodes set 'shape=plain' or 'shape=plaintext' <a
+# href=https://www.graphviz.org/doc/info/shapes.html>Shapes specification</a>
+# The default value is: shape=box,height=0.2,width=0.4.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
-DOT_FONTPATH           = 
+DOT_NODE_ATTR          = "shape=box,height=0.2,width=0.4"
 
-# If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for
-# each documented class showing the direct and indirect inheritance relations.
-# Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO.
-# The default value is: YES.
+# You can set the path where dot can find font specified with fontname in
+# DOT_COMMON_ATTR and others dot attributes.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
+DOT_FONTPATH           =
+
+# If the CLASS_GRAPH tag is set to YES (or GRAPH) then doxygen will generate a
+# graph for each documented class showing the direct and indirect inheritance
+# relations. In case HAVE_DOT is set as well dot will be used to draw the graph,
+# otherwise the built-in generator will be used. If the CLASS_GRAPH tag is set
+# to TEXT the direct and indirect inheritance relations will be shown as texts /
+# links.
+# Possible values are: NO, YES, TEXT and GRAPH.
+# The default value is: YES.
+
 CLASS_GRAPH            = YES
 
 # If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
@@ -2208,7 +2451,8 @@ CLASS_GRAPH            = YES
 COLLABORATION_GRAPH    = YES
 
 # If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
-# groups, showing the direct groups dependencies.
+# groups, showing the direct groups dependencies. See also the chapter Grouping
+# in the manual.
 # The default value is: YES.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
@@ -2231,10 +2475,32 @@ UML_LOOK               = NO
 # but if the number exceeds 15, the total amount of fields shown is limited to
 # 10.
 # Minimum value: 0, maximum value: 100, default value: 10.
-# This tag requires that the tag HAVE_DOT is set to YES.
+# This tag requires that the tag UML_LOOK is set to YES.
 
 UML_LIMIT_NUM_FIELDS   = 10
 
+# If the DOT_UML_DETAILS tag is set to NO, doxygen will show attributes and
+# methods without types and arguments in the UML graphs. If the DOT_UML_DETAILS
+# tag is set to YES, doxygen will add type and arguments for attributes and
+# methods in the UML graphs. If the DOT_UML_DETAILS tag is set to NONE, doxygen
+# will not generate fields with class member information in the UML graphs. The
+# class diagrams will look similar to the default class diagrams but using UML
+# notation for the relationships.
+# Possible values are: NO, YES and NONE.
+# The default value is: NO.
+# This tag requires that the tag UML_LOOK is set to YES.
+
+DOT_UML_DETAILS        = NO
+
+# The DOT_WRAP_THRESHOLD tag can be used to set the maximum number of characters
+# to display on a single line. If the actual line length exceeds this threshold
+# significantly it will wrapped across multiple lines. Some heuristics are apply
+# to avoid ugly line breaks.
+# Minimum value: 0, maximum value: 1000, default value: 17.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_WRAP_THRESHOLD     = 17
+
 # If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
 # collaboration graphs will show the relations between templates and their
 # instances.
@@ -2301,6 +2567,13 @@ GRAPHICAL_HIERARCHY    = YES
 
 DIRECTORY_GRAPH        = YES
 
+# The DIR_GRAPH_MAX_DEPTH tag can be used to limit the maximum number of levels
+# of child directories generated in directory dependency graphs by dot.
+# Minimum value: 1, maximum value: 25, default value: 1.
+# This tag requires that the tag DIRECTORY_GRAPH is set to YES.
+
+DIR_GRAPH_MAX_DEPTH    = 1
+
 # The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
 # generated by dot. For an explanation of the image formats see the section
 # output formats in the documentation of the dot tool (Graphviz (see:
@@ -2332,39 +2605,44 @@ INTERACTIVE_SVG        = NO
 # found. If left blank, it is assumed the dot tool can be found in the path.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
-DOT_PATH               = 
+DOT_PATH               =
 
 # The DOTFILE_DIRS tag can be used to specify one or more directories that
 # contain dot files that are included in the documentation (see the \dotfile
 # command).
 # This tag requires that the tag HAVE_DOT is set to YES.
 
-DOTFILE_DIRS           = 
+DOTFILE_DIRS           =
 
 # The MSCFILE_DIRS tag can be used to specify one or more directories that
 # contain msc files that are included in the documentation (see the \mscfile
 # command).
 
-MSCFILE_DIRS           = 
+MSCFILE_DIRS           =
 
 # The DIAFILE_DIRS tag can be used to specify one or more directories that
 # contain dia files that are included in the documentation (see the \diafile
 # command).
 
-DIAFILE_DIRS           = 
+DIAFILE_DIRS           =
 
 # When using plantuml, the PLANTUML_JAR_PATH tag should be used to specify the
-# path where java can find the plantuml.jar file. If left blank, it is assumed
-# PlantUML is not used or called during a preprocessing step. Doxygen will
-# generate a warning when it encounters a \startuml command in this case and
-# will not generate output for the diagram.
+# path where java can find the plantuml.jar file or to the filename of jar file
+# to be used. If left blank, it is assumed PlantUML is not used or called during
+# a preprocessing step. Doxygen will generate a warning when it encounters a
+# \startuml command in this case and will not generate output for the diagram.
+
+PLANTUML_JAR_PATH      =
 
-PLANTUML_JAR_PATH      = 
+# When using plantuml, the PLANTUML_CFG_FILE tag can be used to specify a
+# configuration file for plantuml.
+
+PLANTUML_CFG_FILE      =
 
 # When using plantuml, the specified paths are searched for files specified by
 # the !include statement in a plantuml block.
 
-PLANTUML_INCLUDE_PATH  = 
+PLANTUML_INCLUDE_PATH  =
 
 # The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes
 # that will be shown in the graph. If the number of nodes in a graph becomes
@@ -2390,18 +2668,6 @@ DOT_GRAPH_MAX_NODES    = 50
 
 MAX_DOT_GRAPH_DEPTH    = 0
 
-# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
-# background. This is disabled by default, because dot on Windows does not seem
-# to support this out of the box.
-#
-# Warning: Depending on the platform used, enabling this option may lead to
-# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
-# read).
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_TRANSPARENT        = NO
-
 # Set the DOT_MULTI_TARGETS tag to YES to allow dot to generate multiple output
 # files in one run (i.e. multiple -o and -T options on the command line). This
 # makes dot run faster, but since only newer versions of dot (>1.8.10) support
@@ -2414,14 +2680,18 @@ DOT_MULTI_TARGETS      = NO
 # If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
 # explaining the meaning of the various boxes and arrows in the dot generated
 # graphs.
+# Note: This tag requires that UML_LOOK isn't set, i.e. the doxygen internal
+# graphical representation for inheritance and collaboration diagrams is used.
 # The default value is: YES.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 GENERATE_LEGEND        = YES
 
-# If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate dot
+# If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate
 # files that are used to generate the various graphs.
+#
+# Note: This setting is not only used for dot files but also for msc temporary
+# files.
 # The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
 
 DOT_CLEANUP            = YES
diff --git a/README.md b/README.md
index 8adba6b54..fb0c05a0e 100644
--- a/README.md
+++ b/README.md
@@ -5,7 +5,7 @@ Recast & Detour
 [![Build](https://github.com/recastnavigation/recastnavigation/actions/workflows/Build.yaml/badge.svg)](https://github.com/recastnavigation/recastnavigation/actions/workflows/Build.yaml)
 [![Tests](https://github.com/recastnavigation/recastnavigation/actions/workflows/Tests.yaml/badge.svg)](https://github.com/recastnavigation/recastnavigation/actions/workflows/Tests.yaml)
 
-![screenshot of a navmesh baked with the sample program](/RecastDemo/screenshot.png?raw=true)
+![screenshot of a navmesh baked with the sample program](/Docs/Images/screenshot.png)
 
 ## Recast
 
diff --git a/Recast/Include/Recast.h b/Recast/Include/Recast.h
index a36d7add7..246376bbe 100644
--- a/Recast/Include/Recast.h
+++ b/Recast/Include/Recast.h
@@ -22,6 +22,9 @@
 /// The value of PI used by Recast.
 static const float RC_PI = 3.14159265f;
 
+/// Used to ignore unused function parameters and silence any compiler warnings.
+template<class T> void rcIgnoreUnused(const T&) { }
+
 /// Recast log categories.
 /// @see rcContext
 enum rcLogCategory
@@ -146,23 +149,23 @@ class rcContext
 	///  @param[in]		category	The category of the message.
 	///  @param[in]		msg			The formatted message.
 	///  @param[in]		len			The length of the formatted message.
-	virtual void doLog(const rcLogCategory /*category*/, const char* /*msg*/, const int /*len*/) {}
+	virtual void doLog(const rcLogCategory category, const char* msg, const int len) { rcIgnoreUnused(category); rcIgnoreUnused(msg); rcIgnoreUnused(len); }
 
 	/// Clears all timers. (Resets all to unused.)
 	virtual void doResetTimers() {}
 
 	/// Starts the specified performance timer.
 	///  @param[in]		label	The category of timer.
-	virtual void doStartTimer(const rcTimerLabel /*label*/) {}
+	virtual void doStartTimer(const rcTimerLabel label) { rcIgnoreUnused(label); }
 
 	/// Stops the specified performance timer.
 	///  @param[in]		label	The category of the timer.
-	virtual void doStopTimer(const rcTimerLabel /*label*/) {}
+	virtual void doStopTimer(const rcTimerLabel label) { rcIgnoreUnused(label); }
 
 	/// Returns the total accumulated time of the specified performance timer.
 	///  @param[in]		label	The category of the timer.
 	///  @return The accumulated time of the timer, or -1 if timers are disabled or the timer has never been started.
-	virtual int doGetAccumulatedTime(const rcTimerLabel /*label*/) const { return -1; }
+	virtual int doGetAccumulatedTime(const rcTimerLabel label) const { rcIgnoreUnused(label); return -1; }
 	
 	/// True if logging is enabled.
 	bool m_logEnabled;
@@ -593,11 +596,6 @@ static const int RC_NOT_CONNECTED = 0x3f;
 /// @name General helper functions
 /// @{
 
-/// Used to ignore a function parameter.  VS complains about unused parameters
-/// and this silences the warning.
-///  @param [in] _ Unused parameter
-template<class T> void rcIgnoreUnused(const T&) { }
-
 /// Swaps the values of the two parameters.
 ///  @param[in,out]	a	Value A
 ///  @param[in,out]	b	Value B
@@ -994,6 +992,7 @@ void rcMarkConvexPolyArea(rcContext* ctx, const float* verts, const int nverts,
 ///  @ingroup recast
 ///  @param[in]		verts		The vertices of the polygon [Form: (x, y, z) * @p nverts]
 ///  @param[in]		nverts		The number of vertices in the polygon.
+///  @param[in]		offset		How much to offset the polygon by. [Units: wu]
 ///  @param[out]	outVerts	The offset vertices (should hold up to 2 * @p nverts) [Form: (x, y, z) * return value]
 ///  @param[in]		maxOutVerts	The max number of vertices that can be stored to @p outVerts.
 ///  @returns Number of vertices in the offset polygon or 0 if too few vertices in @p outVerts.

From 3901c5854c958593443859fd1214162452ff2982 Mon Sep 17 00:00:00 2001
From: Piotr Piastucki <ppiastucki@users.noreply.github.com>
Date: Wed, 23 Nov 2022 08:42:03 +0100
Subject: [PATCH 46/51] Fix incorrect rasterization at tile borders (#476)

* Fix incorrect rasterization at tile borders

Clip the polygon at the tile border and disregard coordinates outside of
the tile before clamping.

* Added unit test with minimal repro case for the rasterization issue fixed in PR #476

Co-authored-by: Graham Pentheny <graham.pentheny@gmail.com>
---
 Recast/Source/RecastRasterization.cpp | 12 ++++++---
 Tests/Recast/Tests_Recast.cpp         | 37 +++++++++++++++++++++++++++
 2 files changed, 45 insertions(+), 4 deletions(-)

diff --git a/Recast/Source/RecastRasterization.cpp b/Recast/Source/RecastRasterization.cpp
index a4cef7490..673550e79 100644
--- a/Recast/Source/RecastRasterization.cpp
+++ b/Recast/Source/RecastRasterization.cpp
@@ -264,7 +264,8 @@ static bool rasterizeTri(const float* v0, const float* v1, const float* v2,
 	// Calculate the footprint of the triangle on the grid's y-axis
 	int y0 = (int)((tmin[2] - bmin[2])*ics);
 	int y1 = (int)((tmax[2] - bmin[2])*ics);
-	y0 = rcClamp(y0, 0, h-1);
+	// use -1 rather than 0 to cut the polygon properly at the start of the tile
+	y0 = rcClamp(y0, -1, h-1);
 	y1 = rcClamp(y1, 0, h-1);
 	
 	// Clip the triangle into all grid cells it touches.
@@ -283,7 +284,7 @@ static bool rasterizeTri(const float* v0, const float* v1, const float* v2,
 		dividePoly(in, nvIn, inrow, &nvrow, p1, &nvIn, cz+cs, 2);
 		rcSwap(in, p1);
 		if (nvrow < 3) continue;
-		
+		if (y < 0) continue;
 		// find the horizontal bounds in the row
 		float minX = inrow[0], maxX = inrow[0];
 		for (int i=1; i<nvrow; ++i)
@@ -293,7 +294,10 @@ static bool rasterizeTri(const float* v0, const float* v1, const float* v2,
 		}
 		int x0 = (int)((minX - bmin[0])*ics);
 		int x1 = (int)((maxX - bmin[0])*ics);
-		x0 = rcClamp(x0, 0, w-1);
+		if (x1 < 0 || x0 >= w) {
+			continue;
+		}
+		x0 = rcClamp(x0, -1, w-1);
 		x1 = rcClamp(x1, 0, w-1);
 
 		int nv, nv2 = nvrow;
@@ -305,7 +309,7 @@ static bool rasterizeTri(const float* v0, const float* v1, const float* v2,
 			dividePoly(inrow, nv2, p1, &nv, p2, &nv2, cx+cs, 0);
 			rcSwap(inrow, p2);
 			if (nv < 3) continue;
-			
+			if (x < 0) continue;
 			// Calculate min and max of the span.
 			float smin = p1[1], smax = p1[1];
 			for (int i = 1; i < nv; ++i)
diff --git a/Tests/Recast/Tests_Recast.cpp b/Tests/Recast/Tests_Recast.cpp
index e21995941..e1ee2235e 100644
--- a/Tests/Recast/Tests_Recast.cpp
+++ b/Tests/Recast/Tests_Recast.cpp
@@ -657,6 +657,43 @@ TEST_CASE("rcRasterizeTriangle")
 	}
 }
 
+TEST_CASE("rcRasterizeTriangle overlapping bb but non-overlapping triangle")
+{
+	// This is a minimal repro case for the issue fixed in PR #476 (https://github.com/recastnavigation/recastnavigation/pull/476)
+    rcContext ctx;
+
+	// create a heightfield
+    float cellSize = 1;
+    float cellHeight = 1;
+    int width = 10;
+    int height = 10;
+    float bmin[] = { 0, 0, 0 };
+    float bmax[] = { 10, 10, 10 };
+    rcHeightfield heightfield;
+    REQUIRE(rcCreateHeightfield(&ctx, heightfield, width, height, bmin, bmax, cellSize, cellHeight));
+
+	// rasterize a triangle outside of the heightfield.
+    unsigned char area = 42;
+    int flagMergeThr = 1;
+    float verts[] =
+	{
+        -10.0, 5.5, -10.0,
+        -10.0, 5.5, 3,
+        3.0, 5.5, -10.0
+    };
+    REQUIRE(rcRasterizeTriangle(&ctx, &verts[0], &verts[3], &verts[6], area, heightfield, flagMergeThr));
+    
+	// ensure that no spans were created
+    for (int x = 0; x < width; ++x)
+	{
+        for (int z = 0; z < height; ++z)
+		{
+            rcSpan* span = heightfield.spans[x + z * heightfield.width];
+			REQUIRE(span == NULL);
+        }
+    }
+}
+
 TEST_CASE("rcRasterizeTriangles")
 {
 	rcContext ctx;

From 4fef0446609b23d6ac180ed822817571525528a1 Mon Sep 17 00:00:00 2001
From: Graham Pentheny <graham.pentheny@gmail.com>
Date: Fri, 25 Nov 2022 19:55:38 -0500
Subject: [PATCH 47/51] Unit test to check for crashes in rasterizing long,
 skinny triangles

Specifically, when rasterizing a triangle into a heightfield with width or height of 0.  This can happen when the input geometry bounding box extents are less than half the cell size in either x or z.  This is a degenerate case, but can crop up in real life scenarios (see https://github.com/godotengine/godot/issues/65764) so we should at least ensure it doesn't crash here.
---
 Tests/Recast/Tests_Recast.cpp | 67 +++++++++++++++++++++++++++++++++++
 1 file changed, 67 insertions(+)

diff --git a/Tests/Recast/Tests_Recast.cpp b/Tests/Recast/Tests_Recast.cpp
index e1ee2235e..39ac43044 100644
--- a/Tests/Recast/Tests_Recast.cpp
+++ b/Tests/Recast/Tests_Recast.cpp
@@ -694,6 +694,73 @@ TEST_CASE("rcRasterizeTriangle overlapping bb but non-overlapping triangle")
     }
 }
 
+TEST_CASE("rcRasterizeTriangle smaller than half a voxel size in x")
+{
+	SECTION("Skinny triangle along x axis")
+	{
+		rcContext ctx;
+		float verts[] = {
+			5, 0, 0.005f,
+			5, 0, -0.005f,
+			-5, 0, 0.005f,
+
+			-5, 0, 0.005f,
+			5, 0, -0.005f,
+			-5, 0, -0.005f,
+		};
+		float bmin[3];
+		float bmax[3];
+		rcCalcBounds(verts, 3, bmin, bmax);
+
+		float cellSize = 1;
+		float cellHeight = 1;
+
+		int width;
+		int height;
+
+		rcCalcGridSize(bmin, bmax, cellSize, &width, &height);
+
+		rcHeightfield solid;
+		REQUIRE(rcCreateHeightfield(&ctx, solid, width, height, bmin, bmax, cellSize, cellHeight));
+
+		unsigned char areas[] = {42, 42};
+		int flagMergeThr = 1;
+		REQUIRE(rcRasterizeTriangles(&ctx, verts, areas, 2, solid, flagMergeThr));
+	}
+	
+	SECTION("Skinny triangle along z axis")
+	{
+		rcContext ctx;
+		float verts[] = {
+			0.005f, 0, 5,
+			-0.005f, 0, 5,
+			0.005f, 0, -5,
+
+			0.005f, 0, -5,
+			-0.005f, 0, 5,
+			-0.005f, 0, -5
+		};
+		float bmin[3];
+		float bmax[3];
+		rcCalcBounds(verts, 3, bmin, bmax);
+
+		float cellSize = 1;
+		float cellHeight = 1;
+
+		int width;
+		int height;
+
+		rcCalcGridSize(bmin, bmax, cellSize, &width, &height);
+
+		rcHeightfield solid;
+		REQUIRE(rcCreateHeightfield(&ctx, solid, width, height, bmin, bmax, cellSize, cellHeight));
+
+		unsigned char areas[] = {42, 42};
+		int flagMergeThr = 1;
+		REQUIRE(rcRasterizeTriangles(&ctx, verts, areas, 2, solid, flagMergeThr));
+	}
+}
+
 TEST_CASE("rcRasterizeTriangles")
 {
 	rcContext ctx;

From 67ba9a2a15d7cb6b0a1e428dbb4b1ed947c74658 Mon Sep 17 00:00:00 2001
From: Graham Pentheny <grahamboree@users.noreply.github.com>
Date: Fri, 25 Nov 2022 20:29:11 -0500
Subject: [PATCH 48/51] Fix macOS CMake SDL linking (#584)

* Ignore cmake intermediate build dir

* Fix C++ language version in cmake build scripts

* Set a default SDL2_ROOT_DIR value for macOS in cmake scripts

* Fixed macOS SDL framework linking in cmake scripts

* Added macos-cmake target for CI builds in github workflows

* Use C++17 for building Tests instead of 20, since we build them with VS2019 in some jobs
---
 .github/workflows/Build.yaml | 27 +++++++++++++++++++++++++++
 .gitignore                   |  3 +++
 CMakeLists.txt               |  2 ++
 RecastDemo/CMakeLists.txt    | 23 +++++++++++++++++++++--
 Tests/CMakeLists.txt         |  3 +++
 5 files changed, 56 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/Build.yaml b/.github/workflows/Build.yaml
index eb45d5692..955b21fd2 100644
--- a/.github/workflows/Build.yaml
+++ b/.github/workflows/Build.yaml
@@ -46,6 +46,33 @@ jobs:
       working-directory: RecastDemo/Build/xcode4/
       run: xcodebuild -scheme Tests -configuration ${{matrix.conf}} -project Tests.xcodeproj build
   
+  macos-cmake:
+    strategy:
+      matrix:
+        conf:
+          - Debug
+          - Release
+
+    runs-on: macos-latest
+    
+    steps:
+    - uses: actions/checkout@v3
+    - name: Download & install SDL
+      run: |
+        curl -L -o SDL2.dmg https://github.com/libsdl-org/SDL/releases/download/release-2.24.2/SDL2-2.24.2.dmg
+        hdiutil attach SDL2.dmg
+        cp -r /Volumes/SDL2/SDL2.framework ${{github.workspace}}/RecastDemo/Bin/
+        hdiutil detach /Volumes/SDL2
+        rm SDL2.dmg
+
+    - name: Configure CMake
+      # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
+      # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
+      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{matrix.conf}} -DSDL2_LIBRARY=${{github.workspace}}/RecastDemo/Bin/SDL2.framework
+
+    - name: Build
+      run: cmake --build ${{github.workspace}}/build --config ${{matrix.conf}}
+  
   linux-premake:
     strategy:
       matrix:
diff --git a/.gitignore b/.gitignore
index 1e20e6026..ccd8a58e6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -47,6 +47,9 @@ RecastDemo/Contrib/SDL/*
 ## Generated doc files
 Docs/html
 
+## CMake build cache
+build
+
 ## IDE files
 .idea/
 cmake-build-*/
diff --git a/CMakeLists.txt b/CMakeLists.txt
index a3fe28d2e..d6fc2169c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -7,6 +7,8 @@ SET(SOVERSION 1)
 set(LIB_VERSION 1.5.1)
 string(REPLACE "." "," LIB_VERSION_NUM "${LIB_VERSION}.0")
 
+set_property(GLOBAL PROPERTY CXX_STANDARD 98)
+
 option(RECASTNAVIGATION_DEMO "Build demo" ON)
 option(RECASTNAVIGATION_TESTS "Build tests" ON)
 option(RECASTNAVIGATION_EXAMPLES "Build examples" ON)
diff --git a/RecastDemo/CMakeLists.txt b/RecastDemo/CMakeLists.txt
index b379b27bd..1e8f9398a 100644
--- a/RecastDemo/CMakeLists.txt
+++ b/RecastDemo/CMakeLists.txt
@@ -3,11 +3,22 @@ file(GLOB SOURCES Source/*.cpp Contrib/fastlz/fastlz.c)
 list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
 
 if(NOT SDL2_ROOT_DIR)
+  if(WIN32)
     set(SDL2_ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/Contrib/SDL")
+  elseif(APPLE)
+    set(SDL2_ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/Bin")
+  endif()
 endif()
 
 find_package(OpenGL REQUIRED)
-find_package(SDL2 REQUIRED)
+if(APPLE)
+  find_library(SDL2_LIBRARY 
+    NAMES SDL2
+    PATHS ${SDL2_ROOT_DIR}
+    REQUIRED)
+else()
+  find_package(SDL2 REQUIRED)
+endif()
 
 include_directories(SYSTEM ${OPENGL_INCLUDE_DIR})
 include_directories(SYSTEM Contrib/fastlz)
@@ -19,6 +30,9 @@ include_directories(../DetourTileCache/Include)
 include_directories(../Recast/Include)
 include_directories(Include)
 include_directories(Contrib/SDL/include)
+if(APPLE)
+  include_directories(${SDL2_LIBRARY}/Headers)
+endif()
 
 if (WIN32)
     add_executable(RecastDemo WIN32 ${SOURCES})
@@ -54,7 +68,12 @@ endif()
 
 
 add_dependencies(RecastDemo DebugUtils Detour DetourCrowd DetourTileCache Recast)
-target_link_libraries(RecastDemo ${OPENGL_LIBRARIES} SDL2::SDL2main DebugUtils Detour DetourCrowd DetourTileCache Recast)
+if(APPLE)
+  target_link_libraries(RecastDemo ${OPENGL_LIBRARIES} ${SDL2_LIBRARY} DebugUtils Detour DetourCrowd DetourTileCache Recast)
+else()
+  target_link_libraries(RecastDemo ${OPENGL_LIBRARIES} SDL2::SDL2main DebugUtils Detour DetourCrowd DetourTileCache Recast)
+endif()
+
 
 install(TARGETS RecastDemo
         RUNTIME DESTINATION bin
diff --git a/Tests/CMakeLists.txt b/Tests/CMakeLists.txt
index 3b906897b..45d7d1f7d 100644
--- a/Tests/CMakeLists.txt
+++ b/Tests/CMakeLists.txt
@@ -6,6 +6,9 @@ include_directories(./Contrib/Catch)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 
 add_executable(Tests ${TESTS_SOURCES})
+
+set_property(TARGET Tests PROPERTY CXX_STANDARD 17)
+
 add_dependencies(Tests Recast Detour)
 target_link_libraries(Tests Recast Detour)
 add_test(Tests Tests)

From 250c3041ce96c422d7cff46e60b1b663af94f158 Mon Sep 17 00:00:00 2001
From: Graham Pentheny <graham.pentheny@gmail.com>
Date: Fri, 25 Nov 2022 21:38:11 -0500
Subject: [PATCH 49/51] Added development roadmap

---
 Doxyfile   |  1 +
 README.md  |  4 +--
 Roadmap.md | 74 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 77 insertions(+), 2 deletions(-)
 create mode 100644 Roadmap.md

diff --git a/Doxyfile b/Doxyfile
index dd7f5ed2f..920937bfd 100644
--- a/Doxyfile
+++ b/Doxyfile
@@ -911,6 +911,7 @@ WARN_LOGFILE           =
 INPUT                  = . \
                          README.md \
                          CONTRIBUTING.md \
+                         Roadmap.md \
                          DetourCrowd \
                          DetourTileCache \
                          Recast \
diff --git a/README.md b/README.md
index fb0c05a0e..fa5b4162d 100644
--- a/README.md
+++ b/README.md
@@ -77,9 +77,9 @@ If you are using the [vcpkg](https://github.com/Microsoft/vcpkg/) dependency man
 vcpkg install recast
 ```
 
-## Contributing
+## Contribute
 
-See the [Contributing document](CONTRIBUTING.md) for guidelines for making contributions.
+Check out the [Project Roadmap](Roadmap.md) to see what features and functionality you might be able to help with, and the [Contributing doc](CONTRIBUTING.md) for guidance on making contributions.
 
 ## Discuss
 
diff --git a/Roadmap.md b/Roadmap.md
new file mode 100644
index 000000000..e86e3793a
--- /dev/null
+++ b/Roadmap.md
@@ -0,0 +1,74 @@
+# Recast Development Roadmap
+
+This document describes the current development roadmap for Recast and Detour.  It is initially focused on maintaining and polishing the current functionality in a way that makes it more appealing and easier to use.  There are a number of large areas of new functionality that are appealing as well.  
+
+If you're excited about contributing to Recast or want to understand what its future looks like, this roadmap is a great place to start.
+
+## Short Term
+
+### Documentation & Web Presence
+-   **Project website** (GitHub pages). A home for docs, info, tutorials, etc. that's easy to find and navigate. There's stuff like the wiki system in GitHub that can serve this purpose, but it's not the greatest.
+-   **Hosted API Reference**: We have extensive doxygen docs that we should also host on github pages.  Ideally this would be implemented as a job for the CI process.
+-   **High-level design/overview**. Basically taking a lot of the "how does Recast work?" docs we have (and stuff on Mikko's blog) and surfacing them in a place that's easier to find.  e.g. [this information](http://digestingduck.blogspot.com/2010/02/slides-from-past.html) should be integrated to the documentation.
+-   **FAQ** to include answers to common questions like "can I use Recast on a spherical world?" etc. The small group of questions that come up often.
+-   **Expand on configuration parameter docstrings**. Expand on the docstrings for the fields in `rcConfig`.
+-   **Projects using recast page**. A place to show off integrations of Recast into different games and engines. Having this visible will help give people confidence in the quality of Recast.
+
+### More explicit variable names
+There's quite a few variables that are single-letter or very condensed acronyms. Stuff like `u`, `v`, `cs`, `nnei` etc. These are certainly easier to type than more descriptive names, and can allow for some nice code formatting, but the readability gains of less condensed names outweigh that.  These should be updated to be more easily maintainable and less of a hurdle for newcomers.
+
+### Opt-in config value validation system
+There's a number of documentation-defined valid value ranges, as well as some suggested value ranges for config values like those in rcConfig.  Recast should have an _opt-in_ system for validating value ranges and value relationships.  Some implementations [like Godot's](https://github.com/godotengine/godot/blob/c7ceb94e372216b1b033d7c2ac26d5b7545c4dac/modules/navigation/navigation_mesh_generator.cpp#L545-L568) include similar configuration value checks already.  This would help alert users to potential problems arising from misconfiguration.  Recast shouldn't restrict people from going outside the recommended bounds, but for the majority of users values that are out of bounds are likely a mistake and Recast should at least raise the concern when prompted.
+
+## Medium Term
+
+### STB-Style Single-Header Release Packaging
+For ease of integration. This should probably be implemented as a build packaging script, similar to the release packaging process for the Catch unit testing library.
+
+### Ensure there's a good threading story
+Currently Recast provides no specific threading support.  Many aspects of navmesh generation (especialy with tile generation) can be easily multithreaded, as can parts of detour (threaded pathfinding, etc).  This likely requires a good example integration to work with - it probably shouldn't be designed in isolation.
+
+### More Tests
+This is a good place to start when making any changes to the internals or fixing bugs. It's important to have a way to validate that bugfixes or enhancements are not adversely affecting the base Recast functionality. Lots of parts of the code are fairly simple to test, but some would require some extra effort with mocking data or similar.
+
+### More POD structs for clarity in internals
+Small structs like a simple 3-float POD vector would go a long way to help clarify a lot of the internals. Any changes here shouldn't impact performance or functionality. They should just be simple POD structs that get optimized away but make the code a bit clearer to read and work with.
+
+### Revisit structural organization
+There some number of generally low-level geometry functions that are implemented both in Recast and in Detour. We should probably take stock of the general library layout and determine if there's enough of a benefit to slightly restructuring things to better share core functionality. There may not be enough code like this to be worth it, so it might not be a net win.  Organization and re-use benefits should vastly outweighing the cost of defining a shared dependency to make this worthwhile.  There's likely just minimal gains here since things are already laid out logically, but it's worth looking into.
+
+## Longer-Term
+
+### Higher-Level APIs
+The current API level is excellent for providing maximum control over the entire navmesh building process. For many people, integrating Recast involves copying over all the code from the tiled mesh demo with minimal tweaks. Recast can better serve these people, and hopefully boost adoption by providing some higher-level API calls.
+
+### C API
+This would help tremendously with adoption. There are a number of integrations of Recast to other languages right now, and a number of them are using their own C API wrappers around the existing Recast API. Providing a first-party C API would help normalize the different integrations of Recast out there, as well as improve the integration process for people with engines written in C or other languages with C interop.
+
+There's enough cases where we pass around object pointers in API calls that may cause this to be a bit more work than it seems.
+
+# Roadmap for New Recast/Detour Functionality
+
+### Nav Volumes & 3D Navigation
+Obviously a big feature that would enable flying agents. Probably not terribly difficult to integrate due to the voxelization process, but it's probably a lot of detailed geometric processes and challenges. We'd at least need to retain unwalkable polygons longer in the process (they get thrown away pretty early) so we should ensure it doesn't have any adversarial affects to the perf or capabilities of the normal navmesh process.  3d navigation should be a separate set of APIs, as the considerations and use cases are quite different than normal navmesh navigation.
+
+### Climbing Markup & Navigation
+This is a common problem with many modern games.  There's a number of ways to solve this, so we should make sure to consult with people who are actively using Recast and building games with climbing to understand their needs. 
+
+### Tooling
+Recast Demo already has a number of sample tools to explore and test the generated navmesh data. There's a number of middleware providers that tout workflow features and tooling for generating and manipulating navmesh data. RecastDemo could be expanded (and maybe re-named) to be a more fully fleshed out standalone tool, rather than be mostly focused as an integration demo and feature showcase. There's almost certainly a ton of custom data and markup most people will want to add to the generated navmeshes, so there should be a reasonable way for people to integrate their customizations and markup with any tooling Recast provide.
+
+### More spatial querying abilities
+There's already a number of spatial query functions, and fleshing out that set some more is likely quite easy and useful.
+
+### Auto-markup system
+This is something recast already gives you access to add yourself, thanks to its low-level API and how each step in the process is explicit.  It is worthwhile to consider what kind of help other middleware systems provide in this process. For example, are other navigation middleware solutions providing a structured way to define spatial queries that result in nav markup? Some easy examples of useful features here might be automatic jump point or cover annotations. It would be good to talk to people in the AAA FPS space to see what markup types are most useful to them.
+
+### Formations, Group behaviors
+Extending DetourCrowd to support formations, group navigation, group behaviors and similar beyond what's it's already capable of.
+
+### Vehicle Navigation & Movement
+A feature set centered on pathfinding and movement planning for characters with kinematic movement constraints.
+
+### Crowd Simulation and Flowfield movement systems
+Movement systems for large crowds that leverage flowfields or other highly-scalable navigation and movement approaches.
\ No newline at end of file

From 5f642c5e5c8b8a90bf205356ddc1c129a8e8f5b3 Mon Sep 17 00:00:00 2001
From: Graham Pentheny <graham.pentheny@gmail.com>
Date: Fri, 25 Nov 2022 21:44:54 -0500
Subject: [PATCH 50/51] Updated readme with better grammar and high-level
 overview

---
 README.md | 31 +++++++++++++++----------------
 1 file changed, 15 insertions(+), 16 deletions(-)

diff --git a/README.md b/README.md
index fa5b4162d..f1878b285 100644
--- a/README.md
+++ b/README.md
@@ -11,28 +11,27 @@ Recast & Detour
 
 Recast is state of the art navigation mesh construction toolset for games.
 
-* It is automatic, which means that you can throw any level geometry at it and you will get robust mesh out
-* It is fast which means swift turnaround times for level designers
-* It is open source so it comes with full source and you can customize it to your heart's content. 
+Recast is...
+* 🤖 **Automatic** - throw any level geometry at it and you will get a robust navmesh out
+* 💨 **Fast** - swift turnaround times for level designers
+* 🧘 **Flexible** - easily customize the navmesh generation and runtime navigation systems to suit your specific game's needs.
 
-The Recast process starts with constructing a voxel mold from a level geometry 
-and then casting a navigation mesh over it. The process consists of three steps, 
-building the voxel mold, partitioning the mold into simple regions, peeling off 
-the regions as simple polygons.
+Recast constructs a navmesh through a multi-step rasterization process:
 
-1. The voxel mold is built from the input triangle mesh by rasterizing the triangles into a multi-layer heightfield. Some simple filters are  then applied to the mold to prune out locations where the character would not be able to move.
-2. The walkable areas described by the mold are divided into simple overlayed 2D regions. The resulting regions have only one non-overlapping contour, which simplifies the final step of the process tremendously.
-3. The navigation polygons are peeled off from the regions by first tracing the boundaries and then simplifying them. The resulting polygons are finally converted to convex polygons which makes them perfect for pathfinding and spatial reasoning about the level. 
+1. First Recast voxelizes the input triangle mesh by rasterizing the triangles into a multi-layer heightfield. 
+2. Voxels in areas where the character would not be able to move are removed by applying simple voxel data filters.
+3. The walkable areas described by the voxel grid are then divided into sets of 2D polygonal regions.
+4. The navigation polygons are generated by triangulating and stiching together the generated 2d plygonal regions.
 
 ## Detour
 
-Recast is accompanied with Detour, path-finding and spatial reasoning toolkit. You can use any navigation mesh with Detour, but of course the data generated with Recast fits perfectly.
+Recast is accompanied by Detour, a path-finding and spatial reasoning toolkit. You can use any navigation mesh with Detour, but of course the data generated with Recast fits perfectly.
 
-Detour offers simple static navigation mesh which is suitable for many simple cases, as well as tiled navigation mesh which allows you to plug in and out pieces of the mesh. The tiled mesh allows you to create systems where you stream new navigation data in and out as the player progresses the level, or you may regenerate tiles as the world changes. 
+Detour offers a simple static navmesh data representation which is suitable for many simple cases.  It also provides a tiled navigation mesh representation, which allows you to stream of navigation data in and out as the player progresses through the world and regenerate sections of the navmesh data as the world changes.
 
-## Recast Demo
+## RecastDemo
 
-You can find a comprehensive demo project in RecastDemo folder. It is a kitchen sink demo containing all the functionality of the library. If you are new to Recast & Detour, check out [Sample_SoloMesh.cpp](/RecastDemo/Source/Sample_SoloMesh.cpp) to get started with building navmeshes and [NavMeshTesterTool.cpp](/RecastDemo/Source/NavMeshTesterTool.cpp) to see how Detour can be used to find paths.
+You can find a comprehensive demo project in the `RecastDemo` folder. It's a kitchen sink demo showcasing all the functionality of the library. If you are new to Recast & Detour, check out [Sample_SoloMesh.cpp](/RecastDemo/Source/Sample_SoloMesh.cpp) to get started with building navmeshes and [NavMeshTesterTool.cpp](/RecastDemo/Source/NavMeshTesterTool.cpp) to see how Detour can be used to find paths.
 
 ### Building RecastDemo
 
@@ -65,11 +64,11 @@ RecastDemo uses [premake5](http://premake.github.io/) to build platform specific
 - Build the "Tests" project.  This will generate an executable named "Tests" in `RecastDemo/Bin/`
 - Run the "Tests" executable.  It will execute all the unit tests, indicate those that failed, and display a count of those that succeeded.
 
-## Integrating with your own project
+## Integrating with your game or engine
 
 It is recommended to add the source directories `DebugUtils`, `Detour`, `DetourCrowd`, `DetourTileCache`, and `Recast` into your own project depending on which parts of the project you need. For example your level building tool could include `DebugUtils`, `Recast`, and `Detour`, and your game runtime could just include `Detour`.
 
-### Installation through vcpkg
+### Install through vcpkg
 
 If you are using the [vcpkg](https://github.com/Microsoft/vcpkg/) dependency manager you can download and install Recast with:
 

From 04ea2a57b14fe3132784a7f553e64733f1541547 Mon Sep 17 00:00:00 2001
From: Graham Pentheny <grahamboree@users.noreply.github.com>
Date: Fri, 25 Nov 2022 21:45:32 -0500
Subject: [PATCH 51/51] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index f1878b285..1de41e8e9 100644
--- a/README.md
+++ b/README.md
@@ -13,7 +13,7 @@ Recast is state of the art navigation mesh construction toolset for games.
 
 Recast is...
 * 🤖 **Automatic** - throw any level geometry at it and you will get a robust navmesh out
-* 💨 **Fast** - swift turnaround times for level designers
+* 🏎️ **Fast** - swift turnaround times for level designers
 * 🧘 **Flexible** - easily customize the navmesh generation and runtime navigation systems to suit your specific game's needs.
 
 Recast constructs a navmesh through a multi-step rasterization process: