dev build 4

Updated release notes
Don't use console colour if running in XCode
2025-09-14 09:25:40 +02:00 · 2017-09-19 17:42:20 +01:00 · 2017-09-19 17:36:20 +01:00 · 2017-09-19 15:25:33 +01:00 · 2017-09-19 14:59:12 +01:00 · 2017-09-19 14:38:18 +01:00
183 changed files with 4851 additions and 3521 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -85,16 +85,9 @@ CheckFileList(TEST_SOURCES ${SELF_TEST_DIR})
 set(SURROGATE_SOURCES
        ${SELF_TEST_DIR}/SurrogateCpps/catch_console_colour.cpp
        ${SELF_TEST_DIR}/SurrogateCpps/catch_debugger.cpp
-        ${SELF_TEST_DIR}/SurrogateCpps/catch_interfaces_capture.cpp
-        ${SELF_TEST_DIR}/SurrogateCpps/catch_interfaces_config.cpp
-        ${SELF_TEST_DIR}/SurrogateCpps/catch_interfaces_exception.cpp
-        ${SELF_TEST_DIR}/SurrogateCpps/catch_interfaces_registry_hub.cpp
        ${SELF_TEST_DIR}/SurrogateCpps/catch_interfaces_reporter.cpp
-        ${SELF_TEST_DIR}/SurrogateCpps/catch_interfaces_runner.cpp
-        ${SELF_TEST_DIR}/SurrogateCpps/catch_interfaces_testcase.cpp
        ${SELF_TEST_DIR}/SurrogateCpps/catch_option.cpp
        ${SELF_TEST_DIR}/SurrogateCpps/catch_stream.cpp
-        ${SELF_TEST_DIR}/SurrogateCpps/catch_streambuf.cpp
        ${SELF_TEST_DIR}/SurrogateCpps/catch_test_case_tracker.cpp
        ${SELF_TEST_DIR}/SurrogateCpps/catch_test_spec.cpp
        ${SELF_TEST_DIR}/SurrogateCpps/catch_xmlwriter.cpp
@@ -105,7 +98,6 @@ CheckFileList(SURROGATE_SOURCES ${SELF_TEST_DIR}/SurrogateCpps)
 # Please keep these ordered alphabetically
 set(TOP_LEVEL_HEADERS
        ${HEADER_DIR}/catch.hpp
-        ${HEADER_DIR}/catch_session.hpp
        ${HEADER_DIR}/catch_with_main.hpp
        )
 CheckFileList(TOP_LEVEL_HEADERS ${HEADER_DIR})
@@ -119,25 +111,27 @@ CheckFileList(EXTERNAL_HEADERS ${HEADER_DIR}/external)

 # Please keep these ordered alphabetically
 set(INTERNAL_HEADERS
-        ${HEADER_DIR}/internal/catch_approx.hpp
+        ${HEADER_DIR}/internal/catch_approx.h
        ${HEADER_DIR}/internal/catch_assertionhandler.h
        ${HEADER_DIR}/internal/catch_assertioninfo.h
        ${HEADER_DIR}/internal/catch_assertionresult.h
        ${HEADER_DIR}/internal/catch_capture.hpp
        ${HEADER_DIR}/internal/catch_capture_matchers.h
        ${HEADER_DIR}/internal/catch_clara.h
-        ${HEADER_DIR}/internal/catch_commandline.hpp
+        ${HEADER_DIR}/internal/catch_commandline.h
        ${HEADER_DIR}/internal/catch_common.h
        ${HEADER_DIR}/internal/catch_compiler_capabilities.h
        ${HEADER_DIR}/internal/catch_config.hpp
-        ${HEADER_DIR}/internal/catch_console_colour.hpp
+        ${HEADER_DIR}/internal/catch_console_colour.h
        ${HEADER_DIR}/internal/catch_context.h
+        ${HEADER_DIR}/internal/catch_debug_console.h
        ${HEADER_DIR}/internal/catch_debugger.h
        ${HEADER_DIR}/internal/catch_decomposer.h
        ${HEADER_DIR}/internal/catch_default_main.hpp
        ${HEADER_DIR}/internal/catch_enforce.h
        ${HEADER_DIR}/internal/catch_errno_guard.h
        ${HEADER_DIR}/internal/catch_exception_translator_registry.h
+        ${HEADER_DIR}/internal/catch_external_interfaces.h
        ${HEADER_DIR}/internal/catch_fatal_condition.h
        ${HEADER_DIR}/internal/catch_impl.hpp
        ${HEADER_DIR}/internal/catch_interfaces_capture.h
@@ -150,23 +144,24 @@ set(INTERNAL_HEADERS
        ${HEADER_DIR}/internal/catch_interfaces_testcase.h
        ${HEADER_DIR}/internal/catch_leak_detector.h
        ${HEADER_DIR}/internal/catch_list.h
-        ${HEADER_DIR}/internal/catch_matchers.hpp
+        ${HEADER_DIR}/internal/catch_matchers.h
        ${HEADER_DIR}/internal/catch_matchers_string.h
        ${HEADER_DIR}/internal/catch_matchers_vector.h
        ${HEADER_DIR}/internal/catch_message.h
-        ${HEADER_DIR}/internal/catch_notimplemented_exception.h
        ${HEADER_DIR}/internal/catch_objc.hpp
        ${HEADER_DIR}/internal/catch_objc_arc.hpp
        ${HEADER_DIR}/internal/catch_option.hpp
        ${HEADER_DIR}/internal/catch_platform.h
+        ${HEADER_DIR}/internal/catch_random_number_generator.h
        ${HEADER_DIR}/internal/catch_reenable_warnings.h
        ${HEADER_DIR}/internal/catch_reporter_registrars.hpp
-        ${HEADER_DIR}/internal/catch_reporter_registry.hpp
+        ${HEADER_DIR}/internal/catch_reporter_registry.h
        ${HEADER_DIR}/internal/catch_result_type.h
-        ${HEADER_DIR}/internal/catch_run_context.hpp
+        ${HEADER_DIR}/internal/catch_run_context.h
        ${HEADER_DIR}/internal/catch_benchmark.h
        ${HEADER_DIR}/internal/catch_section.h
        ${HEADER_DIR}/internal/catch_section_info.h
+        ${HEADER_DIR}/internal/catch_session.h
        ${HEADER_DIR}/internal/catch_startup_exception_registry.h
        ${HEADER_DIR}/internal/catch_stream.h
        ${HEADER_DIR}/internal/catch_streambuf.h
@@ -177,19 +172,19 @@ set(INTERNAL_HEADERS
        ${HEADER_DIR}/internal/catch_tag_alias_autoregistrar.h
        ${HEADER_DIR}/internal/catch_tag_alias_registry.h
        ${HEADER_DIR}/internal/catch_test_case_info.h
-        ${HEADER_DIR}/internal/catch_test_case_registry_impl.hpp
-        ${HEADER_DIR}/internal/catch_test_case_tracker.hpp
-        ${HEADER_DIR}/internal/catch_test_registry.hpp
-        ${HEADER_DIR}/internal/catch_test_spec.hpp
-        ${HEADER_DIR}/internal/catch_test_spec_parser.hpp
+        ${HEADER_DIR}/internal/catch_test_case_registry_impl.h
+        ${HEADER_DIR}/internal/catch_test_case_tracker.h
+        ${HEADER_DIR}/internal/catch_test_registry.h
+        ${HEADER_DIR}/internal/catch_test_spec.h
+        ${HEADER_DIR}/internal/catch_test_spec_parser.h
        ${HEADER_DIR}/internal/catch_text.h
        ${HEADER_DIR}/internal/catch_timer.h
        ${HEADER_DIR}/internal/catch_tostring.h
-        ${HEADER_DIR}/internal/catch_totals.hpp
+        ${HEADER_DIR}/internal/catch_totals.h
        ${HEADER_DIR}/internal/catch_version.h
-        ${HEADER_DIR}/internal/catch_wildcard_pattern.hpp
+        ${HEADER_DIR}/internal/catch_wildcard_pattern.h
        ${HEADER_DIR}/internal/catch_windows_h_proxy.h
-        ${HEADER_DIR}/internal/catch_xmlwriter.hpp
+        ${HEADER_DIR}/internal/catch_xmlwriter.h
        )
 set(IMPL_SOURCES
        ${HEADER_DIR}/internal/catch_approx.cpp
@@ -202,25 +197,35 @@ set(IMPL_SOURCES
        ${HEADER_DIR}/internal/catch_config.cpp
        ${HEADER_DIR}/internal/catch_console_colour.cpp
        ${HEADER_DIR}/internal/catch_context.cpp
+        ${HEADER_DIR}/internal/catch_debug_console.cpp
        ${HEADER_DIR}/internal/catch_debugger.cpp
        ${HEADER_DIR}/internal/catch_decomposer.cpp
        ${HEADER_DIR}/internal/catch_errno_guard.cpp
        ${HEADER_DIR}/internal/catch_exception_translator_registry.cpp
        ${HEADER_DIR}/internal/catch_fatal_condition.cpp
+        ${HEADER_DIR}/internal/catch_interfaces_capture.cpp
+        ${HEADER_DIR}/internal/catch_interfaces_config.cpp
+        ${HEADER_DIR}/internal/catch_interfaces_exception.cpp
+        ${HEADER_DIR}/internal/catch_interfaces_registry_hub.cpp
+        ${HEADER_DIR}/internal/catch_interfaces_runner.cpp
+        ${HEADER_DIR}/internal/catch_interfaces_testcase.cpp
        ${HEADER_DIR}/internal/catch_list.cpp
        ${HEADER_DIR}/internal/catch_leak_detector.cpp
        ${HEADER_DIR}/internal/catch_matchers.cpp
        ${HEADER_DIR}/internal/catch_matchers_string.cpp
        ${HEADER_DIR}/internal/catch_message.cpp
-        ${HEADER_DIR}/internal/catch_notimplemented_exception.cpp
        ${HEADER_DIR}/internal/catch_registry_hub.cpp
        ${HEADER_DIR}/internal/catch_interfaces_reporter.cpp
+        ${HEADER_DIR}/internal/catch_random_number_generator.cpp
+        ${HEADER_DIR}/internal/catch_reporter_registry.cpp
        ${HEADER_DIR}/internal/catch_result_type.cpp
        ${HEADER_DIR}/internal/catch_run_context.cpp
        ${HEADER_DIR}/internal/catch_section.cpp
        ${HEADER_DIR}/internal/catch_section_info.cpp
+        ${HEADER_DIR}/internal/catch_session.cpp
        ${HEADER_DIR}/internal/catch_startup_exception_registry.cpp
        ${HEADER_DIR}/internal/catch_stream.cpp
+        ${HEADER_DIR}/internal/catch_streambuf.cpp
        ${HEADER_DIR}/internal/catch_stringref.cpp
        ${HEADER_DIR}/internal/catch_string_manip.cpp
        ${HEADER_DIR}/internal/catch_tag_alias.cpp
@@ -294,8 +299,13 @@ if (NOT NO_SELFTEST)

    # Add desired warnings
    if ( CMAKE_CXX_COMPILER_ID MATCHES "Clang|AppleClang|GNU" )
-        target_compile_options( SelfTest PRIVATE -Wall -Wextra )
-        target_compile_options( Benchmark PRIVATE -Wall -Wextra )
+        target_compile_options( SelfTest PRIVATE -Wall -Wextra -Wunreachable-code )
+        target_compile_options( Benchmark PRIVATE -Wall -Wextra -Wunreachable-code )
+    endif()
+    # Clang specific warning go here
+    if ( CMAKE_CXX_COMPILER_ID MATCHES "Clang" )
+        # Actually keep these
+        target_compile_options( SelfTest PRIVATE -Wweak-vtables -Wexit-time-destructors -Wglobal-constructors -Wmissing-noreturn )
    endif()
    if ( CMAKE_CXX_COMPILER_ID MATCHES "MSVC" )
        target_compile_options( SelfTest PRIVATE /W4 /w44265 /WX )
@@ -313,6 +323,9 @@ if (NOT NO_SELFTEST)
    add_test(NAME ListTags COMMAND SelfTest --list-tags)
    set_tests_properties(ListTags PROPERTIES PASS_REGULAR_EXPRESSION "[0-9]+ tags")

+    # AppVeyor has a Python 2.7 in path, but doesn't have .py files as autorunnable
+    add_test(NAME ApprovalTests COMMAND python ${CMAKE_CURRENT_SOURCE_DIR}/scripts/approvalTests.py $<TARGET_FILE:SelfTest>)
+    set_tests_properties(ApprovalTests PROPERTIES FAIL_REGULAR_EXPRESSION "Results differed")
 endif() # !NO_SELFTEST


--- a/README.md
+++ b/README.md
@@ -1,3 +1,4 @@
+<a id="top"></a>
 ![catch logo](catch-logo-small.png)

 [![Github Releases](https://img.shields.io/github/release/philsquared/catch.svg)](https://github.com/philsquared/catch/releases)
@@ -17,11 +18,11 @@ extensions may require additional headers.
 ## How to use it
 This documentation comprises these three parts:

-* [Why do we need yet another C++ Test Framework?](docs/why-catch.md)
-* [Tutorial](docs/tutorial.md) - getting started
-* [Reference section](docs/Readme.md) - all the details
+* [Why do we need yet another C++ Test Framework?](docs/why-catch.md#top)
+* [Tutorial](docs/tutorial.md#top) - getting started
+* [Reference section](docs/Readme.md#top) - all the details

 ## More
 * Issues and bugs can be raised on the [Issue tracker on GitHub](https://github.com/philsquared/Catch/issues)
 * For discussion or questions please use [the dedicated Google Groups forum](https://groups.google.com/forum/?fromgroups#!forum/catch-forum)
-* See [who else is using Catch](docs/opensource-users.md)
+* See [who else is using Catch](docs/opensource-users.md#top)
--- a/conanfile.py
+++ b/conanfile.py
@@ -4,7 +4,7 @@ from conans import ConanFile

 class CatchConan(ConanFile):
    name = "Catch"
-    version = "1.9.6"
+    version = "2.0.0-develop.4"
    description = "A modern, C++-native, header-only, framework for unit-tests, TDD and BDD"
    author = "philsquared"
    generators = "cmake"
--- a/docs/Readme.md
+++ b/docs/Readme.md
@@ -1,30 +1,33 @@
-To get the most out of Catch, start with the [tutorial](tutorial.md).
+<a id="top"></a>
+# Reference
+
+To get the most out of Catch, start with the [tutorial](tutorial.md#top).
 Once you're up and running consider the following reference material.

 Writing tests:
-* [Assertion macros](assertions.md)
-* [Matchers](matchers.md)
-* [Logging macros](logging.md)
-* [Test cases and sections](test-cases-and-sections.md)
-* [Test fixtures](test-fixtures.md)
-* [Reporters](reporters.md)
-* [Event Listeners](event-listeners.md)
+* [Assertion macros](assertions.md#top)
+* [Matchers](matchers.md#top)
+* [Logging macros](logging.md#top)
+* [Test cases and sections](test-cases-and-sections.md#top)
+* [Test fixtures](test-fixtures.md#top)
+* [Reporters](reporters.md#top)
+* [Event Listeners](event-listeners.md#top)

 Fine tuning:
-* [Supplying your own main()](own-main.md)
-* [Compile-time configuration](configuration.md)
-* [String Conversions](tostring.md)
+* [Supplying your own main()](own-main.md#top)
+* [Compile-time configuration](configuration.md#top)
+* [String Conversions](tostring.md#top)

 Running:
-* [Command line](command-line.md)
-* [CI and Build system integration](build-systems.md)
+* [Command line](command-line.md#top)
+* [CI and Build system integration](build-systems.md#top)

 FAQ:
-* [Why are my tests slow to compile?](slow-compiles.md)
-* [Known limitations](limitations.md)
+* [Why are my tests slow to compile?](slow-compiles.md#top)
+* [Known limitations](limitations.md#top)
 
 Other:
-* [Why Catch?](why-catch.md)
-* [Open Source Projects using Catch](opensource-users.md)
-* [Contributing](contributing.md)
-* [Release Notes](release-notes.md)
+* [Why Catch?](why-catch.md#top)
+* [Open Source Projects using Catch](opensource-users.md#top)
+* [Contributing](contributing.md#top)
+* [Release Notes](release-notes.md#top)
--- a/docs/assertions.md
+++ b/docs/assertions.md
@@ -1,5 +1,12 @@
+<a id="top"></a>
 # Assertion Macros

+**Contents**  
+[Natural Expressions](#natural-expressions)  
+[Exceptions](#exceptions)  
+[Matcher expressions](#matcher-expressions)  
+[Thread Safety](#thread-safety)  
+
 Most test frameworks have a large collection of assertion macros to capture all possible conditional forms (```_EQUALS```, ```_NOTEQUALS```, ```_GREATER_THAN``` etc).

 Catch is different. Because it decomposes natural C-style conditional expressions most of these forms are reduced to one or two that you will use all the time. That said there are a rich set of auxilliary macros as well. We'll describe all of these here.
@@ -131,7 +138,7 @@ REQUIRE_NOTHROW([&](){

 ## Matcher expressions

-To support Matchers a slightly different form is used. Matchers have [their own documentation](matchers.md).
+To support Matchers a slightly different form is used. Matchers have [their own documentation](matchers.md#top).

 * **REQUIRE_THAT(** _lhs_, _matcher expression_ **)** and  
 * **CHECK_THAT(** _lhs_, _matcher expression_ **)**  
@@ -145,4 +152,4 @@ For more details, along with workarounds, see the section on [the limitations pa

 ---

-[Home](Readme.md)
+[Home](Readme.md#top)
--- a/docs/build-systems.md
+++ b/docs/build-systems.md
@@ -1,14 +1,15 @@
+<a id="top"></a>
 # CI and build system integration

 Build Systems may refer to low-level tools, like CMake, or larger systems that run on servers, like Jenkins or TeamCity. This page will talk about both.

-# Continuous Integration systems
+## Continuous Integration systems

 Probably the most important aspect to using Catch with a build server is the use of different reporters. Catch comes bundled with three reporters that should cover the majority of build servers out there - although adding more for better integration with some is always a possibility (currently we also offer TeamCity, TAP and Automake reporters).

 Two of these reporters are built in (XML and JUnit) and the third (TeamCity) is included as a separate header. It's possible that the other two may be split out in the future too - as that would make the core of Catch smaller for those that don't need them.

-## XML Reporter
+### XML Reporter
 ```-r xml``` 

 The XML Reporter writes in an XML format that is specific to Catch. 
@@ -17,7 +18,7 @@ The advantage of this format is that it corresponds well to the way Catch works

 The disadvantage is that, being specific to Catch, no existing build servers understand the format natively. It can be used as input to an XSLT transformation that could covert it to, say, HTML - although this loses the streaming advantage, of course.

-## JUnit Reporter
+### JUnit Reporter
 ```-r junit```

 The JUnit Reporter writes in an XML format that mimics the JUnit ANT schema.
@@ -52,9 +53,9 @@ The Automake Reporter writes out the [meta tags](https://www.gnu.org/software/au

 Because of the incremental nature of Catch's test suites and ability to run specific tests, our implementation of TAP reporter writes out the number of tests in a suite last.

-# Low-level tools
+## Low-level tools

-## CMake
+### CMake

 In general we recommend "vendoring" Catch's single-include releases inside your own repository. If you do this, the following example shows a minimal CMake project:
 ```CMake
@@ -140,4 +141,4 @@ If you are using GCOV tool to get testing coverage of your code, and are not sur

 ---

-[Home](Readme.md)
+[Home](Readme.md#top)
--- a/docs/command-line.md
+++ b/docs/command-line.md
@@ -1,3 +1,30 @@
+<a id="top"></a>
+# Command line
+
+**Contents**  
+[Specifying which tests to run](#specifying-which-tests-to-run)  
+[Choosing a reporter to use](#choosing-a-reporter-to-use)  
+[Breaking into the debugger](#breaking-into-the-debugger)  
+[Showing results for successful tests](#showing-results-for-successful-tests)  
+[Aborting after a certain number of failures](#aborting-after-a-certain-number-of-failures)  
+[Listing available tests, tags or reporters](#listing-available-tests-tags-or-reporters)  
+[Sending output to a file](#sending-output-to-a-file)  
+[Naming a test run](#naming-a-test-run)  
+[Eliding assertions expected to throw](#eliding-assertions-expected-to-throw)  
+[Make whitespace visible](#make-whitespace-visible)  
+[Warnings](#warnings)  
+[Reporting timings](#reporting-timings)  
+[Load test names to run from a file](#load-test-names-to-run-from-a-file)  
+[Just test names](#just-test-names)  
+[Specify the order test cases are run](#specify-the-order-test-cases-are-run)  
+[Specify a seed for the Random Number Generator](#specify-a-seed-for-the-random-number-generator)  
+[Identify framework and version according to the libIdentify standard](#identify-framework-and-version-according-to-the-libidentify-standard)  
+[Wait for key before continuing](#wait-for-key-before-continuing)  
+[Specify multiples of clock resolution to run benchmarks for](#specify-multiples-of-clock-resolution-to-run-benchmarks-for)  
+[Usage](#usage)  
+[Specify the section to run](#specify-the-section-to-run)  
+[Filenames as tags](#filenames-as-tags)  
+
 Catch works quite nicely without any command line options at all - but for those times when you want greater control the following options are available.
 Click one of the followings links to take you straight to that option - or scroll on to browse the available options.

@@ -298,4 +325,4 @@ So, for example,  tests within the file `~\Dev\MyProject\Ferrets.cpp` would be t

 ---

-[Home](Readme.md)
+[Home](Readme.md#top)
--- a/docs/commercial-users.md
+++ b/docs/commercial-users.md
@@ -1,6 +1,7 @@
+<a id="top"></a>
 # Commercial users of Catch

-As well as [Open Source](opensource-users.md) users Catch is widely used within proprietary code bases too.
+As well as [Open Source](opensource-users.md#top) users Catch is widely used within proprietary code bases too.
 Many organisations like to keep this information internal, and that's fine, 
 but if you're more open it would be great if we could list the names of as
 many organisations as possible that use Catch somewhere in their codebase. 
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -1,22 +1,42 @@
+<a id="top"></a>
+# Compile-time configuration
+
+**Contents**  
+[main()/ implementation](#main-implementation)  
+[Prefixing Catch macros](#prefixing-catch-macros)  
+[Terminal colour](#terminal-colour)  
+[Console width](#console-width)  
+[stdout](#stdout)  
+[Other toggles](#other-toggles)  
+[Windows header clutter](#windows-header-clutter)  
+
 Catch is designed to "just work" as much as possible. For most people the only configuration needed is telling Catch which source file should host all the implementation code (```CATCH_CONFIG_MAIN```).

 Nonetheless there are still some occasions where finer control is needed. For these occasions Catch exposes a set of macros for configuring how it is built.

-#  main()/ implementation
+## main()/ implementation

 	CATCH_CONFIG_MAIN	// Designates this as implementation file and defines main()
 	CATCH_CONFIG_RUNNER	// Designates this as implementation file

 Although Catch is header only it still, internally, maintains a distinction between interface headers and headers that contain implementation. Only one source file in your test project should compile the implementation headers and this is controlled through the use of one of these macros - one of these identifiers should be defined before including Catch in *exactly one implementation file in your project*.

-#  Prefixing Catch macros
+# Reporter / Listener interfaces
+
+    CATCH_CONFIG_EXTERNAL_INTERFACES  // Brings in neccessary headers for Reporter/Listener implementation
+
+Brings in various parts of Catch that are required for user defined Reporters and Listeners. This means that new Reporters and Listeners can be defined in this file as well as in the main file.
+
+Implied by both `CATCH_CONFIG_MAIN` and `CATCH_CONFIG_RUNNER`.
+
+## Prefixing Catch macros

 	CATCH_CONFIG_PREFIX_ALL

 To keep test code clean and uncluttered Catch uses short macro names (e.g. ```TEST_CASE``` and ```REQUIRE```). Occasionally these may conflict with identifiers from platform headers or the system under test. In this case the above identifier can be defined. This will cause all the Catch user macros to be prefixed with ```CATCH_``` (e.g. ```CATCH_TEST_CASE``` and ```CATCH_REQUIRE```).


-#  Terminal colour
+## Terminal colour

 	CATCH_CONFIG_COLOUR_NONE	// completely disables all text colouring
 	CATCH_CONFIG_COLOUR_WINDOWS	// forces the Win32 console API to be used
@@ -32,14 +52,14 @@ Note that when ANSI colour codes are used "unistd.h" must be includable - along

 Typically you should place the ```#define``` before #including "catch.hpp" in your main source file - but if you prefer you can define it for your whole project by whatever your IDE or build system provides for you to do so.

-#  Console width
+## Console width

 	CATCH_CONFIG_CONSOLE_WIDTH = x // where x is a number

 Catch formats output intended for the console to fit within a fixed number of characters. This is especially important as indentation is used extensively and uncontrolled line wraps break this.
 By default a console width of 80 is assumed but this can be controlled by defining the above identifier to be a different value.

-#  stdout
+## stdout

 	CATCH_CONFIG_NOSTDOUT

@@ -53,7 +73,7 @@ This can be useful on certain platforms that do not provide the standard iostrea



-# Other toggles
+## Other toggles

    CATCH_CONFIG_COUNTER                    // Use __COUNTER__ to generate unique names for test cases
    CATCH_CONFIG_WINDOWS_SEH                // Enable SEH handling on Windows
@@ -61,6 +81,8 @@ This can be useful on certain platforms that do not provide the standard iostrea
    CATCH_CONFIG_DISABLE_MATCHERS           // Do not compile Matchers in this compilation unit
    CATCH_CONFIG_POSIX_SIGNALS              // Enable handling POSIX signals
    CATCH_CONFIG_WINDOWS_CRTDBG             // Enable leak checking using Windows's CRT Debug Heap
+    CATCH_CONFIG_DISABLE_STRINGIFICATION    // Disable stringifying the original expression
+    CATCH_CONFIG_DISABLE                    // Disables assertions and test case registration

 Currently Catch enables `CATCH_CONFIG_WINDOWS_SEH` only when compiled with MSVC, because some versions of MinGW do not have the necessary Win32 API support.

@@ -70,21 +92,29 @@ Currently Catch enables `CATCH_CONFIG_WINDOWS_SEH` only when compiled with MSVC,

 These toggles can be disabled by using `_NO_` form of the toggle, e.g. `CATCH_CONFIG_NO_WINDOWS_SEH`.

-## `CATCH_CONFIG_FAST_COMPILE`
+### `CATCH_CONFIG_FAST_COMPILE`
 Defining this flag speeds up compilation of test files by ~20%, by making 2 changes:
 * The `-b` (`--break`) flag no longer makes Catch break into debugger in the same stack frame as the failed test, but rather in a stack frame *below*.
-* The `REQUIRE` family of macros (`REQUIRE`, `REQUIRE_FALSE` and `REQUIRE_THAT`) no longer uses local try-catch block. This disables exception translation, but should not lead to false negatives.
+* Non-exception family of macros ({`REQUIRE`,`CHECK`}{`_`,`_FALSE`, `_FALSE`}, no longer use local try-cache block. This disables exception translation, but should not lead to false negatives.

 `CATCH_CONFIG_FAST_COMPILE` has to be either defined, or not defined, in all translation units that are linked into single test binary, or the behaviour of setting `-b` flag and throwing unexpected exceptions will be unpredictable.

-
-## `CATCH_CONFIG_DISABLE_MATCHERS`
+### `CATCH_CONFIG_DISABLE_MATCHERS`
 When `CATCH_CONFIG_DISABLE_MATCHERS` is defined, all mentions of Catch's Matchers are ifdef-ed away from the translation unit. Doing so will speed up compilation of that TU.

 _Note: If you define `CATCH_CONFIG_DISABLE_MATCHERS` in the same file as Catch's main is implemented, your test executable will fail to link if you use Matchers anywhere._

+### `CATCH_CONFIG_DISABLE_STRINGIFICATION`
+This toggle enables a workaround for VS 2017 bug. For details see [known limitations](limitations.md#Visual Studio 2017 -- raw string literal in assert fails to compile)

-# Windows header clutter
+### `CATCH_CONFIG_DISABLE`
+This toggle removes most of Catch from given file. This means that `TEST_CASE`s are not registered and assertions are turned into no-ops. Useful for keeping tests within implementation files (ie for functions with internal linkage), instead of in external files.
+
+This feature is considered experimental and might change at any point.
+
+_Inspired by Doctest's `DOCTEST_CONFIG_DISABLE`_
+
+## Windows header clutter

 On Windows Catch includes `windows.h`. To minimize global namespace clutter in the implementation file, it defines `NOMINMAX` and `WIN32_LEAN_AND_MEAN` before including it. You can control this behaviour via two macros:

@@ -93,4 +123,4 @@ On Windows Catch includes `windows.h`. To minimize global namespace clutter in t

 ---

-[Home](Readme.md)
+[Home](Readme.md#top)
--- a/docs/contributing.md
+++ b/docs/contributing.md
@@ -1,3 +1,4 @@
+<a id="top"></a>
 # Contributing to Catch

 So you want to contribute something to Catch? That's great! Whether it's a bug fix, a new feature, support for 
@@ -57,4 +58,4 @@ be fairly self-explanatory.

 ---

-[Home](Readme.md)
+[Home](Readme.md#top)
--- a/docs/event-listeners.md
+++ b/docs/event-listeners.md
@@ -1,3 +1,4 @@
+<a id="top"></a>
 # Event Listeners

 A `Listener` is a class you can register with Catch that will then be passed events,
@@ -12,10 +13,11 @@ so you are not forced to implement events you're not interested in.


 ## Implementing a Listener
+Simply derive a class from `Catch::TestEventListenerBase` and implement the methods you are interested in, either in
+the main source file (i.e. the one that defines `CATCH_CONFIG_MAIN` or `CATCH_CONFIG_RUNNER`), or in a
+file that defines `CATCH_CONFIG_EXTERNAL_INTERFACES`.

-In your main source file (i.e. the one that has the `#define` for `CATCH_CONFIG_MAIN` or `CATCH_CONFIG_RUNNER`),
-simply derive a class from `Catch::TestEventListenerBase` and implement the methods you are interested in.
-Then register it using `INTERNAL_CATCH_REGISTER_LISTENER`.
+Then register it using `CATCH_REGISTER_LISTENER`.

 For example:

@@ -70,4 +72,4 @@ just look in the source code to see what fields are available.

 ---

-[Home](Readme.md)
+[Home](Readme.md#top)
--- a/docs/limitations.md
+++ b/docs/limitations.md
@@ -1,7 +1,22 @@
+<a id="top"></a>
 # Known limitations

 Catch has some known limitations, that we are not planning to change. Some of these are caused by our desire to support C++98 compilers, some of these are caused by our desire to keep Catch crossplatform, some exist because their priority is seen as low compared to the development effort they would need and some other yet are compiler/runtime bugs.

+## Implementation limits
+### Sections nested in loops
+
+If you are using `SECTION`s inside loops, you have to create them with different name per loop's iteration. The recommended way to do so is to incorporate the loop's counter into section's name, like so
+```cpp
+TEST_CASE( "Looped section" ) {
+    for (char i = '0'; i < '5'; ++i) {
+        SECTION(std::string("Looped section ") + i) {
+            SUCCEED( "Everything is OK" );
+        }
+    }
+}
+```
+
 ## Features
 This section outlines some missing features, what is their status and their possible workarounds.

@@ -50,6 +65,38 @@ Both of these solutions have their problems, but should let you wring parallelis
 ## 3rd party bugs
 This section outlines known bugs in 3rd party components (this means compilers, standard libraries, standard runtimes).

+### Visual Studio 2017 -- raw string literal in assert fails to compile
+There is a known bug in Visual Studio 2017 (VC 15), that causes compilation error when preprocessor attempts to stringize a raw string literal (`#` preprocessor is applied to it). This snippet is sufficient to trigger the compilation error:
+```cpp
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"
+
+TEST_CASE("test") {
+    CHECK(std::string(R"("\)") == "\"\\");
+}
+```
+
+Catch provides a workaround, it is possible to disable stringification of original expressions by defining `CATCH_CONFIG_DISABLE_STRINGIFICATION`:
+```cpp
+#define CATCH_CONFIG_FAST_COMPILE
+#define CATCH_CONFIG_DISABLE_STRINGIFICATION
+#include "catch.hpp"
+
+TEST_CASE("test") {
+    CHECK(std::string(R"("\)") == "\"\\");
+}
+```
+
+_Do note that this changes the output somewhat_
+```
+catchwork\test1.cpp(6):
+PASSED:
+  CHECK( Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION )
+with expansion:
+  ""\" == ""\"
+```
+
+
 ### Visual Studio 2013 -- do-while loop withing range based for fails to compile (C2059)
 There is a known bug in Visual Studio 2013 (VC 12), that causes compilation error if range based for is followed by an assertion macro, without enclosing the block in braces. This snippet is sufficient to trigger the error
 ```cpp
--- a/docs/logging.md
+++ b/docs/logging.md
@@ -1,3 +1,4 @@
+<a id="top"></a>
 # Logging macros

 Additional messages can be logged during a test case. Note that the messages are scoped and thus will not be reported if failure occurs in scope preceding the message declaration. An example:
@@ -79,4 +80,4 @@ These macros are now deprecated and are just aliases for INFO and CAPTURE (which

 ---

-[Home](Readme.md)
+[Home](Readme.md#top)
--- a/docs/matchers.md
+++ b/docs/matchers.md
@@ -1,3 +1,4 @@
+<a id="top"></a>
 # Matchers

 Matchers are an alternative way to do assertions which are easily extensible and composable.
@@ -101,4 +102,4 @@ with expansion:

 ---

-[Home](Readme.md)
+[Home](Readme.md#top)
--- a/docs/opensource-users.md
+++ b/docs/opensource-users.md
@@ -1,3 +1,4 @@
+<a id="top"></a>
 # Open Source projects using Catch

 Catch is great for open source. With it's [liberal license](../LICENSE.txt) and single-header, dependency-free, distribution 
@@ -25,6 +26,9 @@ The core part of the Chakra Javascript engine that powers Microsoft Edge
 ### [ChaiScript](https://github.com/ChaiScript/ChaiScript)
 A, header-only, embedded scripting language designed from the ground up to directly target C++ and take advantage of modern C++ development techniques

+### [Clara](https://github.com/philsquared/Clara)
+A, single-header-only, type-safe, command line parser - which also prints formatted usage strings.
+
 ### [Couchbase-lite-core](https://github.com/couchbase/couchbase-lite-core)
 The next-generation core storage and query engine for Couchbase Lite/

@@ -52,6 +56,9 @@ A C++ client library for Consul. Consul is a distributed tool for discovering an
 ### [Reactive-Extensions/ RxCpp](https://github.com/Reactive-Extensions/RxCpp)
 A library of algorithms for values-distributed-in-time

+### [TextFlowCpp](https://github.com/philsquared/textflowcpp)
+A small, single-header-only, library for wrapping and composing columns of text
+
 ### [Trompeloeil](https://github.com/rollbear/trompeloeil)
 A thread safe header only mocking framework for C++14

@@ -77,4 +84,4 @@ Standardese aims to be a nextgen Doxygen

 ---

-[Home](Readme.md)
+[Home](Readme.md#top)
--- a/docs/own-main.md
+++ b/docs/own-main.md
@@ -1,3 +1,4 @@
+<a id="top"></a>
 # Supplying main() yourself

 The easiest way to use Catch is to let it supply ```main()``` for you and handle configuring itself from the command line.
@@ -83,4 +84,4 @@ Catch embeds a powerful command line parser which you can also use to parse your

 ---

-[Home](Readme.md)
+[Home](Readme.md#top)
--- a/docs/release-notes.md
+++ b/docs/release-notes.md
@@ -1,15 +1,85 @@
-# 1.9.6
+<a id="top"></a>
+# 2.0.0 (in progress)

-### Improvements
+## Breaking changes
+* Removed C++98 support
+* Removed legacy reporter support
+* Removed legacy generator support
+  * Generator support will come back later, reworked
+* Removed `Catch::toString` support
+  * The new stringification machinery uses `Catch::StringMaker` specializations first and `operator<<` overloads second.
+* Removed legacy `SCOPED_MSG` and `SCOPED_INFO` macros
+* Removed `INTERNAL_CATCH_REGISTER_REPORTER`
+  * `CATCH_REGISTER_REPORTER` should be used to register reporters
+* Removed legacy `[hide]` tag
+  * `[.]`, `[.foo]` and `[!hide]` are still supported
+* Output into debugger is now colourized
+* `*_THROWS_AS(expr, exception_type)` now unconditionally appends `const&` to the exception type.
+* `CATCH_CONFIG_FAST_COMPILE` now affects the `CHECK_` family of assertions as well as `REQUIRE_` family of assertions
+  * This is most noticeable in `CHECK(throws())`, which would previously report failure, properly stringify the exception and continue. Now it will report failure and stop executing current section.
+* Removed deprecated matcher utility functions `Not`, `AllOf` and `AnyOf`.
+  * They are superseded by operators `!`, `&&` and `||`, which are natural and do not have limited arity
+* No longer accept non-const comparison operators
+
+
+## Improvements
+* Reporters and Listeners can be defined in files different from the main file
+  * The file has to define `CATCH_CONFIG_EXTERNAL_INTERFACES` before including catch.hpp.
+* Errors that happen during set up before main are now caught and properly reported once main is entered
+  * If you are providing your own main, you can access and use these as well.
+* New assertion macros, *_THROWS_WITH(expr, exception_type, matcher) are provided
+  * As the arguments suggest, these allow you to assert that an expression throws desired type of exception and pass the exception to a matcher.
+* JUnit reporter no longer has significantly different output for test cases with and without sections
+* Most assertions now support expressions containing commas (ie `REQUIRE(foo() == std::vector<int>{1, 2, 3});`)
+* Catch now contains experimental micro benchmarking support
+  * See `projects/SelfTest/Benchmark.tests.cpp` for examples
+  * The support being experiment means that it can be changed without prior notice
+* Catch uses new CLI parsing library (Clara)
+  * Users can now easily add new command line options to the final executable
+  * This also leads to some changes in `Catch::Session` interface
+* All parts of matchers can be removed from a TU by defining `CATCH_CONFIG_DISABLE_MATCHERS`
+  * This can be used to somewhat speed up compilation times
+* An experimental implementation of `CATCH_CONFIG_DISABLE` has been added
+  * Inspired by Doctest's `DOCTEST_CONFIG_DISABLE`
+  * Useful for implementing tests in source files
+    * ie for functions in anonymous namespaces
+  * Removes all assertions
+  * Prevents `TEST_CASE` registrations
+  * Exception translators are not registered
+  * Reporters are not registered
+  * Listeners are not registered
+* More warnings are silenced
+* Don't use console colour if running in XCode
+
+## Fixes
+* Explicit constructor in reporter base class
+* Many fixes for building in Objective-C context
+* Do not use SEH and console api under UWP
+
+## Internal changes
+* The development version now uses .cpp files instead of header files containing implementation.
+  * This makes partial rebuilds much faster during development
+* The expression decomposition layer has been rewritten
+* The evaluation layer has been rewritten
+* New library (TextFlow) is used for formatting text to output
+
+
+# Older versions
+
+## 1.9.x
+
+### 1.9.6
+
+#### Improvements
 * Catch's runtime overhead has been significantly decreased (#937, #939)
 * Added `--list-extra-info` cli option (#934).
  * It lists all tests together with extra information, ie filename, line number and description.



-# 1.9.5
+### 1.9.5

-### Fixes
+#### Fixes
 * Truthy expressions are now reconstructed properly, not as booleans (#914)
 * Various warnings are no longer erroneously suppressed in test files (files that include `catch.hpp`, but do not define `CATCH_CONFIG_MAIN` or `CATCH_CONFIG_RUNNER`) (#871)
 * Catch no longer fails to link when main is compiled as C++, but linked against Objective-C (#855)
@@ -17,35 +87,35 @@
  * Previously any GCC with minor version less than 3 would be incorrectly classified as not supporting `__COUNTER__`.
 * Suppressed C4996 warning caused by upcoming updated to MSVC 2017, marking `std::uncaught_exception` as deprecated. (#927)

-### Improvements
+#### Improvements
 * CMake integration script now incorporates debug messages and registers tests in an improved way (#911)
 * Various documentation improvements



-# 1.9.4
+### 1.9.4

-### Fixes
+#### Fixes
 * `CATCH_FAIL` macro no longer causes compilation error without variadic macro support
 * `INFO` messages are no longer cleared after being reported once

-### Improvements and minor changes
+#### Improvements and minor changes
 * Catch now uses `wmain` when compiled under Windows and `UNICODE` is defined.
  * Note that Catch still officially supports only ASCII

-# 1.9.3
+### 1.9.3

-### Fixes
+#### Fixes
 * Completed the fix for (lack of) uint64_t in earlier Visual Studios

-# 1.9.2
+### 1.9.2

-### Improvements and minor changes
+#### Improvements and minor changes
 * All of `Approx`'s member functions now accept strong typedefs in C++11 mode (#888)
  * Previously `Approx::scale`, `Approx::epsilon`, `Approx::margin` and `Approx::operator()` didn't.


-### Fixes
+#### Fixes
 * POSIX signals are now disabled by default under QNX (#889)
  * QNX does not support current enough (2001) POSIX specification
 * JUnit no longer counts exceptions as failures if given test case is marked as ok to fail.
@@ -53,22 +123,22 @@
 * Catch no longer attempts to define `uint64_t` on windows (#862)
  * This was causing trouble when compiled under Cygwin

-### Other
+#### Other
 * Catch is now compiled under MSVC 2017 using `std:c++latest` (C++17 mode) in CI
 * We now provide cmake script that autoregisters Catch tests into ctest.
  * See `contrib` folder.


-# 1.9.1
+### 1.9.1

-### Fixes
+#### Fixes
 * Unexpected exceptions are no longer ignored by default (#885, #887)


-# 1.9.0
+### 1.9.0


-### Improvements and minor changes
+#### Improvements and minor changes
 * Catch no longer attempts to ensure the exception type passed by user in `REQUIRE_THROWS_AS` is a constant reference.
  * It was causing trouble when `REQUIRE_THROWS_AS` was used inside templated functions
  * This actually reverts changes made in v1.7.2
@@ -82,7 +152,7 @@
 * When Catch is compiled using C++11, `Approx` is now constructible with anything that can be explicitly converted to `double`.
 * Captured messages are now printed on unexpected exceptions

-### Fixes:
+#### Fixes:
 * Clang's `-Wexit-time-destructors` should be suppressed for Catch's internals
 * GCC's `-Wparentheses` is now suppressed for all TU's that include `catch.hpp`.
  * This is functionally a revert of changes made in 1.8.0, where we tried using `_Pragma` based suppression. This should have kept the suppression local to Catch's assertions, but bugs in GCC's handling of `_Pragma`s in C++ mode meant that it did not always work.
@@ -91,16 +161,18 @@
  * [Details can be found in documentation](configuration.md#catch_config_cpp11_stream_insertable_check)


-### Other notes:
+#### Other notes:
 * We have added VS 2017 to our CI
 * Work on Catch 2 should start soon



-# 1.8.2
+## 1.8.x
+
+### 1.8.2


-### Improvements and minor changes
+#### Improvements and minor changes
 * TAP reporter now behaves as if `-s` was always set
  * This should be more consistent with the protocol desired behaviour.
 * Compact reporter now obeys `-d yes` argument (#780)
@@ -110,11 +182,11 @@
  * This means it reports `INFO` messages on success, if output on success (`-s`) is enabled.
  * Previously it only reported `INFO` messages on failure.
 * `CAPTURE(expr)` now stringifies `expr` in the same way assertion macros do (#639)
-* Listeners are now finally [documented](event-listeners.md).
+* Listeners are now finally [documented](event-listeners.md#top).
  * Listeners provide a way to hook into events generated by running your tests, including start and end of run, every test case, every section and every assertion.


-### Fixes:
+#### Fixes:
 * Catch no longer attempts to reconstruct expression that led to a fatal error  (#810)
  * This fixes possible signal/SEH loop when processing expressions, where the signal was triggered by expression decomposition.
 * Fixed (C4265) missing virtual destructor warning in Matchers (#844)
@@ -131,25 +203,25 @@
 * Regression in Objective-C bindings (Matchers) fixed (#854)


-### Other notes:
+#### Other notes:
 * We have added VS 2013 and 2015 to our CI
 * Catch Classic (1.x.x) now contains its own, forked, version of Clara (the argument parser).



-# 1.8.1
+### 1.8.1

-### Fixes
+#### Fixes

 Cygwin issue with `gettimeofday` - `#define` was not early enough

-# 1.8.0
+### 1.8.0

-### New features/ minor changes
+#### New features/ minor changes

 * Matchers have new, simpler (and documented) interface.
  * Catch provides string and vector matchers.
-  * For details see [Matchers documentation](matchers.md).
+  * For details see [Matchers documentation](matchers.md#top).
 * Changed console reporter test duration reporting format (#322)
  * Old format: `Some simple comparisons between doubles completed in 0.000123s`
  * New format: `xxx.123s: Some simple comparisons between doubles` _(There will always be exactly 3 decimal places)_
@@ -160,12 +232,12 @@ Cygwin issue with `gettimeofday` - `#define` was not early enough
  * _More changes are coming_
 * Added [TAP (Test Anything Protocol)](https://testanything.org/) and [Automake](https://www.gnu.org/software/automake/manual/html_node/Log-files-generation-and-test-results-recording.html#Log-files-generation-and-test-results-recording) reporters.
  * These are not present in the default single-include header and need to be downloaded from GitHub separately.
-  * For details see [documentation about integrating with build systems](build-systems.md).
+  * For details see [documentation about integrating with build systems](build-systems.md#top).
 *  XML reporter now reports filename as part of the `Section` and `TestCase` tags.
 * `Approx` now supports an optional margin of absolute error
-  * It has also received [new documentation](assertions.md).
+  * It has also received [new documentation](assertions.md#top).

-### Fixes
+#### Fixes
 * Silenced C4312 ("conversion from int to 'ClassName *") warnings in the evaluate layer.
 * Fixed C4512 ("assignment operator could not be generated") warnings under VS2013.
 * Cygwin compatibility fixes
@@ -176,13 +248,15 @@ Cygwin issue with `gettimeofday` - `#define` was not early enough
  * Otherwise it is supressed for the whole TU
 * Fixed test spec parser issue (with escapes in multiple names)

-### Other
+#### Other
 * Various documentation fixes and improvements


-# 1.7.2
+## 1.7.x

-### Fixes and minor improvements
+### 1.7.2
+
+#### Fixes and minor improvements
 Xml:

 (technically the first two are breaking changes but are also fixes and arguably break few if any people)
@@ -201,26 +275,26 @@ Other:
 * Silenced a few more warnings in different circumstances
 * Travis improvements

-# 1.7.1
+### 1.7.1

-### Fixes:
+#### Fixes:
 * Fixed inconsistency in defining `NOMINMAX` and `WIN32_LEAN_AND_MEAN` inside `catch.hpp`.
 * Fixed SEH-related compilation error under older MinGW compilers, by making Windows SEH handling opt-in for compilers other than MSVC.
-  * For specifics, look into the [documentation](configuration.md).
+  * For specifics, look into the [documentation](configuration.md#top).
 * Fixed compilation error under MinGW caused by improper compiler detection.
 * Fixed XML reporter sometimes leaving an empty output file when a test ends with signal/structured exception.
 * Fixed XML reporter not reporting captured stdout/stderr.
 * Fixed possible infinite recursion in Windows SEH.
 * Fixed possible compilation error caused by Catch's operator overloads being ambiguous in regards to user-defined templated operators.

-## 1.7.0
+### 1.7.0

-### Features/ Changes:
+#### Features/ Changes:
 * Catch now runs significantly faster for passing tests
  * Microbenchmark focused on Catch's overhead went from ~3.4s to ~0.7s.
  * Real world test using [JSON for Modern C++](https://github.com/nlohmann/json)'s test suite went from ~6m 25s to ~4m 14s.
 * Catch can now run specific sections within test cases.
-  * For now the support is only basic (no wildcards or tags), for details see the [documentation](command-line.md).
+  * For now the support is only basic (no wildcards or tags), for details see the [documentation](command-line.md#top).
 * Catch now supports SEH on Windows as well as signals on Linux.
  * After receiving a signal, Catch reports failing assertion and then passes the signal onto the previous handler.
 * Approx can be used to compare values against strong typedefs (available in C++11 mode only).
@@ -229,61 +303,63 @@ Other:
 * Certain characters (space, tab, etc) are now pretty printed.
  * This means that a `char c = ' '; REQUIRE(c == '\t');` would be printed as `' ' == '\t'`, instead of ` == 9`.

-### Fixes:
+#### Fixes:
 * Text formatting no longer attempts to access out-of-bounds characters under certain conditions.
 * THROW family of assertions no longer trigger `-Wunused-value` on expressions containing explicit cast.
 * Breaking into debugger under OS X works again and no longer required `DEBUG` to be defined.
 * Compilation no longer breaks under certain compiler if a lambda is used inside assertion macro.

-### Other:
+#### Other:
 * Catch's CMakeLists now defines install command.
 * Catch's CMakeLists now generates projects with warnings enabled.


-## 1.6.1
+## 1.6.x

-### Features/ Changes:
+### 1.6.1
+
+#### Features/ Changes:
 * Catch now supports breaking into debugger on Linux

-### Fixes:
+#### Fixes:
 * Generators no longer leak memory (generators are still unsupported in general)
 * JUnit reporter now reports UTC timestamps, instead of "tbd"
 * `CHECK_THAT` macro is now properly defined as `CATCH_CHECK_THAT` when using `CATCH_` prefixed macros

-### Other:
+#### Other:
 * Types with overloaded `&&` operator are no longer evaluated twice when used in an assertion macro.
 * The use of `__COUNTER__` is supressed when Catch is parsed by CLion
  * This change is not active when compiling a binary
 * Approval tests can now be run on Windows
 * CMake will now warn if a file is present in the `include` folder but not is not enumerated as part of the project
 * Catch now defines `NOMINMAX` and `WIN32_LEAN_AND_MEAN` before including `windows.h`
-  * This can be disabled if needed, see [documentation](configuration.md) for details.
+  * This can be disabled if needed, see [documentation](configuration.md#top) for details.


-## 1.6.0
+### 1.6.0

-### Cmake/ projects:
+#### Cmake/ projects:
 * Moved CMakeLists.txt to root, made it friendlier for CLion and generating XCode and VS projects, and removed the manually maintained XCode and VS projects.

-### Features/ Changes:
+#### Features/ Changes:
 * Approx now supports `>=` and `<=`
 * Can now use `\` to escape chars in test names on command line
 * Standardize C++11 feature toggles

-### Fixes:
+#### Fixes:
 * Blue shell colour
 * Missing argument to `CATCH_CHECK_THROWS`
 * Don't encode extended ASCII in XML
 * use `std::shuffle` on more compilers (fixes deprecation warning/error)
 * Use `__COUNTER__` more consistently (where available)

-### Other:
+#### Other:
 * Tweaks and changes to scripts - particularly for Approval test - to make them more portable


-# Older versions
+# Even Older versions
 Release notes were not maintained prior to v1.6.0, but you should be able to work them out from the Git history

 ---

-[Home](Readme.md)
+[Home](Readme.md#top)
--- a/docs/release-process.md
+++ b/docs/release-process.md
@@ -1,3 +1,4 @@
+<a id="top"></a>
 # How to release

 When enough changes have accumulated, it is time to release new version of Catch. This document describes the proces in doing so, that no steps are forgotten. Note that all referenced scripts can be found in the `scripts/` directory.
--- a/docs/reporters.md
+++ b/docs/reporters.md
@@ -1,3 +1,4 @@
+<a id="top"></a>
 # Reporters

 Catch has a modular reporting system and comes bundled with a handful of useful reporters built in.
@@ -17,7 +18,7 @@ There are four reporters built in to the single include:

 * `console` writes as lines of text, formatted to a typical terminal width, with colours if a capable terminal is detected.
 * `compact` similar to `console` but optimised for minimal output - each entry on one line
-* `junit` writes xml that corresponds to Ant's [junitreport](http://help.catchsoftware.com/display/ET/JUnit+Format) target. Useful for build systems that understand Junit. If you are using Jenkins with Catch 1.x, you can improve quality of output by applying changes in [#923](https://github.com/philsquared/Catch/pull/923).
+* `junit` writes xml that corresponds to Ant's [junitreport](http://help.catchsoftware.com/display/ET/JUnit+Format) target. Useful for build systems that understand Junit.
 Because of the way the junit format is structured the run must complete before anything is written. 
 * `xml` writes an xml format tailored to Catch. Unlike `junit` this is a streaming format so results are delivered progressively.

@@ -42,4 +43,4 @@ but do keep in mind upcoming changes (these will be minor, simplifying, changes

 ---

-[Home](Readme.md)
+[Home](Readme.md#top)
--- a/docs/slow-compiles.md
+++ b/docs/slow-compiles.md
@@ -1,5 +1,12 @@
+<a id="top"></a>
 # Why do my tests take so long to compile?

+**Contents**  
+[Short answer](#short-answer)  
+[Long answer](#long-answer)  
+[Practical example](#practical-example)  
+[Other possible solutions](#other-possible-solutions)  
+
 Several people have reported that test code written with Catch takes much longer to compile than they would expect. Why is that?

 Catch is implemented entirely in headers. There is a little overhead due to this - but not as much as you might think - and you can minimise it simply by organising your test code as follows:
@@ -18,7 +25,7 @@ Because Catch is implemented *entirely* in headers you might think that the whol
 As a result the main source file *does* compile the whole of Catch every time! So it makes sense to dedicate this file to *only* ```#define```-ing the identifier and ```#include```-ing Catch (and implementing the runner code, if you're doing that). Keep all your test cases in other files. This way you won't pay the recompilation cost for the whole of Catch 

 ## Practical example
-Assume you have the `Factorial` function from the [tutorial](tutorial.md) in `factorial.cpp` (with forward declaration in `factorial.h`) and want to test it and keep the compile times down when adding new tests. Then you should have 2 files, `tests-main.cpp` and `tests-factorial.cpp`:
+Assume you have the `Factorial` function from the [tutorial](tutorial.md#top) in `factorial.cpp` (with forward declaration in `factorial.h`) and want to test it and keep the compile times down when adding new tests. Then you should have 2 files, `tests-main.cpp` and `tests-factorial.cpp`:

 ```cpp
 // tests-main.cpp
@@ -61,4 +68,4 @@ You can also opt to sacrifice some features in order to speed-up Catch's compila

 ---

-[Home](Readme.md)
+[Home](Readme.md#top)
--- a/docs/test-cases-and-sections.md
+++ b/docs/test-cases-and-sections.md
@@ -1,3 +1,4 @@
+<a id="top"></a>
 # Test cases and sections

 While Catch fully supports the traditional, xUnit, style of class-based fixtures containing test case methods this is not the preferred style.
@@ -11,7 +12,7 @@ Test cases and sections are very easy to use in practice:

 _test name_ and _section name_ are free form, quoted, strings. The optional _tags_ argument is a quoted string containing one or more tags enclosed in square brackets. Tags are discussed below. Test names must be unique within the Catch executable.

-For examples see the [Tutorial](tutorial.md)
+For examples see the [Tutorial](tutorial.md#top)

 ## Tags

@@ -34,7 +35,7 @@ Tag names are not case sensitive and can contain any ASCII characters. This mean

 All tag names beginning with non-alphanumeric characters are reserved by Catch. Catch defines a number of "special" tags, which have meaning to the test runner itself. These special tags all begin with a symbol character. Following is a list of currently defined special tags and their meanings.

-* `[!hide]` or `[.]` (or, for legacy reasons, `[hide]`)	- causes test cases to be skipped from the default list (i.e. when no test cases have been explicitly selected through tag expressions or name wildcards). The hide tag is often combined with another, user, tag (for example `[.][integration]` - so all integration tests are excluded from the default run but can be run by passing `[integration]` on the command line). As a short-cut you can combine these by simply prefixing your user tag with a `.` - e.g. `[.integration]`. Because the hide tag has evolved to have several forms, all forms are added as tags if you use one of them.
+* `[!hide]` or `[.]` - causes test cases to be skipped from the default list (i.e. when no test cases have been explicitly selected through tag expressions or name wildcards). The hide tag is often combined with another, user, tag (for example `[.][integration]` - so all integration tests are excluded from the default run but can be run by passing `[integration]` on the command line). As a short-cut you can combine these by simply prefixing your user tag with a `.` - e.g. `[.integration]`. Because the hide tag has evolved to have several forms, all forms are added as tags if you use one of them.

 * `[!throws]`	- lets Catch know that this test is likely to throw an exception even if successful. This causes the test to be excluded when running with `-e` or `--nothrow`.

@@ -48,6 +49,8 @@ All tag names beginning with non-alphanumeric characters are reserved by Catch.

 * `[@<alias>]` - tag aliases all begin with `@` (see below).

+* `[!benchmark]` - this test case is actually a benchmark. This is an experimental feature, and currently has no documentation. If you want to try it out, look at `projects/SelfTest/Benchmark.tests.cpp` for details.
+
 ## Tag aliases

 Between tag expressions and wildcarded test names (as well as combinations of the two) quite complex patterns can be constructed to direct which test cases are run. If a complex pattern is used often it is convenient to be able to create an alias for the expression. this can be done, in code, using the following form:
@@ -85,4 +88,4 @@ Other than the additional prefixes and the formatting in the console reporter th

 ---

-[Home](Readme.md)
+[Home](Readme.md#top)
--- a/docs/test-fixtures.md
+++ b/docs/test-fixtures.md
@@ -1,3 +1,6 @@
+<a id="top"></a>
+# Test fixtures
+
 Although Catch allows you to group tests together as sections within a test case, it can still be convenient, sometimes, to group them using a more traditional test fixture. Catch fully supports this too. You define the test fixture as a simple structure:

 ```c++
@@ -29,4 +32,4 @@ The two test cases here will create uniquely-named derived classes of UniqueTest

 ---

-[Home](Readme.md)
+[Home](Readme.md#top)
--- a/docs/tostring.md
+++ b/docs/tostring.md
@@ -1,3 +1,4 @@
+<a id="top"></a>
 # String conversions

 Catch needs to be able to convert types you use in assertions and logging expressions into strings (for logging and reporting purposes).
@@ -44,4 +45,4 @@ CATCH_TRANSLATE_EXCEPTION( MyType& ex ) {

 ---

-[Home](Readme.md)
+[Home](Readme.md#top)
--- a/docs/tutorial.md
+++ b/docs/tutorial.md
@@ -1,4 +1,16 @@
-# Getting Catch
+<a id="top"></a>
+# Tutorial
+
+**Contents**  
+[Getting Catch](#getting-catch)  
+[Where to put it?](#where-to-put-it)  
+[Writing tests](#writing-tests)  
+[Test cases and sections](#test-cases-and-sections)  
+[BDD-Style](#bdd-style)  
+[Scaling up](#scaling-up)  
+[Next steps](#next-steps)  
+
+## Getting Catch

 The simplest way to get Catch is to download the latest [single header version](https://raw.githubusercontent.com/philsquared/Catch/master/single_include/catch.hpp). The single header is generated by merging a set of individual headers but it is still just normal source code in a header file.

@@ -11,7 +23,7 @@ Catch is header only. All you need to do is drop the file(s) somewhere reachable

 The rest of this tutorial will assume that the Catch single-include header (or the include folder) is available unqualified - but you may need to prefix it with a folder name if necessary.

-# Writing tests
+## Writing tests

 Let's start with a really simple example. Say you have written a function to calculate factorials and now you want to test it (let's leave aside TDD for now). 

@@ -39,7 +51,7 @@ TEST_CASE( "Factorials are computed", "[factorial]" ) {
 }
 ```

-This will compile to a complete executable which responds to [command line arguments](command-line.md). If you just run it with no arguments it will execute all test cases (in this case there is just one), report any failures, report a summary of how many tests passed and failed and return the number of failed tests (useful for if you just want a yes/ no answer to: "did it work").
+This will compile to a complete executable which responds to [command line arguments](command-line.md#top). If you just run it with no arguments it will execute all test cases (in this case there is just one), report any failures, report a summary of how many tests passed and failed and return the number of failed tests (useful for if you just want a yes/ no answer to: "did it work").

 If you run this as written it will pass. Everything is good. Right?
 Well, there is still a bug here. In fact the first version of this tutorial I posted here genuinely had the bug in! So it's not completely contrived (thanks to Daryle Walker (```@CTMacUser```) for pointing this out).
@@ -82,12 +94,12 @@ Now all the tests pass.

 Of course there are still more issues to deal with. For example we'll hit problems when the return value starts to exceed the range of an unsigned int. With factorials that can happen quite quickly. You might want to add tests for such cases and decide how to handle them. We'll stop short of doing that here.

-## What did we do here?
+### What did we do here?

 Although this was a simple test it's been enough to demonstrate a few things about how Catch is used. Let's take moment to consider those before we move on.

-1. All we did was ```#define``` one identifier and ```#include``` one header and we got everything - even an implementation of ```main()``` that will [respond to command line arguments](command-line.md). You can only use that ```#define``` in one implementation file, for (hopefully) obvious reasons. Once you have more than one file with unit tests in you'll just ```#include "catch.hpp"``` and go. Usually it's a good idea to have a dedicated implementation file that just has ```#define CATCH_CONFIG_MAIN``` and ```#include "catch.hpp"```. You can also provide your own implementation of main and drive Catch yourself (see [Supplying-your-own-main()](own-main.md)).
-2. We introduce test cases with the ```TEST_CASE``` macro. This macro takes one or two arguments - a free form test name and, optionally, one or more tags (for more see <a href="#test-cases-and-sections">Test cases and Sections</a>, ). The test name must be unique. You can run sets of tests by specifying a wildcarded test name or a tag expression. See the [command line docs](command-line.md) for more information on running tests.
+1. All we did was ```#define``` one identifier and ```#include``` one header and we got everything - even an implementation of ```main()``` that will [respond to command line arguments](command-line.md#top). You can only use that ```#define``` in one implementation file, for (hopefully) obvious reasons. Once you have more than one file with unit tests in you'll just ```#include "catch.hpp"``` and go. Usually it's a good idea to have a dedicated implementation file that just has ```#define CATCH_CONFIG_MAIN``` and ```#include "catch.hpp"```. You can also provide your own implementation of main and drive Catch yourself (see [Supplying-your-own-main()](own-main.md#top)).
+2. We introduce test cases with the ```TEST_CASE``` macro. This macro takes one or two arguments - a free form test name and, optionally, one or more tags (for more see <a href="#test-cases-and-sections">Test cases and Sections</a>, ). The test name must be unique. You can run sets of tests by specifying a wildcarded test name or a tag expression. See the [command line docs](command-line.md#top) for more information on running tests.
 3. The name and tags arguments are just strings. We haven't had to declare a function or method - or explicitly register the test case anywhere. Behind the scenes a function with a generated name is defined for you, and automatically registered using static registry classes. By abstracting the function name away we can name our tests without the constraints of identifier names.
 4. We write our individual test assertions using the ```REQUIRE``` macro. Rather than a separate macro for each type of condition we express the condition naturally using C/C++ syntax. Behind the scenes a simple set of expression templates captures the left-hand-side and right-hand-side of the expression so we can display the values in our test report. As we'll see later there _are_ other assertion macros - but because of this technique the number of them is drastically reduced.

@@ -161,7 +173,7 @@ Sections can be nested to an arbitrary depth (limited only by your stack size).

 ## BDD-Style

-If you name your test cases and sections appropriately you can achieve a BDD-style specification structure. This became such a useful way of working that first class support has been added to Catch. Scenarios can be specified using ```SCENARIO```, ```GIVEN```, ```WHEN``` and ```THEN``` macros, which map on to ```TEST_CASE```s and ```SECTION```s, respectively. For more details see [Test cases and sections](test-cases-and-sections.md).
+If you name your test cases and sections appropriately you can achieve a BDD-style specification structure. This became such a useful way of working that first class support has been added to Catch. Scenarios can be specified using ```SCENARIO```, ```GIVEN```, ```WHEN``` and ```THEN``` macros, which map on to ```TEST_CASE```s and ```SECTION```s, respectively. For more details see [Test cases and sections](test-cases-and-sections.md#top).

 The vector example can be adjusted to use these macros like so:

@@ -224,7 +236,7 @@ Scenario: vectors can be sized and resized

 To keep the tutorial simple we put all our code in a single file. This is fine to get started - and makes jumping into Catch even quicker and easier. As you write more real-world tests, though, this is not really the best approach.

-The requirement is that the following block of code ([or equivalent](own-main.md)):
+The requirement is that the following block of code ([or equivalent](own-main.md#top)):

 ```c++
 #define CATCH_CONFIG_MAIN
@@ -233,7 +245,7 @@ The requirement is that the following block of code ([or equivalent](own-main.md

 appears in _exactly one_ source file. Use as many additional cpp files (or whatever you call your implementation files) as you need for your tests, partitioned however makes most sense for your way of working. Each additional file need only ```#include "catch.hpp"``` - do not repeat the ```#define```!

-In fact it is usually a good idea to put the block with the ```#define``` [in its own source file](slow-compiles.md).
+In fact it is usually a good idea to put the block with the ```#define``` [in its own source file](slow-compiles.md#top).

 Do not write your tests in header files!

@@ -242,8 +254,8 @@ Do not write your tests in header files!

 This has been a brief introduction to get you up and running with Catch, and to point out some of the key differences between Catch and other frameworks you may already be familiar with. This will get you going quite far already and you are now in a position to dive in and write some tests.

-Of course there is more to learn - most of which you should be able to page-fault in as you go. Please see the ever-growing [Reference section](Readme.md) for what's available.
+Of course there is more to learn - most of which you should be able to page-fault in as you go. Please see the ever-growing [Reference section](Readme.md#top) for what's available.

 ---

-[Home](Readme.md)
+[Home](Readme.md#top)
--- a/docs/why-catch.md
+++ b/docs/why-catch.md
@@ -1,3 +1,4 @@
+<a id="top"></a>
 # Why do we need yet another C++ test framework?

 Good question. For C++ there are quite a number of established frameworks,
@@ -36,10 +37,10 @@ So what does Catch bring to the party that differentiates it from these? Apart f

 ## Who else is using Catch?

-See the list of [open source projects using Catch](opensource-users.md).
+See the list of [open source projects using Catch](opensource-users.md#top).

-See the [tutorial](tutorial.md) to get more of a taste of using Catch in practice 
+See the [tutorial](tutorial.md#top) to get more of a taste of using Catch in practice 

 ---

-[Home](Readme.md)
+[Home](Readme.md#top)
--- a/include/catch.hpp
+++ b/include/catch.hpp
@@ -19,8 +19,14 @@

 #if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)
 #  define CATCH_IMPL
+#  define CATCH_CONFIG_EXTERNAL_INTERFACES
+#  if defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#    undef CATCH_CONFIG_DISABLE_MATCHERS
+#  endif
 #endif

+#include "internal/catch_platform.h"
+
 #ifdef CATCH_IMPL
 #  ifndef CLARA_CONFIG_MAIN
 #    define CLARA_CONFIG_MAIN_NOT_DEFINED
@@ -28,16 +34,15 @@
 #  endif
 #endif

-#include "internal/catch_context.h"
 #include "internal/catch_tag_alias_autoregistrar.h"
-#include "internal/catch_test_registry.hpp"
+#include "internal/catch_test_registry.h"
 #include "internal/catch_capture.hpp"
 #include "internal/catch_section.h"
 #include "internal/catch_benchmark.h"
 #include "internal/catch_interfaces_exception.h"
-#include "internal/catch_approx.hpp"
+#include "internal/catch_approx.h"
 #include "internal/catch_compiler_capabilities.h"
-#include "internal/catch_interfaces_tag_alias_registry.h"
+#include "internal/catch_string_manip.h"

 #ifndef CATCH_CONFIG_DISABLE_MATCHERS
 #include "internal/catch_capture_matchers.h"
@@ -52,6 +57,10 @@
 #include "internal/catch_objc.hpp"
 #endif

+#ifdef CATCH_CONFIG_EXTERNAL_INTERFACES
+#include "internal/catch_external_interfaces.h"
+#endif
+
 #ifdef CATCH_IMPL
 #include "internal/catch_impl.hpp"
 #endif
@@ -65,6 +74,7 @@
 #  undef CLARA_CONFIG_MAIN
 #endif

+#if !defined(CATCH_CONFIG_DISABLE)
 //////
 // If this config identifier is defined then all CATCH macros are prefixed with CATCH_
 #ifdef CATCH_CONFIG_PREFIX_ALL
@@ -115,8 +125,6 @@

 #define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()

-#define CATCH_REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType )
-
 // "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__ )
@@ -175,8 +183,6 @@
 #define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
 #define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()

-#define REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType )
-
 #endif

 #define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
@@ -193,6 +199,134 @@

 using Catch::Detail::Approx;

+#else
+//////
+// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
+#ifdef CATCH_CONFIG_PREFIX_ALL
+
+#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_THROWS_WITH( expr, matcher )     (void)(0)
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+#endif// CATCH_CONFIG_DISABLE_MATCHERS
+#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_THROWS_WITH( expr, matcher )     (void)(0)
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define CATCH_CHECK_NOTHROW( ... ) (void)(0)
+
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_CHECK_THAT( arg, matcher )   (void)(0)
+
+#define CATCH_REQUIRE_THAT( arg, matcher ) (void)(0)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+
+#define CATCH_INFO( msg )    (void)(0)
+#define CATCH_WARN( msg )    (void)(0)
+#define CATCH_CAPTURE( msg ) (void)(0)
+
+#define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+#define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+#define CATCH_METHOD_AS_TEST_CASE( method, ... )
+#define CATCH_REGISTER_TEST_CASE( Function, ... ) (void)(0)
+#define CATCH_SECTION( ... )
+#define CATCH_FAIL( ... ) (void)(0)
+#define CATCH_FAIL_CHECK( ... ) (void)(0)
+#define CATCH_SUCCEED( ... ) (void)(0)
+
+#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+
+// "BDD-style" convenience wrappers
+#define CATCH_SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
+#define CATCH_GIVEN( desc )
+#define CATCH_WHEN( desc )
+#define CATCH_AND_WHEN( desc )
+#define CATCH_THEN( desc )
+#define CATCH_AND_THEN( desc )
+
+// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
+#else
+
+#define REQUIRE( ... )       (void)(0)
+#define REQUIRE_FALSE( ... ) (void)(0)
+
+#define REQUIRE_THROWS( ... ) (void)(0)
+#define REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
+#define REQUIRE_THROWS_WITH( expr, matcher ) (void)(0)
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#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_THROWS_WITH( expr, matcher ) (void)(0)
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define CHECK_NOTHROW( ... ) (void)(0)
+
+
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CHECK_THAT( arg, matcher ) (void)(0)
+
+#define REQUIRE_THAT( arg, matcher ) (void)(0)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+
+#define INFO( msg ) (void)(0)
+#define WARN( msg ) (void)(0)
+#define CAPTURE( msg ) (void)(0)
+
+#define TEST_CASE( ... )  INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+#define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+#define METHOD_AS_TEST_CASE( method, ... )
+#define REGISTER_TEST_CASE( Function, ... ) (void)(0)
+#define SECTION( ... )
+#define FAIL( ... ) (void)(0)
+#define FAIL_CHECK( ... ) (void)(0)
+#define SUCCEED( ... ) (void)(0)
+#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+
+#endif
+
+#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
+
+// "BDD-style" convenience wrappers
+#define SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ) )
+#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
+
+#define GIVEN( desc )
+#define WHEN( desc )
+#define AND_WHEN( desc )
+#define THEN( desc )
+#define AND_THEN( desc )
+
+using Catch::Detail::Approx;
+
+
+#endif
+
 #include "internal/catch_reenable_warnings.h"

 #endif // TWOBLUECUBES_CATCH_HPP_INCLUDED
--- a/include/catch_session.hpp
+++ b/include/catch_session.hpp
@@ -1,263 +0,0 @@
-/*
- *  Created by Phil on 31/10/2010.
- *  Copyright 2010 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_CATCH_RUNNER_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_RUNNER_HPP_INCLUDED
-
-#include "internal/catch_commandline.hpp"
-#include "internal/catch_console_colour.hpp"
-#include "internal/catch_enforce.h"
-#include "internal/catch_list.h"
-#include "internal/catch_run_context.hpp"
-#include "internal/catch_test_spec.hpp"
-#include "internal/catch_version.h"
-#include "internal/catch_interfaces_reporter.h"
-#include "internal/catch_startup_exception_registry.h"
-#include "internal/catch_text.h"
-
-#include <fstream>
-#include <cstdlib>
-#include <limits>
-#include <iomanip>
-
-namespace Catch {
-
-    IStreamingReporterPtr createReporter( std::string const& reporterName, IConfigPtr const& config ) {
-        auto reporter = getRegistryHub().getReporterRegistry().create( reporterName, config );
-        CATCH_ENFORCE( reporter, "No reporter registered with name: '" << reporterName << "'" );
-
-        return reporter;
-    }
-
-#ifndef CATCH_CONFIG_DEFAULT_REPORTER
-#define CATCH_CONFIG_DEFAULT_REPORTER "console"
-#endif
-
-    IStreamingReporterPtr makeReporter( std::shared_ptr<Config> const& config ) {
-        auto const& reporterNames = config->getReporterNames();
-        if( reporterNames.empty() )
-            return createReporter(CATCH_CONFIG_DEFAULT_REPORTER, config );
-
-        IStreamingReporterPtr reporter;
-        for( auto const& name : reporterNames )
-            addReporter( reporter, createReporter( name, config ) );
-        return reporter;
-    }
-    void addListeners( IStreamingReporterPtr& reporters, IConfigPtr const& config ) {
-        auto const& listeners = getRegistryHub().getReporterRegistry().getListeners();
-        for( auto const& listener : listeners )
-            addReporter(reporters, listener->create( ReporterConfig( config ) ) );
-    }
-
-
-    Totals runTests( std::shared_ptr<Config> const& config ) {
-
-        IStreamingReporterPtr reporter = makeReporter( config );
-        addListeners( reporter, config );
-
-        RunContext context( config, std::move( reporter ) );
-
-        Totals totals;
-
-        context.testGroupStarting( config->name(), 1, 1 );
-
-        TestSpec testSpec = config->testSpec();
-        if( !testSpec.hasFilters() )
-            testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "~[.]" ).testSpec(); // All not hidden tests
-
-        std::vector<TestCase> const& allTestCases = getAllTestCasesSorted( *config );
-        for( auto const& testCase : allTestCases ) {
-            if( !context.aborting() && matchTest( testCase, testSpec, *config ) )
-                totals += context.runTest( testCase );
-            else
-                context.reporter().skipTest( testCase );
-        }
-
-        context.testGroupEnded( config->name(), totals, 1, 1 );
-        return totals;
-    }
-
-    void applyFilenamesAsTags( IConfig const& config ) {
-        auto& tests = const_cast<std::vector<TestCase>&>( getAllTestCasesSorted( config ) );
-        for( auto& testCase : tests ) {
-            auto tags = testCase.tags;
-
-            std::string filename = testCase.lineInfo.file;
-            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.push_back( '#' + filename );
-            setTags( testCase, tags );
-        }
-    }
-
-
-    class Session : NonCopyable {
-        static const int MaxExitCode;
-    public:
-
-        Session() {
-            static bool alreadyInstantiated = false;
-            if( alreadyInstantiated )
-                CATCH_INTERNAL_ERROR( "Only one instance of Catch::Session can ever be used" );
-            alreadyInstantiated = true;
-            m_cli = makeCommandLineParser( m_configData );
-        }
-        ~Session() override {
-            Catch::cleanUp();
-        }
-
-        void showHelp() const {
-            Catch::cout()
-                    << "\nCatch v" << libraryVersion() << "\n"
-                    << m_cli << std::endl
-                    << "For more detailed usage please see the project docs\n" << std::endl;
-        }
-        void 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* argv[] ) {
-            auto result = m_cli.parse( clara::Args( argc, argv ) );
-            if( !result ) {
-                Catch::cerr()
-                    << Colour( Colour::Red )
-                    << "\nError(s) in input:\n"
-                    << Column( result.errorMessage() ).indent( 2 )
-                    << "\n\n";
-                Catch::cerr() << "Run with -? for usage\n" << std::endl;
-                return MaxExitCode;
-            }
-
-            if( m_configData.showHelp )
-                showHelp();
-            if( m_configData.libIdentify )
-                libIdentify();
-            m_config.reset();
-            return 0;
-        }
-
-        void useConfigData( ConfigData const& configData ) {
-            m_configData = configData;
-            m_config.reset();
-        }
-
-        int run( int argc, char* argv[] ) {
-            const auto& exceptions = getRegistryHub().getStartupExceptionRegistry().getExceptions();
-            if ( !exceptions.empty() ) {
-                Catch::cerr() << "Errors occured during startup!" << '\n';
-                // iterate over all exceptions and notify user
-                for ( const auto& ex_ptr : exceptions ) {
-                    try {
-                        std::rethrow_exception(ex_ptr);
-                    } catch ( std::exception const& ex ) {
-                        Catch::cerr() << ex.what() << '\n';
-                    }
-                }
-                return 1;
-            }
-            int returnCode = applyCommandLine( argc, argv );
-            if( returnCode == 0 )
-                returnCode = run();
-            return returnCode;
-        }
-
-    #if defined(WIN32) && defined(UNICODE)
-        int run( int argc, wchar_t* const argv[] ) {
-
-            char **utf8Argv = new char *[ argc ];
-
-            for ( int i = 0; i < argc; ++i ) {
-                int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, NULL, 0, NULL, NULL );
-
-                utf8Argv[ i ] = new char[ bufSize ];
-
-                WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, NULL, NULL );
-            }
-
-            int returnCode = run( argc, utf8Argv );
-
-            for ( int i = 0; i < argc; ++i )
-                delete [] utf8Argv[ i ];
-
-            delete [] utf8Argv;
-
-            return returnCode;
-        }
-    #endif
-        int run() {
-            if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
-                Catch::cout() << "...waiting for enter/ return before starting" << std::endl;
-                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;
-                std::getchar();
-            }
-            return exitCode;
-        }
-
-        clara::Parser const& cli() const {
-            return m_cli;
-        }
-        void cli( clara::Parser const& newParser ) {
-            m_cli = newParser;
-        }
-        ConfigData& configData() {
-            return m_configData;
-        }
-        Config& config() {
-            if( !m_config )
-                m_config = std::make_shared<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 (std::min)( MaxExitCode, static_cast<int>( runTests( m_config ).assertions.failed ) );
-            }
-            catch( std::exception& ex ) {
-                Catch::cerr() << ex.what() << std::endl;
-                return MaxExitCode;
-            }
-        }
-
-        clara::Parser m_cli;
-        ConfigData m_configData;
-        std::shared_ptr<Config> m_config;
-    };
-
-    const int Session::MaxExitCode = 255;
-
-} // end namespace Catch
-
-#endif // TWOBLUECUBES_CATCH_RUNNER_HPP_INCLUDED
--- a/include/external/clara.hpp
+++ b/include/external/clara.hpp
@@ -135,7 +135,7 @@ namespace Catch { namespace clara { namespace TextFlow {

            auto operator *() const -> std::string {
                assert( m_stringIndex < m_column.m_strings.size() );
-                assert( m_pos < m_end );
+                assert( m_pos <= m_end );
                if( m_pos + m_column.m_width < m_end )
                    return addIndentAndSuffix(line().substr(m_pos, m_len));
                else
--- a/include/internal/catch_approx.cpp
+++ b/include/internal/catch_approx.cpp
@@ -6,13 +6,20 @@
 *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 */

-#include "catch_approx.hpp"
+#include "catch_approx.h"

 #include <limits>

 namespace Catch {
 namespace Detail {

+    double max(double lhs, double rhs) {
+        if (lhs < rhs) {
+            return rhs;
+        }
+        return lhs;
+    }
+
    Approx::Approx ( double value )
    :   m_epsilon( std::numeric_limits<float>::epsilon()*100 ),
        m_margin( 0.0 ),
--- a/include/internal/catch_approx.hpp
+++ b/include/internal/catch_approx.hpp
@@ -10,7 +10,6 @@

 #include "catch_tostring.h"

-#include <algorithm>
 #include <cmath>

 #include <type_traits>
@@ -18,6 +17,8 @@
 namespace Catch {
 namespace Detail {

+    double max(double lhs, double rhs);
+
    class Approx {
    public:
        explicit Approx ( double value );
@@ -42,7 +43,7 @@ namespace Detail {
        friend bool operator == ( const T& lhs, Approx const& rhs ) {
            // Thanks to Richard Harris for his help refining this formula
            auto lhs_v = static_cast<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)));
+            bool relativeOK = std::fabs(lhs_v - rhs.m_value) < rhs.m_epsilon * (rhs.m_scale + (max)(std::fabs(lhs_v), std::fabs(rhs.m_value)));
            if (relativeOK) {
                return true;
            }
--- a/include/internal/catch_assertionresult.cpp
+++ b/include/internal/catch_assertionresult.cpp
@@ -9,6 +9,9 @@
 #include "catch_assertionresult.h"

 namespace Catch {
+    AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const & _lazyExpression):
+        lazyExpression(_lazyExpression),
+        resultType(_resultType) {}

    std::string AssertionResultData::reconstructExpression() const {

--- a/include/internal/catch_assertionresult.h
+++ b/include/internal/catch_assertionresult.h
@@ -21,18 +21,14 @@ namespace Catch {
    {
        AssertionResultData() = delete;

-        AssertionResultData( ResultWas::OfType _resultType, LazyExpression const& _lazyExpression )
-        :   resultType( _resultType ),
-            lazyExpression( _lazyExpression )
-        {}
+        AssertionResultData( ResultWas::OfType _resultType, LazyExpression const& _lazyExpression );

-        ResultWas::OfType resultType = ResultWas::Unknown;
        std::string message;
-
+        mutable std::string reconstructedExpression;
        LazyExpression lazyExpression;
+        ResultWas::OfType resultType;

        std::string reconstructExpression() const;
-        mutable std::string reconstructedExpression;
    };

    class AssertionResult {
--- a/include/internal/catch_benchmark.cpp
+++ b/include/internal/catch_benchmark.cpp
@@ -9,6 +9,7 @@
 #include "catch_benchmark.h"
 #include "catch_capture.hpp"
 #include "catch_interfaces_reporter.h"
+#include "catch_context.h"

 namespace Catch {

--- a/include/internal/catch_benchmark.h
+++ b/include/internal/catch_benchmark.h
@@ -19,8 +19,8 @@ namespace Catch {
    class BenchmarkLooper {

        std::string m_name;
-        size_t m_count = 0;
-        size_t m_iterationsToRun = 1;
+        std::size_t m_count = 0;
+        std::size_t m_iterationsToRun = 1;
        uint64_t m_resolution;
        Timer m_timer;

--- a/include/internal/catch_capture.hpp
+++ b/include/internal/catch_capture.hpp
@@ -11,7 +11,15 @@
 #include "catch_assertionhandler.h"
 #include "catch_message.h"
 #include "catch_interfaces_capture.h"
+#include "catch_debugger.h"

+#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)
 ///////////////////////////////////////////////////////////////////////////////
@@ -31,8 +39,6 @@

 #else // CATCH_CONFIG_FAST_COMPILE

-#include "catch_debugger.h"
-
 ///////////////////////////////////////////////////////////////////////////////
 // In the event of a failure works out if the debugger needs to be invoked
 // and/or an exception thrown and takes appropriate action.
@@ -50,7 +56,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_TEST( macroName, resultDisposition, ... ) \
    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName, CATCH_INTERNAL_LINEINFO, #__VA_ARGS__, resultDisposition ); \
+        Catch::AssertionHandler catchAssertionHandler( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
        INTERNAL_CATCH_TRY( catchAssertionHandler ) { \
            CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
            catchAssertionHandler.handle( Catch::Decomposer() <= __VA_ARGS__ ); \
@@ -73,7 +79,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, ... ) \
    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName, CATCH_INTERNAL_LINEINFO, #__VA_ARGS__, resultDisposition ); \
+        Catch::AssertionHandler catchAssertionHandler( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
        try { \
            static_cast<void>(__VA_ARGS__); \
            catchAssertionHandler.handle( Catch::ResultWas::Ok ); \
@@ -87,7 +93,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_THROWS( macroName, resultDisposition, ... ) \
    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName, CATCH_INTERNAL_LINEINFO, #__VA_ARGS__, resultDisposition); \
+        Catch::AssertionHandler catchAssertionHandler( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition); \
        if( catchAssertionHandler.allowThrows() ) \
            try { \
                static_cast<void>(__VA_ARGS__); \
@@ -104,7 +110,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \
    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName, CATCH_INTERNAL_LINEINFO, #expr ", " #exceptionType, resultDisposition ); \
+        Catch::AssertionHandler catchAssertionHandler( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
        if( catchAssertionHandler.allowThrows() ) \
            try { \
                static_cast<void>(expr); \
@@ -138,7 +144,7 @@
 // Although this is matcher-based, it can be used with just a string
 #define INTERNAL_CATCH_THROWS_STR_MATCHES( macroName, resultDisposition, matcher, ... ) \
    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName, CATCH_INTERNAL_LINEINFO, #__VA_ARGS__ ", " #matcher, resultDisposition ); \
+        Catch::AssertionHandler catchAssertionHandler( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
        if( catchAssertionHandler.allowThrows() ) \
            try { \
                static_cast<void>(__VA_ARGS__); \
@@ -152,5 +158,6 @@
        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( Catch::alwaysFalse() )

+#endif // CATCH_CONFIG_DISABLE

 #endif // TWOBLUECUBES_CATCH_CAPTURE_HPP_INCLUDED
--- a/include/internal/catch_capture_matchers.cpp
+++ b/include/internal/catch_capture_matchers.cpp
@@ -16,7 +16,8 @@ namespace Catch {
    // There is another overload, in catch_assertinhandler.h/.cpp, that only takes a string and infers
    // the Equals matcher (so the header does not mention matchers)
    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef matcherString  ) {
-        MatchExpr<std::string, StringMatcher const&> expr( Catch::translateActiveException(), matcher, matcherString );
+        std::string exceptionMessage = Catch::translateActiveException();
+        MatchExpr<std::string, StringMatcher const&> expr( exceptionMessage, matcher, matcherString );
        handler.handle( expr );
    }

--- a/include/internal/catch_capture_matchers.h
+++ b/include/internal/catch_capture_matchers.h
@@ -9,7 +9,7 @@
 #define TWOBLUECUBES_CATCH_CAPTURE_MATCHERS_HPP_INCLUDED

 #include "catch_capture.hpp"
-#include "catch_matchers.hpp"
+#include "catch_matchers.h"
 #include "catch_matchers_string.h"
 #include "catch_matchers_vector.h"

@@ -57,7 +57,7 @@ namespace Catch {
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName, CATCH_INTERNAL_LINEINFO, #arg ", " #matcher, resultDisposition ); \
+        Catch::AssertionHandler catchAssertionHandler( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
        INTERNAL_CATCH_TRY( catchAssertionHandler ) { \
            catchAssertionHandler.handle( Catch::makeMatchExpr( arg, matcher, #matcher ) ); \
        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
@@ -68,7 +68,7 @@ namespace Catch {
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_THROWS_MATCHES( macroName, exceptionType, resultDisposition, matcher, ... ) \
    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName, CATCH_INTERNAL_LINEINFO, #__VA_ARGS__ ", " #exceptionType ", " #matcher, resultDisposition ); \
+        Catch::AssertionHandler catchAssertionHandler( macroName, 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__ ); \
--- a/include/internal/catch_clara.h
+++ b/include/internal/catch_clara.h
@@ -16,9 +16,18 @@
 #endif
 #define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH-1

+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wweak-vtables"
+#pragma clang diagnostic ignored "-Wexit-time-destructors"
+#pragma clang diagnostic ignored "-Wshadow"
+#endif

 #include "../external/clara.hpp"

+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif

 // Restore Clara's value for console width, if present
 #ifdef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
--- a/include/internal/catch_commandline.cpp
+++ b/include/internal/catch_commandline.cpp
@@ -6,7 +6,7 @@
 *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 */

-#include "catch_commandline.hpp"
+#include "catch_commandline.h"

 #include "catch_string_manip.h"

@@ -135,7 +135,7 @@ namespace Catch {
            + Opt( setWarning, "warning name" )
                ["-w"]["--warn"]
                ( "enable warnings" )
-            + Opt( [&]( bool ) { config.showDurations = ShowDurations::Always; } )
+            + Opt( [&]( bool flag ) { config.showDurations = flag ? ShowDurations::Always : ShowDurations::Never; }, "yes|no" )
                ["-d"]["--durations"]
                ( "show test durations" )
            + Opt( loadTestNamesFromFile, "filename" )
--- a/include/internal/catch_commandline.hpp
+++ b/include/internal/catch_commandline.hpp
--- a/include/internal/catch_common.cpp
+++ b/include/internal/catch_common.cpp
@@ -29,14 +29,6 @@ namespace Catch {
        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 << ')';
@@ -54,4 +46,7 @@ namespace Catch {
        return std::string();
    }

+    NonCopyable::NonCopyable() = default;
+    NonCopyable::~NonCopyable() = default;
+
 }
--- a/include/internal/catch_common.h
+++ b/include/internal/catch_common.h
@@ -18,17 +18,12 @@
 #  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 <iosfwd>
 #include <string>
 #include <cstdint>

 namespace Catch {

-    struct IConfig;
-
    struct CaseSensitive { enum Choice {
        Yes,
        No
@@ -41,7 +36,7 @@ namespace Catch {
        NonCopyable& operator = ( NonCopyable && )     = delete;

    protected:
-        NonCopyable() {}
+        NonCopyable();
        virtual ~NonCopyable();
    };

@@ -70,9 +65,6 @@ namespace Catch {
    bool alwaysTrue();
    bool alwaysFalse();

-    void seedRng( IConfig const& config );
-    unsigned int rngSeed();
-
    // Use this in variadic streaming macros to allow
    //    >> +StreamEndStop
    // as well as
--- a/include/internal/catch_compiler_capabilities.h
+++ b/include/internal/catch_compiler_capabilities.h
@@ -35,11 +35,11 @@

 #ifdef __clang__

-
-#       define CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
+#       define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
            _Pragma( "clang diagnostic push" ) \
-            _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" )
-#       define CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
+            _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
+            _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
+#       define CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \
            _Pragma( "clang diagnostic pop" )

 #       define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
@@ -76,53 +76,26 @@

 #endif // __CYGWIN__

-////////////////////////////////////////////////////////////////////////////////
-// Borland
-#ifdef __BORLANDC__
-
-
-#endif // __BORLANDC__
-
-////////////////////////////////////////////////////////////////////////////////
-// EDG
-#ifdef __EDG_VERSION__
-
-
-#endif // __EDG_VERSION__
-
-////////////////////////////////////////////////////////////////////////////////
-// Digital Mars
-#ifdef __DMC__
-
-
-#endif // __DMC__
-
-////////////////////////////////////////////////////////////////////////////////
-// GCC
-#ifdef __GNUC__
-
-
-#endif // __GNUC__
-
 ////////////////////////////////////////////////////////////////////////////////
 // Visual C++
 #ifdef _MSC_VER

-#define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
+// Universal Windows platform does not support SEH
+// Or console colours (or console at all...)
+#  if (WINAPI_FAMILY == WINAPI_FAMILY_APP)
+#    define CATCH_CONFIG_COLOUR_NONE
+#  else
+#    define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
+#  endif

 #endif // _MSC_VER

 ////////////////////////////////////////////////////////////////////////////////

-// 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 )
-
+// All supported compilers support COUNTER macro,
+//but user still might want to turn it off
 #define CATCH_INTERNAL_CONFIG_COUNTER

-#endif
-

 // Now set the actual defines based on the above + anything the user has configured

@@ -144,9 +117,9 @@
 #   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
+#if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+#   define CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
 #endif


--- a/include/internal/catch_config.cpp
+++ b/include/internal/catch_config.cpp
@@ -7,6 +7,7 @@

 #include "catch_config.hpp"
 #include "catch_enforce.h"
+#include "catch_stream.h"

 namespace Catch {

--- a/include/internal/catch_config.hpp
+++ b/include/internal/catch_config.hpp
@@ -8,9 +8,10 @@
 #ifndef TWOBLUECUBES_CATCH_CONFIG_HPP_INCLUDED
 #define TWOBLUECUBES_CATCH_CONFIG_HPP_INCLUDED

-#include "catch_test_spec_parser.hpp"
-#include "catch_context.h"
+#include "catch_test_spec_parser.h"
 #include "catch_interfaces_config.h"
+
+// Libstdc++ doesn't like incomplete classes for unique_ptr
 #include "catch_stream.h"

 #include <memory>
@@ -23,6 +24,8 @@

 namespace Catch {

+    struct IStream;
+
    struct ConfigData {
        bool listTests = false;
        bool listTags = false;
@@ -59,7 +62,6 @@ namespace Catch {


    class Config : public IConfig {
-        virtual void dummy();
    public:

        Config() = default;
--- a/include/internal/catch_console_colour.cpp
+++ b/include/internal/catch_console_colour.cpp
@@ -6,13 +6,21 @@
 *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 */

-#include "catch_console_colour.hpp"
+
+#if defined(__clang__)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wexit-time-destructors"
+#endif
+ 
+ 
+#include "catch_console_colour.h"
 #include "catch_enforce.h"
 #include "catch_errno_guard.h"
 #include "catch_interfaces_config.h"
 #include "catch_stream.h"
 #include "catch_context.h"
 #include "catch_platform.h"
+#include "catch_debugger.h"

 namespace Catch {
    namespace {
@@ -149,6 +157,13 @@ namespace {
        }
    };

+    bool useColourOnPlatform() {
+        return
+#ifdef CATCH_PLATFORM_MAC
+            !isDebuggerActive() &&
+#endif
+            isatty(STDOUT_FILENO);
+    }
    IColourImpl* platformColourInstance() {
        ErrnoGuard guard;
        IConfigPtr config = getCurrentContext().getConfig();
@@ -156,7 +171,7 @@ namespace {
            ? config->useColour()
            : UseColour::Auto;
        if( colourMode == UseColour::Auto )
-            colourMode = isatty(STDOUT_FILENO)
+            colourMode = useColourOnPlatform()
                ? UseColour::Yes
                : UseColour::No;
        return colourMode == UseColour::Yes
@@ -202,3 +217,8 @@ namespace Catch {
    }

 } // end namespace Catch
+
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#endif
+
--- a/include/internal/catch_console_colour.hpp
+++ b/include/internal/catch_console_colour.hpp
--- a/include/internal/catch_context.cpp
+++ b/include/internal/catch_context.cpp
@@ -24,6 +24,8 @@ namespace Catch {
            return m_config;
        }

+        virtual ~Context() override;
+
    public: // IMutableContext
        virtual void setResultCapture( IResultCapture* resultCapture ) override {
            m_resultCapture = resultCapture;
@@ -59,4 +61,7 @@ namespace Catch {
        delete currentContext;
        currentContext = nullptr;
    }
+    IContext::~IContext() = default;
+    IMutableContext::~IMutableContext() = default;
+    Context::~Context() = default;
 }
--- a/include/internal/catch_context.h
+++ b/include/internal/catch_context.h
@@ -12,8 +12,6 @@

 namespace Catch {

-    class TestCase;
-    class Stream;
    struct IResultCapture;
    struct IRunner;
    struct IConfig;
--- a/include/internal/catch_debug_console.cpp
+++ b/include/internal/catch_debug_console.cpp
@@ -0,0 +1,29 @@
+/*
+ *  Created by Martin on 29/08/2017.
+ *
+ *  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)
+ *
+ */
+
+#include "catch_debug_console.h"
+#include "catch_stream.h"
+#include "catch_platform.h"
+
+#ifdef CATCH_PLATFORM_WINDOWS
+
+#include "catch_windows_h_proxy.h"
+
+    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
--- a/include/internal/catch_debug_console.h
+++ b/include/internal/catch_debug_console.h
@@ -0,0 +1,17 @@
+/*
+ *  Created by Martin on 29/08/2017.
+ *
+ *  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_CATCH_DEBUG_CONSOLE_H_INCLUDED
+#define TWOBLUECUBES_CATCH_DEBUG_CONSOLE_H_INCLUDED
+
+#include <string>
+
+namespace Catch {
+    void writeToDebugConsole( std::string const& text );
+}
+
+#endif // TWOBLUECUBES_CATCH_DEBUG_CONSOLE_H_INCLUDED
--- a/include/internal/catch_debugger.cpp
+++ b/include/internal/catch_debugger.cpp
@@ -20,7 +20,7 @@
    #include <unistd.h>
    #include <sys/sysctl.h>

-    namespace Catch{
+    namespace Catch {

        // The following function is taken directly from the following technical note:
        // http://developer.apple.com/library/mac/#qa/qa2004/qa1361.html
@@ -31,7 +31,7 @@

            int                 mib[4];
            struct kinfo_proc   info;
-            size_t              size;
+            std::size_t         size;

            // Initialize the flags so that, if sysctl fails for some bizarre
            // reason, we get a predictable result.
@@ -109,21 +109,3 @@
       bool isDebuggerActive() { return false; }
    }
 #endif // Platform
-
-#ifdef CATCH_PLATFORM_WINDOWS
-
-#include "catch_windows_h_proxy.h"
-
-    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
--- a/include/internal/catch_debugger.h
+++ b/include/internal/catch_debugger.h
@@ -11,12 +11,8 @@

 #include "catch_platform.h"

-#include <string>
-
-namespace Catch{
-
+namespace Catch {
    bool isDebuggerActive();
-    void writeToDebugConsole( std::string const& text );
 }

 #ifdef CATCH_PLATFORM_MAC
--- a/include/internal/catch_decomposer.cpp
+++ b/include/internal/catch_decomposer.cpp
@@ -11,7 +11,9 @@

 namespace Catch {

-    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, std::string const& op, std::string const& rhs ) {
+    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 )
--- a/include/internal/catch_decomposer.h
+++ b/include/internal/catch_decomposer.h
@@ -18,6 +18,7 @@
 #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
 #endif

 namespace Catch {
@@ -29,16 +30,16 @@ namespace Catch {

        // We don't actually need a virtual destructore, but many static analysers
        // complain if it's not here :-(
-        virtual ~ITransientExpression() = default;
+        virtual ~ITransientExpression();
    };

-    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, std::string const& op, std::string const& rhs );
+    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs );

    template<typename LhsT, typename RhsT>
    class BinaryExpr  : public ITransientExpression {
        bool m_result;
        LhsT m_lhs;
-        std::string m_op;
+        StringRef m_op;
        RhsT m_rhs;

        auto isBinaryExpression() const -> bool override { return true; }
@@ -50,8 +51,8 @@ namespace Catch {
        }

    public:
-        BinaryExpr( bool comparisionResult, LhsT lhs, StringRef op, RhsT rhs )
-        :   m_result( comparisionResult ),
+        BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )
+        :   m_result( comparisonResult ),
            m_lhs( lhs ),
            m_op( op ),
            m_rhs( rhs )
@@ -76,18 +77,26 @@ namespace Catch {

    // Specialised comparison functions to handle equality comparisons between ints and pointers (NULL deduces as an int)
    template<typename LhsT, typename RhsT>
-    auto compareEqual( LhsT lhs, RhsT&& rhs ) -> bool { return lhs == rhs; };
+    auto compareEqual( LhsT const& lhs, RhsT&& rhs ) -> bool { return lhs == rhs; };
    template<typename T>
-    auto compareEqual( T* const& lhs, int rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); };
+    auto compareEqual( T* const& lhs, int 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; };
+    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 lhs, RhsT&& rhs ) -> bool { return lhs != rhs; };
+    auto compareNotEqual( LhsT const& lhs, RhsT&& rhs ) -> bool { return lhs != rhs; };
    template<typename T>
-    auto compareNotEqual( T* const& lhs, int rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); };
+    auto compareNotEqual( T* const& lhs, int 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; };
+    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>
@@ -142,10 +151,6 @@ namespace Catch {
    }

    struct Decomposer {
-        template<typename T>
-        auto operator <= ( T& lhs ) -> ExprLhs<T&> {
-            return ExprLhs<T&>( lhs );
-        }
        template<typename T>
        auto operator <= ( T const& lhs ) -> ExprLhs<T const&> {
            return ExprLhs<T const&>( lhs );
@@ -157,8 +162,4 @@ namespace Catch {

 } // end namespace Catch

-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
 #endif // TWOBLUECUBES_CATCH_DECOMPOSER_H_INCLUDED
--- a/include/internal/catch_default_main.hpp
+++ b/include/internal/catch_default_main.hpp
@@ -8,6 +8,8 @@
 #ifndef TWOBLUECUBES_CATCH_DEFAULT_MAIN_HPP_INCLUDED
 #define TWOBLUECUBES_CATCH_DEFAULT_MAIN_HPP_INCLUDED

+#include "catch_session.h"
+
 #ifndef __OBJC__

 #if defined(WIN32) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
@@ -30,7 +32,7 @@ int main (int argc, char * const argv[]) {
 #endif

    Catch::registerTestMethods();
-    int result = Catch::Session().run( argc, (char* const*)argv );
+    int result = Catch::Session().run( argc, (char**)argv );

 #if !CATCH_ARC_ENABLED
    [pool drain];
--- a/include/internal/catch_exception_translator_registry.cpp
+++ b/include/internal/catch_exception_translator_registry.cpp
@@ -30,7 +30,7 @@ namespace Catch {
                return tryTranslators();
            }
            @catch (NSException *exception) {
-                return Catch::toString( [exception description] );
+                return Catch::Detail::stringify( [exception description] );
            }
 #else
            return tryTranslators();
--- a/include/internal/catch_external_interfaces.h
+++ b/include/internal/catch_external_interfaces.h
@@ -0,0 +1,14 @@
+/*
+ *  Created by Martin on 17/08/2017.
+ *
+ *  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_CATCH_EXTERNAL_INTERFACES_H_INCLUDED
+#define TWOBLUECUBES_CATCH_EXTERNAL_INTERFACES_H_INCLUDED
+
+#include "../reporters/catch_reporter_bases.hpp"
+#include "catch_console_colour.h"
+#include "catch_reporter_registrars.hpp"
+
+#endif // TWOBLUECUBES_CATCH_EXTERNAL_INTERFACES_H_INCLUDED
--- a/include/internal/catch_fatal_condition.cpp
+++ b/include/internal/catch_fatal_condition.cpp
@@ -12,16 +12,12 @@
 #include "catch_context.h"
 #include "catch_interfaces_capture.h"

-namespace Catch {
-
+namespace {
    // Report the error condition
-    void reportFatal( std::string const& message ) {
-        IContext& context = Catch::getCurrentContext();
-        IResultCapture* resultCapture = context.getResultCapture();
-        resultCapture->handleFatalErrorCondition( message );
+    void reportFatal( char const * const message ) {
+        Catch::getCurrentContext().getResultCapture()->handleFatalErrorCondition( message );
    }
-
-} // namespace Catch
+}

 #if defined ( CATCH_PLATFORM_WINDOWS ) /////////////////////////////////////////

@@ -39,7 +35,7 @@ namespace Catch {
    // 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[] = {
+    static SignalDefs signalDefs[] = {
        { EXCEPTION_ILLEGAL_INSTRUCTION,  "SIGILL - Illegal instruction signal" },
        { EXCEPTION_STACK_OVERFLOW, "SIGSEGV - Stack overflow" },
        { EXCEPTION_ACCESS_VIOLATION, "SIGSEGV - Segmentation violation signal" },
@@ -47,9 +43,9 @@ namespace Catch {
    };

    LONG CALLBACK FatalConditionHandler::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);
+        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.
@@ -111,7 +107,7 @@ namespace Catch {
        int id;
        const char* name;
    };
-    SignalDefs signalDefs[] = {
+    static SignalDefs signalDefs[] = {
        { SIGINT,  "SIGINT - Terminal interrupt signal" },
        { SIGILL,  "SIGILL - Illegal instruction signal" },
        { SIGFPE,  "SIGFPE - Floating point error signal" },
@@ -122,9 +118,8 @@ namespace Catch {


    void FatalConditionHandler::handleSignal( int sig ) {
-        std::string name = "<unknown signal>";
-        for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
-            SignalDefs &def = signalDefs[i];
+        char const * name = "<unknown signal>";
+        for (auto const& def : signalDefs) {
            if (sig == def.id) {
                name = def.name;
                break;
--- a/include/internal/catch_fatal_condition.h
+++ b/include/internal/catch_fatal_condition.h
@@ -13,12 +13,6 @@
 #include "catch_platform.h"
 #include "catch_compiler_capabilities.h"

-namespace Catch {
-
-    // Report the error condition
-    void reportFatal( std::string const& message );
-    
-} // namespace Catch

 #if defined ( CATCH_PLATFORM_WINDOWS ) /////////////////////////////////////////
 #include "catch_windows_h_proxy.h"
--- a/include/internal/catch_impl.hpp
+++ b/include/internal/catch_impl.hpp
@@ -8,57 +8,22 @@
 #ifndef TWOBLUECUBES_CATCH_IMPL_HPP_INCLUDED
 #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

+// Keep these here for external reporters
+#include "catch_test_spec.h"
+#include "catch_test_case_tracker.h"

-#include "internal/catch_notimplemented_exception.h"
-
-
-// Temporary hack to fix separately provided reporters
-#include "../reporters/catch_reporter_bases.hpp"
-#include "catch_reporter_registrars.hpp"
-//
-
-#include "internal/catch_leak_detector.h"
-
-
-#include "../catch_session.hpp"
-#include "catch_test_spec.hpp"
-#include "catch_test_case_tracker.hpp"
+#include "catch_leak_detector.h"

 // Cpp files will be included in the single-header file here
 // ~*~* CATCH_CPP_STITCH_PLACE *~*~

 namespace Catch {
    LeakDetector leakDetector;
-
-    // These are all here to avoid warnings about not having any out of line
-    // virtual methods
-    NonCopyable::~NonCopyable() {}
-    IStream::~IStream() noexcept {}
-    FileStream::~FileStream() noexcept {}
-    CoutStream::~CoutStream() noexcept {}
-    DebugOutStream::~DebugOutStream() noexcept {}
-    StreamBufBase::~StreamBufBase() noexcept {}
-    IContext::~IContext() {}
-    IResultCapture::~IResultCapture() {}
-    ITestInvoker::~ITestInvoker() {}
-    ITestCaseRegistry::~ITestCaseRegistry() {}
-    IRegistryHub::~IRegistryHub() {}
-    IMutableRegistryHub::~IMutableRegistryHub() {}
-    IExceptionTranslator::~IExceptionTranslator() {}
-    IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() {}
-    IRunner::~IRunner() {}
-    IMutableContext::~IMutableContext() {}
-    IConfig::~IConfig() {}
-
-    void Config::dummy() {}
 }

 #ifdef __clang__
--- a/include/internal/catch_interfaces_capture.cpp
+++ b/include/internal/catch_interfaces_capture.cpp
@@ -0,0 +1,5 @@
+#include "catch_interfaces_capture.h"
+
+namespace Catch {
+    IResultCapture::~IResultCapture() = default;
+}
--- a/include/internal/catch_interfaces_capture.h
+++ b/include/internal/catch_interfaces_capture.h
@@ -10,15 +10,15 @@

 #include <string>

+#include "catch_stringref.h"
+
 namespace Catch {

-    class TestCase;
    class AssertionResult;
    struct AssertionInfo;
    struct SectionInfo;
    struct SectionEndInfo;
    struct MessageInfo;
-    class ScopedMessageBuilder;
    struct Counts;
    struct BenchmarkInfo;
    struct BenchmarkStats;
@@ -45,7 +45,7 @@ namespace Catch {

        virtual void exceptionEarlyReported() = 0;

-        virtual void handleFatalErrorCondition( std::string const& message ) = 0;
+        virtual void handleFatalErrorCondition( StringRef message ) = 0;

        virtual bool lastAssertionPassed() = 0;
        virtual void assertionPassed() = 0;
--- a/include/internal/catch_interfaces_config.cpp
+++ b/include/internal/catch_interfaces_config.cpp
@@ -0,0 +1,5 @@
+#include "internal/catch_interfaces_config.h"
+
+namespace Catch {
+    IConfig::~IConfig() = default;
+}
--- a/include/internal/catch_interfaces_exception.cpp
+++ b/include/internal/catch_interfaces_exception.cpp
@@ -0,0 +1,6 @@
+#include "internal/catch_interfaces_exception.h"
+
+namespace Catch {
+    IExceptionTranslator::~IExceptionTranslator() = default;
+    IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() = default;
+}
--- a/include/internal/catch_interfaces_exception.h
+++ b/include/internal/catch_interfaces_exception.h
@@ -8,11 +8,16 @@
 #ifndef TWOBLUECUBES_CATCH_INTERFACES_EXCEPTION_H_INCLUDED
 #define TWOBLUECUBES_CATCH_INTERFACES_EXCEPTION_H_INCLUDED

+#include "catch_interfaces_registry_hub.h"
+
+#if defined(CATCH_CONFIG_DISABLE)
+    #define INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( translatorName, signature) \
+        static std::string translatorName( signature )
+#endif
+
 #include <string>
 #include <vector>

-#include "catch_interfaces_registry_hub.h"
-
 namespace Catch {
    using exceptionTranslateFunction = std::string(*)();

--- a/include/internal/catch_interfaces_registry_hub.cpp
+++ b/include/internal/catch_interfaces_registry_hub.cpp
@@ -0,0 +1,6 @@
+#include "internal/catch_interfaces_registry_hub.h"
+
+namespace Catch {
+    IRegistryHub::~IRegistryHub() = default;
+    IMutableRegistryHub::~IMutableRegistryHub() = default;
+}
--- a/include/internal/catch_interfaces_reporter.cpp
+++ b/include/internal/catch_interfaces_reporter.cpp
@@ -50,6 +50,8 @@ namespace Catch {
        }
    }

+     AssertionStats::~AssertionStats() = default;
+
    SectionStats::SectionStats(  SectionInfo const& _sectionInfo,
                                 Counts const& _assertions,
                                 double _durationInSeconds,
@@ -60,6 +62,8 @@ namespace Catch {
        missingAssertions( _missingAssertions )
    {}

+    SectionStats::~SectionStats() = default;
+

    TestCaseStats::TestCaseStats(  TestCaseInfo const& _testInfo,
                                   Totals const& _totals,
@@ -73,6 +77,8 @@ namespace Catch {
        aborting( _aborting )
    {}

+    TestCaseStats::~TestCaseStats() = default;
+

    TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo,
                                    Totals const& _totals,
@@ -87,6 +93,8 @@ namespace Catch {
        aborting( false )
    {}

+    TestGroupStats::~TestGroupStats() = default;
+
    TestRunStats::TestRunStats(   TestRunInfo const& _runInfo,
                    Totals const& _totals,
                    bool _aborting )
@@ -95,9 +103,14 @@ namespace Catch {
        aborting( _aborting )
    {}

+    TestRunStats::~TestRunStats() = default;

+    void IStreamingReporter::fatalErrorEncountered( StringRef ) {}
    bool IStreamingReporter::isMulti() const { return false; }

+    IReporterFactory::~IReporterFactory() = default;
+    IReporterRegistry::~IReporterRegistry() = default;
+
    void addReporter( IStreamingReporterPtr& existingReporter, IStreamingReporterPtr&& additionalReporter ) {

        if( !existingReporter ) {
--- a/include/internal/catch_interfaces_reporter.h
+++ b/include/internal/catch_interfaces_reporter.h
@@ -11,12 +11,12 @@
 #include "catch_section_info.h"
 #include "catch_common.h"
 #include "catch_config.hpp"
-#include "catch_context.h"
-#include "catch_totals.hpp"
+#include "catch_totals.h"
 #include "catch_test_case_info.h"
 #include "catch_assertionresult.h"
 #include "catch_message.h"
 #include "catch_option.hpp"
+#include "catch_stringref.h"


 #include <string>
@@ -81,7 +81,7 @@ namespace Catch {
        AssertionStats( AssertionStats && )                  = default;
        AssertionStats& operator = ( AssertionStats const& ) = default;
        AssertionStats& operator = ( AssertionStats && )     = default;
-        virtual ~AssertionStats()                            = default;
+        virtual ~AssertionStats();

        AssertionResult assertionResult;
        std::vector<MessageInfo> infoMessages;
@@ -97,7 +97,7 @@ namespace Catch {
        SectionStats( SectionStats && )                  = default;
        SectionStats& operator = ( SectionStats const& ) = default;
        SectionStats& operator = ( SectionStats && )     = default;
-        virtual ~SectionStats()                          = default;
+        virtual ~SectionStats();

        SectionInfo sectionInfo;
        Counts assertions;
@@ -116,7 +116,7 @@ namespace Catch {
        TestCaseStats( TestCaseStats && )                  = default;
        TestCaseStats& operator = ( TestCaseStats const& ) = default;
        TestCaseStats& operator = ( TestCaseStats && )     = default;
-        virtual ~TestCaseStats()                           = default;
+        virtual ~TestCaseStats();

        TestCaseInfo testInfo;
        Totals totals;
@@ -135,7 +135,7 @@ namespace Catch {
        TestGroupStats( TestGroupStats && )                  = default;
        TestGroupStats& operator = ( TestGroupStats const& ) = default;
        TestGroupStats& operator = ( TestGroupStats && )     = default;
-        virtual ~TestGroupStats()                            = default;
+        virtual ~TestGroupStats();

        GroupInfo groupInfo;
        Totals totals;
@@ -151,7 +151,7 @@ namespace Catch {
        TestRunStats( TestRunStats && )                  = default;
        TestRunStats& operator = ( TestRunStats const& ) = default;
        TestRunStats& operator = ( TestRunStats && )     = default;
-        virtual ~TestRunStats()                          = default;
+        virtual ~TestRunStats();

        TestRunInfo runInfo;
        Totals totals;
@@ -163,10 +163,9 @@ namespace Catch {
    };
    struct BenchmarkStats {
        BenchmarkInfo info;
-        size_t iterations;
+        std::size_t iterations;
        uint64_t elapsedTimeInNanoseconds;
    };
-    class MultipleReporters;

    struct IStreamingReporter {
        virtual ~IStreamingReporter() = default;
@@ -203,12 +202,15 @@ namespace Catch {

        virtual void skipTest( TestCaseInfo const& testInfo ) = 0;

+        // Default empty implementation provided
+        virtual void fatalErrorEncountered( StringRef name );
+
        virtual bool isMulti() const;
    };
    using IStreamingReporterPtr = std::unique_ptr<IStreamingReporter>;

    struct IReporterFactory {
-        virtual ~IReporterFactory() = default;
+        virtual ~IReporterFactory();
        virtual IStreamingReporterPtr create( ReporterConfig const& config ) const = 0;
        virtual std::string getDescription() const = 0;
    };
@@ -218,7 +220,7 @@ namespace Catch {
        using FactoryMap = std::map<std::string, IReporterFactoryPtr>;
        using Listeners = std::vector<IReporterFactoryPtr>;

-        virtual ~IReporterRegistry() = default;
+        virtual ~IReporterRegistry();
        virtual IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const = 0;
        virtual FactoryMap const& getFactories() const = 0;
        virtual Listeners const& getListeners() const = 0;
--- a/include/internal/catch_interfaces_runner.cpp
+++ b/include/internal/catch_interfaces_runner.cpp
@@ -0,0 +1,5 @@
+#include "internal/catch_interfaces_runner.h"
+
+namespace Catch {
+    IRunner::~IRunner() = default;
+}
--- a/include/internal/catch_interfaces_runner.h
+++ b/include/internal/catch_interfaces_runner.h
@@ -9,7 +9,6 @@
 #define TWOBLUECUBES_CATCH_INTERFACES_RUNNER_H_INCLUDED

 namespace Catch {
-    class TestCase;

    struct IRunner {
        virtual ~IRunner();
--- a/include/internal/catch_interfaces_testcase.cpp
+++ b/include/internal/catch_interfaces_testcase.cpp
@@ -0,0 +1,6 @@
+#include "internal/catch_interfaces_testcase.h"
+
+namespace Catch {
+    ITestInvoker::~ITestInvoker() = default;
+    ITestCaseRegistry::~ITestCaseRegistry() = default;
+}
--- a/include/internal/catch_list.cpp
+++ b/include/internal/catch_list.cpp
@@ -12,10 +12,11 @@
 #include "catch_interfaces_reporter.h"
 #include "catch_interfaces_testcase.h"

+#include "catch_stream.h"
 #include "catch_text.h"

-#include "catch_console_colour.hpp"
-#include "catch_test_spec_parser.hpp"
+#include "catch_console_colour.h"
+#include "catch_test_spec_parser.h"
 #include "catch_tostring.h"
 #include "catch_string_manip.h"

--- a/include/internal/catch_matchers.cpp
+++ b/include/internal/catch_matchers.cpp
@@ -5,7 +5,7 @@
 * file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 */

-#include "catch_matchers.hpp"
+#include "catch_matchers.h"

 namespace Catch {
 namespace Matchers {
@@ -17,6 +17,8 @@ namespace Matchers {
            return m_cachedToString;
        }

+        MatcherUntypedBase::~MatcherUntypedBase() = default;
+
    } // namespace Impl
 } // namespace Matchers

--- a/include/internal/catch_matchers.hpp
+++ b/include/internal/catch_matchers.hpp
@@ -29,7 +29,7 @@ namespace Matchers {
            std::string toString() const;

        protected:
-            virtual ~MatcherUntypedBase() = default;
+            virtual ~MatcherUntypedBase();
            virtual std::string describe() const = 0;
            mutable std::string m_cachedToString;
        };
@@ -148,31 +148,6 @@ namespace Matchers {

    } // 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;
--- a/include/internal/catch_matchers_string.h
+++ b/include/internal/catch_matchers_string.h
@@ -8,7 +8,7 @@
 #ifndef TWOBLUECUBES_CATCH_MATCHERS_STRING_H_INCLUDED
 #define TWOBLUECUBES_CATCH_MATCHERS_STRING_H_INCLUDED

-#include "catch_matchers.hpp"
+#include "catch_matchers.h"

 #include <string>

--- a/include/internal/catch_matchers_vector.h
+++ b/include/internal/catch_matchers_vector.h
@@ -8,7 +8,7 @@
 #ifndef TWOBLUECUBES_CATCH_MATCHERS_VECTOR_H_INCLUDED
 #define TWOBLUECUBES_CATCH_MATCHERS_VECTOR_H_INCLUDED

-#include "catch_matchers.hpp"
+#include "catch_matchers.h"

 namespace Catch {
 namespace Matchers {
@@ -78,7 +78,7 @@ namespace Matchers {
                // - then just call that directly
                if (m_comparator.size() != v.size())
                    return false;
-                for (size_t i = 0; i < v.size(); ++i)
+                for (std::size_t i = 0; i < v.size(); ++i)
                    if (m_comparator[i] != v[i])
                        return false;
                return true;
--- a/include/internal/catch_message.h
+++ b/include/internal/catch_message.h
@@ -21,9 +21,9 @@ namespace Catch {
                        ResultWas::OfType _type );

        std::string macroName;
+        std::string message;
        SourceLineInfo lineInfo;
        ResultWas::OfType type;
-        std::string message;
        unsigned int sequence;

        bool operator == ( MessageInfo const& other ) const;
--- a/include/internal/catch_notimplemented_exception.cpp
+++ b/include/internal/catch_notimplemented_exception.cpp
@@ -1,25 +0,0 @@
-/*
- *  Created by Phil on 5/8/2012.
- *  Copyright 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)
- */
-
-#include "catch_notimplemented_exception.h"
-#include <sstream>
-
-namespace Catch {
-
-    NotImplementedException::NotImplementedException( SourceLineInfo const& lineInfo ) {
-        std::ostringstream oss;
-        oss << lineInfo << ": function ";
-        oss << "not implemented";
-        m_what = oss.str();
-    }
-
-    const char* NotImplementedException::what() const noexcept {
-        return m_what.c_str();
-    }
-
-} // end namespace Catch
--- a/include/internal/catch_notimplemented_exception.h
+++ b/include/internal/catch_notimplemented_exception.h
@@ -1,35 +0,0 @@
-/*
- *  Created by Phil on 5/8/2012.
- *  Copyright 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_CATCH_NOTIMPLEMENTED_EXCEPTION_H_INCLUDED
-#define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_H_INCLUDED
-
-#include "catch_common.h"
-
-#include <exception>
-
-namespace Catch {
-
-    class NotImplementedException : public std::exception
-    {
-    public:
-        NotImplementedException( SourceLineInfo const& lineInfo );
-
-        virtual ~NotImplementedException() noexcept = default;
-
-        virtual const char* what() const noexcept override;
-
-    private:
-        std::string m_what;
-    };
-
-} // end namespace Catch
-
-///////////////////////////////////////////////////////////////////////////////
-#define CATCH_NOT_IMPLEMENTED throw Catch::NotImplementedException( CATCH_INTERNAL_LINEINFO )
-
-#endif // TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_H_INCLUDED
--- a/include/internal/catch_objc.hpp
+++ b/include/internal/catch_objc.hpp
@@ -18,6 +18,8 @@
 // in catch.hpp first to make sure they are included by the single
 // header for non obj-usage
 #include "catch_test_case_info.h"
+#include "catch_string_manip.h"
+#include "catch_tostring.h"

 ///////////////////////////////////////////////////////////////////////////////
 // This protocol is really only here for (self) documenting purposes, since
@@ -70,8 +72,8 @@ namespace Catch {
        }
    }

-    inline size_t registerTestMethods() {
-        size_t noTestMethods = 0;
+    inline std::size_t registerTestMethods() {
+        std::size_t noTestMethods = 0;
        int noClasses = objc_getClassList( nullptr, 0 );

        Class* classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc( sizeof(Class) * noClasses);
@@ -91,7 +93,7 @@ namespace Catch {
                        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() ) );
+                        getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, name.c_str(), desc.c_str(), SourceLineInfo("",0) ) );
                        noTestMethods++;
                    }
                }
@@ -118,7 +120,7 @@ namespace Catch {
                    return false;
                }

-                NSString* m_substr;
+                NSString* CATCH_ARC_STRONG m_substr;
            };

            struct Equals : StringHolder {
@@ -130,7 +132,7 @@ namespace Catch {
                }

                std::string describe() const override {
-                    return "equals string: " + Catch::toString( m_substr );
+                    return "equals string: " + Catch::Detail::stringify( m_substr );
                }
            };

@@ -143,7 +145,7 @@ namespace Catch {
                }

                std::string describe() const override {
-                    return "contains string: " + Catch::toString( m_substr );
+                    return "contains string: " + Catch::Detail::stringify( m_substr );
                }
            };

@@ -156,7 +158,7 @@ namespace Catch {
                }

                std::string describe() const override {
-                    return "starts with: " + Catch::toString( m_substr );
+                    return "starts with: " + Catch::Detail::stringify( m_substr );
                }
            };
            struct EndsWith : StringHolder {
@@ -168,7 +170,7 @@ namespace Catch {
                }

                std::string describe() const override {
-                    return "ends with: " + Catch::toString( m_substr );
+                    return "ends with: " + Catch::Detail::stringify( m_substr );
                }
            };

@@ -196,15 +198,18 @@ namespace Catch {
 } // namespace Catch

 ///////////////////////////////////////////////////////////////////////////////
-#define OC_TEST_CASE( name, desc )\
-+(NSString*) INTERNAL_CATCH_UNIQUE_NAME( Catch_Name_test ) \
-{\
+#define OC_MAKE_UNIQUE_NAME( root, uniqueSuffix ) root##uniqueSuffix
+#define OC_TEST_CASE2( name, desc, uniqueSuffix ) \
+(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Name_test_, uniqueSuffix ) \
+{ \
 return @ name; \
-}\
-+(NSString*) INTERNAL_CATCH_UNIQUE_NAME( Catch_Description_test ) \
+} \
+(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Description_test_, uniqueSuffix ) \
 { \
 return @ desc; \
 } \
-(void) INTERNAL_CATCH_UNIQUE_NAME( Catch_TestCase_test )
+-(void) OC_MAKE_UNIQUE_NAME( Catch_TestCase_test_, uniqueSuffix )
+
+#define OC_TEST_CASE( name, desc ) OC_TEST_CASE2( name, desc, __LINE__ )

 #endif // TWOBLUECUBES_CATCH_OBJC_HPP_INCLUDED
--- a/include/internal/catch_random_number_generator.cpp
+++ b/include/internal/catch_random_number_generator.cpp
@@ -0,0 +1,31 @@
+/*
+ *  Created by Martin on 30/08/2017.
+ *
+ *  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)
+ */
+
+#include "catch_random_number_generator.h"
+#include "catch_context.h"
+#include "catch_interfaces_config.h"
+
+#include <cstdlib>
+
+namespace Catch {
+
+    void seedRng( IConfig const& config ) {
+        if( config.rngSeed() != 0 )
+            std::srand( config.rngSeed() );
+    }
+    unsigned int rngSeed() {
+        return getCurrentContext().getConfig()->rngSeed();
+    }
+
+    RandomNumberGenerator::result_type RandomNumberGenerator::operator()( result_type n ) const {
+        return std::rand() % n;
+    }
+    RandomNumberGenerator::result_type RandomNumberGenerator::operator()() const {
+        return std::rand() % max();
+    }
+
+}
--- a/include/internal/catch_random_number_generator.h
+++ b/include/internal/catch_random_number_generator.h
@@ -0,0 +1,40 @@
+/*
+ *  Created by Martin on 30/08/2017.
+ *
+ *  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_CATCH_RANDOM_NUMBER_GENERATOR_H_INCLUDED
+#define TWOBLUECUBES_CATCH_RANDOM_NUMBER_GENERATOR_H_INCLUDED
+
+#include "catch_random_number_generator.h"
+
+#include <algorithm>
+
+namespace Catch {
+
+    struct IConfig;
+
+    void seedRng( IConfig const& config );
+
+    unsigned int rngSeed();
+
+    struct RandomNumberGenerator {
+        using result_type = std::ptrdiff_t;
+
+        static constexpr result_type min() { return 0; }
+        static constexpr result_type max() { return 1000000; }
+
+        result_type operator()( result_type n ) const;
+        result_type operator()() const;
+
+        template<typename V>
+        static void shuffle( V& vector ) {
+            RandomNumberGenerator rng;
+            std::shuffle( vector.begin(), vector.end(), rng );
+        }
+    };
+
+}
+
+#endif // TWOBLUECUBES_CATCH_RANDOM_NUMBER_GENERATOR_H_INCLUDED
--- a/include/internal/catch_registry_hub.cpp
+++ b/include/internal/catch_registry_hub.cpp
@@ -8,8 +8,9 @@

 #include "catch_interfaces_registry_hub.h"

-#include "catch_test_case_registry_impl.hpp"
-#include "catch_reporter_registry.hpp"
+#include "catch_context.h"
+#include "catch_test_case_registry_impl.h"
+#include "catch_reporter_registry.h"
 #include "catch_exception_translator_registry.h"
 #include "catch_tag_alias_registry.h"
 #include "catch_startup_exception_registry.h"
@@ -22,8 +23,7 @@ namespace Catch {
                            private NonCopyable {

        public: // IRegistryHub
-            RegistryHub() {
-            }
+            RegistryHub() = default;
            IReporterRegistry const& getReporterRegistry() const override {
                return m_reporterRegistry;
            }
--- a/include/internal/catch_reporter_registrars.hpp
+++ b/include/internal/catch_reporter_registrars.hpp
@@ -1,3 +1,4 @@
+
 /*
 *  Created by Phil on 31/12/2010.
 *  Copyright 2010 Two Blue Cubes Ltd. All rights reserved.
@@ -39,7 +40,7 @@ namespace Catch {
        class ListenerFactory : public IReporterFactory {

            virtual IStreamingReporterPtr create( ReporterConfig const& config ) const override {
-                return std::make_shared<T>( config );
+                return std::unique_ptr<T>( new T( config ) );
            }
            virtual std::string getDescription() const override {
                return std::string();
@@ -54,14 +55,22 @@ namespace Catch {
    };
 }

-#define INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType ) \
-    namespace{ Catch::ReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); }
+#if !defined(CATCH_CONFIG_DISABLE)

-// Deprecated - use the form without INTERNAL_
-#define INTERNAL_CATCH_REGISTER_LISTENER( listenerType ) \
-    namespace{ Catch::ListenerRegistrar<listenerType> catch_internal_RegistrarFor##listenerType; }
+#define CATCH_REGISTER_REPORTER( name, reporterType ) \
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS          \
+    namespace{ Catch::ReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); } \
+    CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS

 #define CATCH_REGISTER_LISTENER( listenerType ) \
-    namespace{ Catch::ListenerRegistrar<listenerType> catch_internal_RegistrarFor##listenerType; }
+     CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS   \
+     namespace{ Catch::ListenerRegistrar<listenerType> catch_internal_RegistrarFor##listenerType; } \
+     CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+#else // CATCH_CONFIG_DISABLE
+
+#define CATCH_REGISTER_REPORTER(name, reporterType)
+#define CATCH_REGISTER_LISTENER(listenerType)
+
+#endif // CATCH_CONFIG_DISABLE

 #endif // TWOBLUECUBES_CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
--- a/include/internal/catch_reporter_registry.cpp
+++ b/include/internal/catch_reporter_registry.cpp
@@ -0,0 +1,34 @@
+/*
+ *  Created by Martin on 31/08/2017.
+ *
+ *  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)
+ */
+#include "catch_reporter_registry.h"
+
+namespace Catch {
+
+    ReporterRegistry::~ReporterRegistry() = default;
+
+    IStreamingReporterPtr ReporterRegistry::create( std::string const& name, IConfigPtr const& config ) const {
+        auto it =  m_factories.find( name );
+        if( it == m_factories.end() )
+            return nullptr;
+        return it->second->create( ReporterConfig( config ) );
+    }
+
+    void ReporterRegistry::registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) {
+        m_factories.emplace(name, factory);
+    }
+    void ReporterRegistry::registerListener( IReporterFactoryPtr const& factory ) {
+        m_listeners.push_back( factory );
+    }
+
+    IReporterRegistry::FactoryMap const& ReporterRegistry::getFactories() const {
+        return m_factories;
+    }
+    IReporterRegistry::Listeners const& ReporterRegistry::getListeners() const {
+        return m_listeners;
+    }
+
+}
--- a/include/internal/catch_reporter_registry.h
+++ b/include/internal/catch_reporter_registry.h
@@ -0,0 +1,37 @@
+/*
+ *  Created by Phil on 29/10/2010.
+ *  Copyright 2010 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_CATCH_REPORTER_REGISTRY_H_INCLUDED
+#define TWOBLUECUBES_CATCH_REPORTER_REGISTRY_H_INCLUDED
+
+#include "catch_interfaces_reporter.h"
+
+#include <map>
+
+namespace Catch {
+
+    class ReporterRegistry : public IReporterRegistry {
+
+    public:
+
+        ~ReporterRegistry() override;
+
+        IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const override;
+
+        void registerReporter( std::string const& name, IReporterFactoryPtr const& factory );
+        void registerListener( IReporterFactoryPtr const& factory );
+
+        FactoryMap const& getFactories() const override;
+        Listeners const& getListeners() const override;
+
+    private:
+        FactoryMap m_factories;
+        Listeners m_listeners;
+    };
+}
+
+#endif // TWOBLUECUBES_CATCH_REPORTER_REGISTRY_H_INCLUDED
--- a/include/internal/catch_reporter_registry.hpp
+++ b/include/internal/catch_reporter_registry.hpp
@@ -1,50 +0,0 @@
-/*
- *  Created by Phil on 29/10/2010.
- *  Copyright 2010 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_CATCH_REPORTER_REGISTRY_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_REPORTER_REGISTRY_HPP_INCLUDED
-
-#include "catch_interfaces_reporter.h"
-
-#include <map>
-
-namespace Catch {
-
-    class ReporterRegistry : public IReporterRegistry {
-
-    public:
-
-        ~ReporterRegistry() override {}
-
-        IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const override {
-            FactoryMap::const_iterator it =  m_factories.find( name );
-            if( it == m_factories.end() )
-                return nullptr;
-            return it->second->create( ReporterConfig( config ) );
-        }
-
-        void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) {
-            m_factories.insert( { name, factory } );
-        }
-        void registerListener( IReporterFactoryPtr const& factory ) {
-            m_listeners.push_back( factory );
-        }
-
-        FactoryMap const& getFactories() const override {
-            return m_factories;
-        }
-        Listeners const& getListeners() const override {
-            return m_listeners;
-        }
-
-    private:
-        FactoryMap m_factories;
-        Listeners m_listeners;
-    };
-}
-
-#endif // TWOBLUECUBES_CATCH_REPORTER_REGISTRY_HPP_INCLUDED
--- a/include/internal/catch_run_context.cpp
+++ b/include/internal/catch_run_context.cpp
@@ -1,5 +1,8 @@
-#include "catch_run_context.hpp"
+#include "catch_run_context.h"
+#include "catch_context.h"
 #include "catch_enforce.h"
+#include "catch_random_number_generator.h"
+#include "catch_stream.h"

 #include <cassert>
 #include <algorithm>
@@ -112,7 +115,10 @@ namespace Catch {
        if (result.getResultType() == ResultWas::Ok) {
            m_totals.assertions.passed++;
        } else if (!result.isOk()) {
-            m_totals.assertions.failed++;
+            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
@@ -202,11 +208,13 @@ namespace Catch {
        m_shouldReportUnexpected = false;
    }

-    void RunContext::handleFatalErrorCondition(std::string const & message) {
+    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::Unknown, { false } );
-        tempResult.resultType = ResultWas::FatalErrorCondition;
+        AssertionResultData tempResult( ResultWas::FatalErrorCondition, { false } );
        tempResult.message = message;
        AssertionResult result(m_lastAssertionInfo, tempResult);

@@ -215,7 +223,7 @@ namespace Catch {
        handleUnfinishedSections();

        // Recreate section for test case (as we will lose the one that was in scope)
-        TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
+        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description);

        Counts assertions;
@@ -223,7 +231,7 @@ namespace Catch {
        SectionStats testCaseSectionStats(testCaseSection, assertions, 0, false);
        m_reporter->sectionEnded(testCaseSectionStats);

-        TestCaseInfo testInfo = m_activeTestCase->getTestCaseInfo();
+        auto const& testInfo = m_activeTestCase->getTestCaseInfo();

        Totals deltaTotals;
        deltaTotals.testCases.failed = 1;
@@ -257,7 +265,7 @@ namespace Catch {
    }

    void RunContext::runCurrentTest(std::string & redirectedCout, std::string & redirectedCerr) {
-        TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
+        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description);
        m_reporter->sectionStarting(testCaseSection);
        Counts prevAssertions = m_totals.assertions;
@@ -297,13 +305,6 @@ namespace Catch {

        Counts assertions = m_totals.assertions - prevAssertions;
        bool missingAssertions = testForMissingAssertions(assertions);
-
-        if (testCaseInfo.okToFail()) {
-            std::swap(assertions.failedButOk, assertions.failed);
-            m_totals.assertions.failed -= assertions.failedButOk;
-            m_totals.assertions.failedButOk += assertions.failedButOk;
-        }
-
        SectionStats testCaseSectionStats(testCaseSection, assertions, duration, missingAssertions);
        m_reporter->sectionEnded(testCaseSectionStats);
    }
@@ -326,9 +327,9 @@ namespace Catch {
    }

    IResultCapture& getResultCapture() {
-        if (IResultCapture* capture = getCurrentContext().getResultCapture())
+        if (auto* capture = getCurrentContext().getResultCapture())
            return *capture;
        else
            CATCH_INTERNAL_ERROR("No result capture instance");
    }
-}
+}
--- a/include/internal/catch_run_context.hpp
+++ b/include/internal/catch_run_context.hpp
@@ -12,12 +12,12 @@
 #include "catch_interfaces_reporter.h"
 #include "catch_interfaces_exception.h"
 #include "catch_config.hpp"
-#include "catch_test_registry.hpp"
+#include "catch_test_registry.h"
 #include "catch_test_case_info.h"
 #include "catch_capture.hpp"
-#include "catch_totals.hpp"
-#include "catch_test_spec.hpp"
-#include "catch_test_case_tracker.hpp"
+#include "catch_totals.h"
+#include "catch_test_spec.h"
+#include "catch_test_case_tracker.h"
 #include "catch_timer.h"
 #include "catch_assertionhandler.h"
 #include "catch_fatal_condition.h"
@@ -26,6 +26,8 @@

 namespace Catch {

+    struct IMutableContext;
+
    class StreamRedirect {

    public:
@@ -98,7 +100,7 @@ namespace Catch {

        void exceptionEarlyReported() override;

-        void handleFatalErrorCondition(std::string const& message) override;
+        void handleFatalErrorCondition( StringRef message ) override;

        bool lastAssertionPassed() override;

@@ -133,7 +135,7 @@ namespace Catch {
        std::vector<SectionEndInfo> m_unfinishedSections;
        std::vector<ITracker*> m_activeSections;
        TrackerContext m_trackerContext;
-        size_t m_prevPassed = 0;
+        std::size_t m_prevPassed = 0;
        bool m_shouldReportUnexpected = true;
    };

--- a/include/internal/catch_section.h
+++ b/include/internal/catch_section.h
@@ -9,7 +9,7 @@
 #define TWOBLUECUBES_CATCH_SECTION_H_INCLUDED

 #include "catch_section_info.h"
-#include "catch_totals.hpp"
+#include "catch_totals.h"
 #include "catch_timer.h"

 #include <string>
--- a/include/internal/catch_section_info.h
+++ b/include/internal/catch_section_info.h
@@ -9,7 +9,7 @@
 #define TWOBLUECUBES_CATCH_SECTION_INFO_H_INCLUDED

 #include "catch_common.h"
-#include "catch_totals.hpp"
+#include "catch_totals.h"

 #include <string>

--- a/include/internal/catch_session.cpp
+++ b/include/internal/catch_session.cpp
@@ -0,0 +1,263 @@
+/*
+ *  Created by Martin on 31/08/2017.
+ *
+ *  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)
+ */
+
+#include "catch_session.h"
+#include "catch_commandline.h"
+#include "catch_console_colour.h"
+#include "catch_enforce.h"
+#include "catch_list.h"
+#include "catch_run_context.h"
+#include "catch_stream.h"
+#include "catch_test_spec.h"
+#include "catch_version.h"
+#include "catch_interfaces_reporter.h"
+#include "catch_random_number_generator.h"
+#include "catch_startup_exception_registry.h"
+#include "catch_text.h"
+
+#include <cstdlib>
+#include <iomanip>
+
+
+namespace {
+    const int MaxExitCode = 255;
+    using Catch::IStreamingReporterPtr;
+    using Catch::IConfigPtr;
+    using Catch::Config;
+
+    IStreamingReporterPtr createReporter(std::string const& reporterName, IConfigPtr const& config) {
+        auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, config);
+        CATCH_ENFORCE(reporter, "No reporter registered with name: '" << reporterName << "'");
+
+        return reporter;
+    }
+
+#ifndef CATCH_CONFIG_DEFAULT_REPORTER
+#define CATCH_CONFIG_DEFAULT_REPORTER "console"
+#endif
+
+    IStreamingReporterPtr makeReporter(std::shared_ptr<Config> const& config) {
+        auto const& reporterNames = config->getReporterNames();
+        if (reporterNames.empty())
+            return createReporter(CATCH_CONFIG_DEFAULT_REPORTER, config);
+
+        IStreamingReporterPtr reporter;
+        for (auto const& name : reporterNames)
+            addReporter(reporter, createReporter(name, config));
+        return reporter;
+    }
+
+#undef CATCH_CONFIG_DEFAULT_REPORTER
+
+    void addListeners(IStreamingReporterPtr& reporters, IConfigPtr const& config) {
+        auto const& listeners = Catch::getRegistryHub().getReporterRegistry().getListeners();
+        for (auto const& listener : listeners)
+            addReporter(reporters, listener->create(Catch::ReporterConfig(config)));
+    }
+
+
+    Catch::Totals runTests(std::shared_ptr<Config> const& config) {
+        using namespace Catch;
+        IStreamingReporterPtr reporter = makeReporter(config);
+        addListeners(reporter, config);
+
+        RunContext context(config, std::move(reporter));
+
+        Totals totals;
+
+        context.testGroupStarting(config->name(), 1, 1);
+
+        TestSpec testSpec = config->testSpec();
+        if (!testSpec.hasFilters())
+            testSpec = TestSpecParser(ITagAliasRegistry::get()).parse("~[.]").testSpec(); // All not hidden tests
+
+        auto const& allTestCases = getAllTestCasesSorted(*config);
+        for (auto const& testCase : allTestCases) {
+            if (!context.aborting() && matchTest(testCase, testSpec, *config))
+                totals += context.runTest(testCase);
+            else
+                context.reporter().skipTest(testCase);
+        }
+
+        context.testGroupEnded(config->name(), totals, 1, 1);
+        return totals;
+    }
+
+    void applyFilenamesAsTags(Catch::IConfig const& config) {
+        using namespace Catch;
+        auto& tests = const_cast<std::vector<TestCase>&>(getAllTestCasesSorted(config));
+        for (auto& testCase : tests) {
+            auto tags = testCase.tags;
+
+            std::string filename = testCase.lineInfo.file;
+            auto lastSlash = filename.find_last_of("\\/");
+            if (lastSlash != std::string::npos) {
+                filename.erase(0, lastSlash);
+                filename[0] = '#';
+            }
+
+            auto lastDot = filename.find_last_of('.');
+            if (lastDot != std::string::npos) {
+                filename.erase(lastDot);
+            }
+
+            tags.push_back(std::move(filename));
+            setTags(testCase, tags);
+        }
+    }
+
+}
+
+namespace Catch {
+
+    Session::Session() {
+        static bool alreadyInstantiated = false;
+        if( alreadyInstantiated )
+            CATCH_INTERNAL_ERROR( "Only one instance of Catch::Session can ever be used" );
+        alreadyInstantiated = true;
+        m_cli = makeCommandLineParser( m_configData );
+    }
+    Session::~Session() {
+        Catch::cleanUp();
+    }
+
+    void Session::showHelp() const {
+        Catch::cout()
+                << "\nCatch v" << libraryVersion() << "\n"
+                << m_cli << std::endl
+                << "For more detailed usage please see the project docs\n" << std::endl;
+    }
+    void Session::libIdentify() {
+        Catch::cout()
+                << std::left << std::setw(16) << "description: " << "A Catch test executable\n"
+                << std::left << std::setw(16) << "category: " << "testframework\n"
+                << std::left << std::setw(16) << "framework: " << "Catch Test\n"
+                << std::left << std::setw(16) << "version: " << libraryVersion() << std::endl;
+    }
+
+    int Session::applyCommandLine( int argc, char* argv[] ) {
+        auto result = m_cli.parse( clara::Args( argc, argv ) );
+        if( !result ) {
+            Catch::cerr()
+                << Colour( Colour::Red )
+                << "\nError(s) in input:\n"
+                << Column( result.errorMessage() ).indent( 2 )
+                << "\n\n";
+            Catch::cerr() << "Run with -? for usage\n" << std::endl;
+            return MaxExitCode;
+        }
+
+        if( m_configData.showHelp )
+            showHelp();
+        if( m_configData.libIdentify )
+            libIdentify();
+        m_config.reset();
+        return 0;
+    }
+
+    void Session::useConfigData( ConfigData const& configData ) {
+        m_configData = configData;
+        m_config.reset();
+    }
+
+    int Session::run( int argc, char* argv[] ) {
+        const auto& exceptions = getRegistryHub().getStartupExceptionRegistry().getExceptions();
+        if ( !exceptions.empty() ) {
+            Catch::cerr() << "Errors occured during startup!" << '\n';
+            // iterate over all exceptions and notify user
+            for ( const auto& ex_ptr : exceptions ) {
+                try {
+                    std::rethrow_exception(ex_ptr);
+                } catch ( std::exception const& ex ) {
+                    Catch::cerr() << ex.what() << '\n';
+                }
+            }
+            return 1;
+        }
+        int returnCode = applyCommandLine( argc, argv );
+        if( returnCode == 0 )
+            returnCode = run();
+        return returnCode;
+    }
+
+#if defined(WIN32) && defined(UNICODE)
+    int Session::run( int argc, wchar_t* const argv[] ) {
+
+        char **utf8Argv = new char *[ argc ];
+
+        for ( int i = 0; i < argc; ++i ) {
+            int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, NULL, 0, NULL, NULL );
+
+            utf8Argv[ i ] = new char[ bufSize ];
+
+            WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, NULL, NULL );
+        }
+
+        int returnCode = run( argc, utf8Argv );
+
+        for ( int i = 0; i < argc; ++i )
+            delete [] utf8Argv[ i ];
+
+        delete [] utf8Argv;
+
+        return returnCode;
+    }
+#endif
+    int Session::run() {
+        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
+            Catch::cout() << "...waiting for enter/ return before starting" << std::endl;
+            static_cast<void>(std::getchar());
+        }
+        int exitCode = runInternal();
+        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeExit ) != 0 ) {
+            Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode << std::endl;
+            static_cast<void>(std::getchar());
+        }
+        return exitCode;
+    }
+
+    clara::Parser const& Session::cli() const {
+        return m_cli;
+    }
+    void Session::cli( clara::Parser const& newParser ) {
+        m_cli = newParser;
+    }
+    ConfigData& Session::configData() {
+        return m_configData;
+    }
+    Config& Session::config() {
+        if( !m_config )
+            m_config = std::make_shared<Config>( m_configData );
+        return *m_config;
+    }
+
+    int Session::runInternal() {
+        if( m_configData.showHelp || m_configData.libIdentify )
+            return 0;
+
+        try
+        {
+            config(); // Force config to be constructed
+
+            seedRng( *m_config );
+
+            if( m_configData.filenamesAsTags )
+                applyFilenamesAsTags( *m_config );
+
+            // Handle list request
+            if( Option<std::size_t> listed = list( config() ) )
+                return static_cast<int>( *listed );
+
+            return (std::min)( MaxExitCode, static_cast<int>( runTests( m_config ).assertions.failed ) );
+        }
+        catch( std::exception& ex ) {
+            Catch::cerr() << ex.what() << std::endl;
+            return MaxExitCode;
+        }
+    }
+
+} // end namespace Catch
--- a/include/internal/catch_session.h
+++ b/include/internal/catch_session.h
@@ -0,0 +1,52 @@
+/*
+ *  Created by Phil on 31/10/2010.
+ *  Copyright 2010 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_CATCH_RUNNER_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_RUNNER_HPP_INCLUDED
+
+#include "catch_commandline.h"
+#include "catch_config.hpp"
+#include "catch_text.h"
+
+#include <memory>
+
+namespace Catch {
+
+    class Session : NonCopyable {
+    public:
+
+        Session();
+        ~Session() override;
+
+        void showHelp() const;
+        void libIdentify();
+
+        int applyCommandLine( int argc, char* argv[] );
+
+        void useConfigData( ConfigData const& configData );
+
+        int run( int argc, char* argv[] );
+    #if defined(WIN32) && defined(UNICODE)
+        int run( int argc, wchar_t* const argv[] );
+    #endif
+        int run();
+
+        clara::Parser const& cli() const;
+        void cli( clara::Parser const& newParser );
+        ConfigData& configData();
+        Config& config();
+    private:
+        int runInternal();
+
+        clara::Parser m_cli;
+        ConfigData m_configData;
+        std::shared_ptr<Config> m_config;
+    };
+
+} // end namespace Catch
+
+#endif // TWOBLUECUBES_CATCH_RUNNER_HPP_INCLUDED
--- a/include/internal/catch_stream.cpp
+++ b/include/internal/catch_stream.cpp
@@ -10,7 +10,7 @@
 #include "catch_common.h"
 #include "catch_enforce.h"
 #include "catch_stream.h"
-#include "catch_debugger.h"
+#include "catch_debug_console.h"

 #include <stdexcept>
 #include <cstdio>
@@ -18,7 +18,7 @@

 namespace Catch {

-    template<typename WriterF, size_t bufferSize=256>
+    template<typename WriterF, std::size_t bufferSize=256>
    class StreamBufImpl : public StreamBufBase {
        char data[bufferSize];
        WriterF m_writer;
@@ -57,6 +57,8 @@ namespace Catch {
    ///////////////////////////////////////////////////////////////////////////


+    Catch::IStream::~IStream() = default;
+
    FileStream::FileStream( std::string const& filename ) {
        m_ofs.open( filename.c_str() );
        CATCH_ENFORCE( !m_ofs.fail(), "Unable to open file: '" << filename << "'" );
--- a/include/internal/catch_stream.h
+++ b/include/internal/catch_stream.h
@@ -24,7 +24,7 @@ namespace Catch {


    struct IStream {
-        virtual ~IStream() noexcept;
+        virtual ~IStream();
        virtual std::ostream& stream() const = 0;
    };

@@ -32,7 +32,7 @@ namespace Catch {
        mutable std::ofstream m_ofs;
    public:
        FileStream( std::string const& filename );
-        ~FileStream() noexcept override;
+        ~FileStream() override = default;
    public: // IStream
        std::ostream& stream() const override;
    };
@@ -42,7 +42,7 @@ namespace Catch {
        mutable std::ostream m_os;
    public:
        CoutStream();
-        ~CoutStream() noexcept override;
+        ~CoutStream() override = default;

    public: // IStream
        std::ostream& stream() const override;
@@ -54,7 +54,7 @@ namespace Catch {
        mutable std::ostream m_os;
    public:
        DebugOutStream();
-        ~DebugOutStream() noexcept override;
+        ~DebugOutStream() override = default;

    public: // IStream
        std::ostream& stream() const override;
--- a/include/internal/catch_streambuf.cpp
+++ b/include/internal/catch_streambuf.cpp
@@ -0,0 +1,12 @@
+/*
+ *  Created by Martin on 31/08/2017.
+ *
+ *  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)
+ */
+
+#include "catch_streambuf.h"
+
+namespace Catch {
+    StreamBufBase::~StreamBufBase() = default;
+}
--- a/include/internal/catch_streambuf.h
+++ b/include/internal/catch_streambuf.h
@@ -8,15 +8,13 @@
 #ifndef TWOBLUECUBES_CATCH_STREAMBUF_H_INCLUDED
 #define TWOBLUECUBES_CATCH_STREAMBUF_H_INCLUDED

-#include "catch_compiler_capabilities.h"
-
 #include <streambuf>

 namespace Catch {

    class StreamBufBase : public std::streambuf {
    public:
-        virtual ~StreamBufBase() noexcept;
+        virtual ~StreamBufBase();
    };
 }

--- a/include/internal/catch_stringref.cpp
+++ b/include/internal/catch_stringref.cpp
@@ -5,12 +5,20 @@
 *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 */

+
+#if defined(__clang__)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wexit-time-destructors"
+#endif
+ 
 #include "catch_stringref.h"

 #include <ostream>
 #include <cassert>
 #include <cstring>

+
+
 namespace Catch {

    auto getEmptyStringRef() -> StringRef {
@@ -160,3 +168,7 @@ namespace Catch {
    }
        
 } // namespace Catch
+
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#endif
--- a/include/internal/catch_stringref.h
+++ b/include/internal/catch_stringref.h
@@ -25,7 +25,7 @@ namespace Catch {
    class StringRef {
        friend struct StringRefTestAccess;

-        using size_type = size_t;
+        using size_type = std::size_t;
        
        char const* m_start;
        size_type m_size;
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Phil Nash	bd46f66754	dev build 4	2017-09-19 17:42:20 +01:00
Phil Nash	e9f0773f37	Updated release notes	2017-09-19 17:36:20 +01:00
Phil Nash	54f1ce2af2	Don't use console colour if running in XCode	2017-09-19 15:25:33 +01:00
Phil Nash	0a146e3af7	OCTest project now #includes all cpp files, so they all get __OBJC__ defined	2017-09-19 14:59:12 +01:00
Phil Nash	b9ff7ec301	Fixed issues for ObjC use (see #1011 )	2017-09-19 14:38:18 +01:00
Phil Nash	a63b4a75bd	Updated OCTest project	2017-09-19 14:37:35 +01:00
Phil Nash	8da0d0473b	qualified a load of size_ts with std:: namespace (all those not from Clara)	2017-09-18 17:13:17 +01:00
Martin Hořeňovský	40209d1ae0	Use StringRef on fatal error path So far the fatal error path only uses string literals, so this removes an allocation from that context	2017-09-14 20:05:25 +02:00
Martin Hořeňovský	4e85267203	Add fatalErrorEncountered method to Reporter/Listener interface An empty default implementation is provided to keep backward compatibility. Called when signal or Structured Exception is encountered. Related to #1005	2017-09-14 19:57:59 +02:00
Martin Hořeňovský	eaf850cd0c	Do not use SEH and console api under UWP Fixes #1020	2017-09-11 21:09:35 +02:00
Martin Hořeňovský	9aa96712ae	Sweep out some extra warnings Swept: `-Wpadded` in some places (where it caused extra size, instead of just saying "hey, we padded struct at the end to align, just as standard says") `-Wweak-vtables` everywhere (Clang) `-Wexit-time-destructors` everywhere (Clang) `-Wmissing-noreturn` everywhere (Clang) The last three are enabled for Clang compilation going forward. Also enabled `-Wunreachable-code` for Clang and GCC	2017-09-07 17:25:15 +02:00
Phil Nash	6105282c4f	Removed function pointer comparison test from approvals as it has different serilaisation behaviour in MSVC	2017-09-07 15:04:30 +01:00
Phil Nash	ca7021ae19	Reflected file extension changes in CMakeLists.txt file	2017-09-07 12:58:44 +01:00
Phil Nash	03d41ce5b9	Suppressed meaningless function type qualifier warning in MSVC again (this time in catch_tostring.h)	2017-09-07 11:25:10 +01:00
Phil Nash	c5608f0202	Changed all .hpp extensions to .h where there is now a corresponding .cpp	2017-09-07 11:24:33 +01:00
Phil Nash	8c39f9a725	Suppress MSVC warning about meaningless function type qualifier in generic code	2017-09-07 11:15:07 +01:00
Phil Nash	4e5a67bc44	Added back OCTest project	2017-09-06 15:44:42 +01:00
Phil Nash	2d37649377	Fixed Objective-C mode	2017-09-06 15:44:42 +01:00
Martin Hořeňovský	8d03cb4915	Use StringRef to pass comparison operator name to BinaryExpr Some nominally C++11 platforms do not have SSO (I am looking at you libstdc++), where this avoids meaningless allocations.	2017-09-06 15:15:48 +02:00
Martin Hořeňovský	b000411434	Stop accepting non-const comparison operators A) non-const comparison operators should not exist and should not be encouraged B) The logic breaks comparing function pointers certain way C) It was inconsistent anyway, as it only applied to `==` and `!=` Closes #925	2017-09-06 15:01:03 +02:00
Martin Hořeňovský	aef2e4d9e7	Update baselines	2017-09-02 20:29:05 +02:00
Martin Hořeňovský	ab5d176195	Fix/disable failing approval tests	2017-09-02 10:51:19 +02:00
Martin Hořeňovský	b3a923133d	Actually fix AppVeyor ctest Note, this doesn't mean it will start passing, just that it will run the approval tests properly Some changes are needed before it passes, as the Windows output somewhat differs.	2017-09-01 19:12:15 +02:00
Martin Hořeňovský	35bad89684	Fix ctest failure on windows	2017-09-01 17:55:16 +02:00
Phil Nash	792d3d0a26	Fixed alignment of getSupportedVerbosities in MultipleReporters	2017-09-01 09:41:28 +01:00
offa	be067bce37	Explicit ctor used to fix compilation failures caused by copy initialization.	2017-09-01 09:40:11 +01:00
Phil Nash	115db71bab	Incorporated Clara with TextFlow fix for assertion with consecutive newlines fixes #1012	2017-08-31 16:14:27 +01:00
Martin Hořeňovský	3a5b951256	Make approval tests part of ctest	2017-08-31 12:00:35 +02:00
Martin Hořeňovský	4e4a13dfb4	Update approvals after removing deprecated matcher helpers	2017-08-31 11:50:34 +02:00
Martin Hořeňovský	e8ec6bd73c	General cleanup for C++11 Also less allocations and less stack usage on the fatal condition path	2017-08-31 11:46:37 +02:00
Martin Hořeňovský	e871742534	Move session to internal, split apart implementation	2017-08-31 10:31:52 +02:00
Martin Hořeňovský	6388fc946f	Remove last usage of NotImplementedException TeamCity reporter now uses CATCH_ERROR instead	2017-08-30 20:03:54 +02:00
Martin Hořeňovský	a4df0b2c37	Remove obsoleted utility functions on matchers Natural operators, &&, \|\| and ! are preferred and do not have limited arity.	2017-08-30 19:45:09 +02:00
Martin Hořeňovský	97edf7ce65	Fix-up compilation benchmark script	2017-08-30 18:11:52 +02:00
Martin Hořeňovský	49a1408ff2	Fix compilation of main file with CATCH_CONFIG_FAST_COMPILE	2017-08-30 18:07:29 +02:00
Martin Hořeňovský	9796c516bb	Always compile matchers implementation	2017-08-30 18:06:48 +02:00
Martin Hořeňovský	255f7d7369	Minor cleanup	2017-08-30 15:53:39 +02:00
Martin Hořeňovský	46e28791ff	Stitch .cpp files into single header in deterministic order	2017-08-30 15:43:44 +02:00
Martin Hořeňovský	0673b9be35	Split RNG related things into its own file This further removes 2 function declarations from the common path	2017-08-30 15:32:44 +02:00
Martin Hořeňovský	48db47c737	Remove unused internal macro from the common path	2017-08-30 15:30:10 +02:00
Martin Hořeňovský	cde57d9365	Remove tag alias registry interface from the common path	2017-08-30 15:28:33 +02:00
Martin Hořeňovský	13213faa4e	Update release notes in regards to CATCH_CONFIG_DISABLE	2017-08-30 12:43:23 +02:00
Martin Hořeňovský	fc495ba0cb	Dev build 3	2017-08-30 12:20:21 +02:00
Martin Hořeňovský	4dcdcc0ac3	Change developBuild to work same as *Release	2017-08-30 12:16:10 +02:00
Martin Hořeňovský	61d2c375dd	Add evaluation specialization for T* and long Fixes #1005	2017-08-30 12:11:41 +02:00
Martin Moene	07211cea9c	Add table of contents	2017-08-29 17:25:24 +02:00
Martin Moene	c5553019cc	Fix heading levels - page title (chapter): 1 - sections: 2	2017-08-29 17:25:24 +02:00
Martin Moene	66124d9e38	Make Current, Older releases sections, add subsections for each minor release	2017-08-29 17:25:24 +02:00
Martin Hořeňovský	dd8e79c529	Streamline includes in external interfaces	2017-08-29 16:44:02 +02:00
Martin Hořeňovský	4453fefb00	Remove check for compiler version before using __COUNTER__ All still supported compiler versions support __COUNTER__. User can also still turn off use of __COUNTER__ by defining CATCH_CONFIG_NO_COUNTER.	2017-08-29 15:45:58 +02:00
Martin Hořeňovský	6e46f29830	Remove empty compiler detection If they are needed in the future, they can be reinstated, but there is no point in keeping them around currently.	2017-08-29 15:40:19 +02:00
Martin Hořeňovský	92444d8b72	Remove catch_context.h from the common include path	2017-08-29 15:36:09 +02:00
Martin Hořeňovský	bcb430b837	Clean up various minor things	2017-08-29 14:02:14 +02:00
Martin Hořeňovský	5932576f53	Split writeToDebugConsole out of main path	2017-08-29 13:51:55 +02:00
Martin Hořeňovský	faead53151	Update approval test baselines after removing [hide] tag	2017-08-29 13:48:20 +02:00
Martin Hořeňovský	3b8b25c59d	Make REGISTER_TEST_CASE auto registering This also means it can be used in global scope	2017-08-29 09:52:58 +02:00
Martin Hořeňovský	75f143835e	Prevent exception translator registration with CATCH_CONFIG_DISABLE	2017-08-29 09:52:25 +02:00
Martin Hořeňovský	05b6f03f3e	Disable reporter/listener registration with CATCH_CONFIG_DISABLE	2017-08-29 09:48:52 +02:00
Martin Hořeňovský	053c29a2b8	Add partial implementation of CATCH_CONFIG_DISABLE * Assertions are defined into (void)(0) no-op * SECTIONs are defined away (leaving {} as scope) * TEST_CASEs and TEST_CASE_METHODs are not registered. * REGISTER_TEST_CASE is defined into (void)(0) no-op * METHOD_AS_TEST_CASE is defined away	2017-08-27 22:05:25 +02:00
Martin Hořeňovský	2a13593885	Update CATCH_CONFIG_FAST_COMPILE documentation Now it mentions that CHECK family of macros is affected as well	2017-08-27 16:48:15 +02:00
Martin Hořeňovský	a0988dabf6	Add the experimental benchmark feature in documentation	2017-08-27 16:47:25 +02:00
Martin Hořeňovský	8f6d6a4a2d	Remove legacy [hide] tag Also removed even legacier "./" prefix for test case name...	2017-08-27 16:45:53 +02:00
Martin Hořeňovský	e8d3be3621	Workaround raw string literal bug in VS2017	2017-08-27 12:38:59 +02:00
Martin Hořeňovský	67dc654c70	Fix updateVcpkgPackage	2017-08-27 11:48:25 +02:00
Phil Nash	b1d0085796	Tweaked how failedButOk assertions are recorded - fixes issue where sections in !shouldfail or !mayfail test cases that have failing assertions where marked as failed instead of failedButOk	2017-08-25 11:33:40 +01:00
Martin Moene	071f49b12b	Add page titles	2017-08-24 22:56:27 +02:00
Martin Hořeňovský	dee61df274	Refactor release scripts, automatically update Wandbox on release	2017-08-24 22:50:25 +02:00
Martin Moene	6c09b45a20	Let toplevel links to .md files link to .md#top	2017-08-24 19:40:36 +02:00
Martin Moene	e8225052f1	Add html anchor 'top'	2017-08-24 19:40:36 +02:00
Martin Hořeňovský	a7a9be59ff	Ignore return value of getchar when waiting for keypress Previously this was causing warnings under MSVC for ignored return value.	2017-08-22 22:00:52 +02:00
Martin Hořeňovský	cb2fceb119	Force include catch_platform.h before any if-defs Closes #994	2017-08-21 14:58:50 +02:00
Martin Hořeňovský	49f5919c41	Add partial release notes for 2.0.0	2017-08-18 20:15:00 +02:00
Martin Hořeňovský	489b639587	Change include guards in catch_external_interfaces.h Previously they weren't recognized by the generateSingleHeader.py script and weren't removed during stitching	2017-08-18 19:33:00 +02:00
Martin Hořeňovský	c7da5b5128	Remove obsolete note from reporter documentation	2017-08-18 19:33:00 +02:00
Martin Hořeňovský	3dc4de8173	Document implementation of listeners in non-main files Closes #991	2017-08-18 19:33:00 +02:00
Martin Hořeňovský	626b1d3936	Add problems with `SECTION`s in loops to documentations	2017-08-18 19:33:00 +02:00
Phil Nash	5d6c1f4dd0	Dev build 2	2017-08-18 15:58:00 +01:00
Phil Nash	3bc03cd617	Went back to Catch 1.x behaviour for -d -d takes "yes" or "no", rather than being a standalone flag option. The default is "defaultForReporter" so the previous change actually dropped some control.	2017-08-18 15:53:10 +01:00
Phil Nash	28f11a7149	Added dummy listener registration	2017-08-17 19:40:48 +01:00
Martin Hořeňovský	24af32f378	Add define that pulls in reporter and listeners interfaces This allows users to define reporters and listeners in files different from the main file. Related to #991, #986	2017-08-17 20:23:30 +02:00
Phil Nash	0545de0a31	Hold translated exception in local string while matching	2017-08-17 19:21:00 +01:00
Phil Nash	ee75b324e7	Rebased with missing [failing] tag	2017-08-17 19:21:00 +01:00
Martin Hořeňovský	597fca3c89	Remove <algorithm> header from the common path It was only used for std::max<double> within Approx, so we now have ::Catch::Detail::max(double, double) that is used instead.	2017-08-17 20:04:53 +02:00
Martin Hořeňovský	f99f511155	Removed *_REGISTER_REPORTER from main path Also simplified them to single macro: CATCH_REGISTER_REPORTER	2017-08-17 20:03:16 +02:00
Martin Hořeňovský	9a18ba042f	Remove deprecated listener registration macro	2017-08-17 20:03:16 +02:00
Martin Hořeňovský	8e6641c19b	Replace stdint.h include with cstdint include Just small unification of includes	2017-08-17 20:03:16 +02:00
Martin Hořeňovský	185573e701	Do not include c++ stitch marking in final single header	2017-08-17 20:03:15 +02:00
Phil Nash	632e023ff4	Added non-copyable test to [failing] set	2017-08-17 16:55:35 +01:00
Phil Nash	b8f482b9aa	Added test comparing non-copyable values	2017-08-17 16:48:46 +01:00
Phil Nash	aaedae60b4	Fixed issue with comparing non-copyable values	2017-08-17 16:46:05 +01:00
Phil Nash	ff9aaf3afe	Added Clara and TextFlowCpp to open source users	2017-08-17 10:48:53 +01:00
Phil Nash	e6ffbb732a	Updated conan files to use version number	2017-08-17 08:40:58 +01:00