v1.12.0

The backport fixed some bugs (ie #981), but caused strict C++98
(and MSVC 9) compilers to fail. This means that we will
reintroduce some issues but get back compatibility with obsolete
compilers. People using newer ones can keep using Catch2.

This reverts commit b6e7c9bd7a.
This reverts commit b7bd52cc98.

Should fix #1103

.conan/build.py

@@ -1,94 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-import os
-import re
-from cpt.packager import ConanMultiPackager
-from cpt.ci_manager import CIManager
-from cpt.printer import Printer
-
-
-class BuilderSettings(object):
-    @property
-    def username(self):
-        """ Set catchorg as package's owner
-        """
-        return os.getenv("CONAN_USERNAME", "catchorg")
-
-    @property
-    def login_username(self):
-        """ Set Bintray login username
-        """
-        return os.getenv("CONAN_LOGIN_USERNAME", "horenmar")
-
-    @property
-    def upload(self):
-        """ Set Catch2 repository to be used on upload.
-            The upload server address could be customized by env var
-            CONAN_UPLOAD. If not defined, the method will check the branch name.
-            Only master or CONAN_STABLE_BRANCH_PATTERN will be accepted.
-            The master branch will be pushed to testing channel, because it does
-            not match the stable pattern. Otherwise it will upload to stable
-            channel.
-        """
-        return os.getenv("CONAN_UPLOAD", "https://api.bintray.com/conan/catchorg/Catch2")
-
-    @property
-    def upload_only_when_stable(self):
-        """ Force to upload when running over tag branch
-        """
-        return os.getenv("CONAN_UPLOAD_ONLY_WHEN_STABLE", "True").lower() in ["true", "1", "yes"]
-
-    @property
-    def stable_branch_pattern(self):
-        """ Only upload the package the branch name is like a tag
-        """
-        return os.getenv("CONAN_STABLE_BRANCH_PATTERN", r"v\d+\.\d+\.\d+")
-
-    @property
-    def reference(self):
-        """ Read project version from branch create Conan reference
-        """
-        return os.getenv("CONAN_REFERENCE", "Catch2/{}".format(self._version))
-
-    @property
-    def channel(self):
-        """ Default Conan package channel when not stable
-        """
-        return os.getenv("CONAN_CHANNEL", "testing")
-
-    @property
-    def _version(self):
-        """ Get version name from cmake file
-        """
-        pattern = re.compile(r"project\(Catch2 LANGUAGES CXX VERSION (\d+\.\d+\.\d+)\)")
-        version = "latest"
-        with open("CMakeLists.txt") as file:
-            for line in file:
-                result = pattern.search(line)
-                if result:
-                    version = result.group(1)
-        return version
-
-    @property
-    def _branch(self):
-        """ Get branch name from CI manager
-        """
-        printer = Printer(None)
-        ci_manager = CIManager(printer)
-        return ci_manager.get_branch()
-
-
-if __name__ == "__main__":
-    settings = BuilderSettings()
-    builder = ConanMultiPackager(
-        reference=settings.reference,
-        channel=settings.channel,
-        upload=settings.upload,
-        upload_only_when_stable=settings.upload_only_when_stable,
-        stable_branch_pattern=settings.stable_branch_pattern,
-        login_username=settings.login_username,
-        username=settings.username,
-        test_folder=os.path.join(".conan", "test_package"))
-    builder.add()
-    builder.run()

.conan/test_package/CMakeLists.txt

@@ -1,11 +0,0 @@
-cmake_minimum_required(VERSION 3.2.0)
-project(test_package CXX)
-
-include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
-conan_basic_setup(TARGETS)
-
-find_package(Catch2 REQUIRED CONFIG)
-
-add_executable(${PROJECT_NAME} test_package.cpp)
-target_link_libraries(${PROJECT_NAME} CONAN_PKG::Catch2)
-set_target_properties(${PROJECT_NAME} PROPERTIES CXX_STANDARD 11)

.conan/test_package/conanfile.py

@@ -1,19 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-from conans import ConanFile, CMake
-import os
-
-
-class TestPackageConan(ConanFile):
-    settings = "os", "compiler", "build_type", "arch"
-    generators = "cmake"
-
-    def build(self):
-        cmake = CMake(self)
-        cmake.configure()
-        cmake.build()
-
-    def test(self):
-        assert os.path.isfile(os.path.join(self.deps_cpp_info["Catch2"].rootpath, "licenses", "LICENSE.txt"))
-        bin_path = os.path.join("bin", "test_package")
-        self.run("%s -s" % bin_path, run_environment=True)

.conan/test_package/test_package.cpp

@@ -1,15 +0,0 @@
-#define CATCH_CONFIG_MAIN
-
-#include <catch2/catch.hpp>
-
-int Factorial( int number ) {
-    return number <= 1 ? 1 : Factorial( number - 1 ) * number;
-}
-
-TEST_CASE( "Factorial Tests", "[single-file]" ) {
-    REQUIRE( Factorial(0) == 1 );
-    REQUIRE( Factorial(1) == 1 );
-    REQUIRE( Factorial(2) == 2 );
-    REQUIRE( Factorial(3) == 6 );
-    REQUIRE( Factorial(10) == 3628800 );
-}

.gitattributes

@@ -8,15 +8,4 @@
 *.hpp text
 
 # Windows specific files should retain windows line-endings
-*.sln text eol=crlf
-
-# Keep executable scripts with LFs so they can be run after being
-# checked out on Windows
-*.py text eol=lf
-
-
-# Keep the single include header with LFs to make sure it is uploaded,
-# hashed etc with LF
-single_include/**/*.hpp eol=lf
-# Also keep the LICENCE file with LFs for the same reason
-LICENCE.txt eol=lf
+*.sln text eol=crlf

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,29 +0,0 @@
----
-name: Bug report
-about: Create an issue that documents a bug
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Reproduction steps**
-Steps to reproduce the bug.
-<!-- Usually this means a small and self-contained piece of code that uses Catch and specifying compiler flags if relevant. -->
-
-
-**Platform information:**
-<!-- Fill in any extra information that might be important for your issue. -->
- - OS: **Windows NT**
- - Compiler+version: **GCC v2.9.5**
- - Catch version: **v1.2.3**
-
-
-**Additional context**
-Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,14 +0,0 @@
----
-name: Feature request
-about: Create an issue that requests a feature or other improvement
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**Description**
-Describe the feature/change you request and why do you want it.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.

.github/issue_template.md

@@ -0,0 +1,29 @@
+## Description
+<!--
+If your issue is a bugreport, this means describing what you did,
+what did you want to happen and what actually did happen.
+
+If your issue is a feature request, describe the feature and why do you
+want it.
+-->
+
+
+### Steps to reproduce
+<!--
+This is only relevant for bug reports, but if you do have one,
+please provide a minimal set of steps to reproduce the problem.
+
+Usually this means providing a small and self-contained code using Catch
+and specifying compiler flags/tools used if relevant.
+-->
+
+
+### Extra information
+<!--
+Fill in any extra information that might be important for your issue.
+
+If your issue is a bugreport, definitely fill out at least the following.
+-->
+* Catch version: **v42.42.42**
+* Operating System: **Joe's discount operating system**
+* Compiler+version: **Hidden Dragon v1.2.3**

.github/pull_request_template.md

@@ -12,7 +12,7 @@ at docs/contributing.md. It will tell you how to properly test your changes.
 <!--
 Describe the what and the why of your pull request. Remember that these two
 are usually a bit different. As an example, if you have made various changes
-to decrease the number of new strings allocated, that's what. The why probably
+to decrease the number of new strings allocated, thats what. The why probably
 was that you have a large set of tests and found that this speeds them up.
 -->
 

.gitignore

@@ -24,7 +24,6 @@ DerivedData
 *.xccheckout
 Build
 .idea
-.vs
-cmake-build-*
-benchmark-dir
-.conan/test_package/build
+cmake-build-debug
+cmake-build-release
+.vs

.travis.yml

@@ -1,16 +1,5 @@
 language: cpp
-
-branches:
-  except:
-  - /dev-appveyor.*/
-
-common_sources: &all_sources
-  - ubuntu-toolchain-r-test
-  - llvm-toolchain-trusty
-  - llvm-toolchain-trusty-3.9
-  - llvm-toolchain-trusty-4.0
-  - llvm-toolchain-trusty-5.0
-  - llvm-toolchain-trusty-6.0
+sudo: false
 
 matrix:
   include:
@@ -18,307 +7,262 @@ matrix:
     # 1/ Linux Clang Builds
     - os: linux
       compiler: clang
-      addons:
+      addons: &clang34
         apt:
-          sources: *all_sources
+          sources: ['llvm-toolchain-precise', 'ubuntu-toolchain-r-test']
+          packages: ['clang']
+      env: COMPILER='clang++' BUILD_TYPE='Release'
+
+    - os: linux
+      compiler: clang
+      addons: *clang34
+      env: COMPILER='clang++' BUILD_TYPE='Debug'
+
+    - os: linux
+      compiler: clang
+      addons: &clang35
+        apt:
+          sources: ['llvm-toolchain-precise-3.5', 'ubuntu-toolchain-r-test']
           packages: ['clang-3.5']
-      env: COMPILER='clang++-3.5'
+      env: COMPILER='clang++-3.5' BUILD_TYPE='Release'
 
     - os: linux
       compiler: clang
-      addons:
+      addons: *clang35
+      env: COMPILER='clang++-3.5' BUILD_TYPE='Debug'
+
+
+    - os: linux
+      compiler: clang
+      addons: &clang36
         apt:
-          sources: *all_sources
+          sources: ['llvm-toolchain-precise-3.6', 'ubuntu-toolchain-r-test']
           packages: ['clang-3.6']
-      env: COMPILER='clang++-3.6'
-
-    # Clang 3.7 is intentionally skipped as we cannot get it easily on
-    # TravisCI container
+      env: COMPILER='clang++-3.6' BUILD_TYPE='Release'
 
     - os: linux
       compiler: clang
-      addons:
+      addons: *clang36
+      env: COMPILER='clang++-3.6' BUILD_TYPE='Debug'
+
+
+    - os: linux
+      compiler: clang
+      addons: &clang37
         apt:
-          sources: *all_sources
-          packages: ['lcov', 'clang-3.8']
-      env: COMPILER='clang++-3.8'
+          sources: ['llvm-toolchain-precise-3.7', 'ubuntu-toolchain-r-test']
+          packages: ['clang-3.7']
+      env: COMPILER='clang++-3.7' BUILD_TYPE='Release'
 
     - os: linux
       compiler: clang
-      addons:
-          apt:
-              sources: *all_sources
-              packages: ['clang-3.9']
-      env: COMPILER='clang++-3.9'
+      addons: *clang37
+      env: COMPILER='clang++-3.7' BUILD_TYPE='Debug'
+
 
     - os: linux
       compiler: clang
-      addons:
-          apt:
-              sources: *all_sources
-              packages: ['clang-4.0']
-      env: COMPILER='clang++-4.0'
+      addons: &clang38
+        apt:
+          sources: ['llvm-toolchain-precise-3.8', 'ubuntu-toolchain-r-test']
+          packages: ['clang-3.8']
+      env: COMPILER='clang++-3.8' BUILD_TYPE='Release'
 
     - os: linux
       compiler: clang
-      addons:
-          apt:
-              sources: *all_sources
-              packages: ['clang-5.0']
-      env: COMPILER='clang++-5.0'
+      addons: *clang38
+      env: COMPILER='clang++-3.8' BUILD_TYPE='Debug'
 
-    - os: linux
-      compiler: clang
-      addons:
-          apt:
-              sources: *all_sources
-              packages: ['clang-6.0']
-      env: COMPILER='clang++-6.0'
 
     # 2/ Linux GCC Builds
     - os: linux
       compiler: gcc
-      addons:
+      addons: &gcc44
         apt:
-         sources: *all_sources
+         sources: ['ubuntu-toolchain-r-test']
+         packages: ['g++-4.4']
+      env: COMPILER='g++-4.4' BUILD_TYPE='Release'
+
+    - os: linux
+      compiler: gcc
+      addons: *gcc44
+      env: COMPILER='g++-4.4' BUILD_TYPE='Debug'
+
+
+    - os: linux
+      compiler: gcc
+      addons: &gcc47
+        apt:
+         sources: ['ubuntu-toolchain-r-test']
+         packages: ['g++-4.7']
+      env: COMPILER='g++-4.7' BUILD_TYPE='Release'
+
+    - os: linux
+      compiler: gcc
+      addons: *gcc47
+      env: COMPILER='g++-4.7' BUILD_TYPE='Debug'
+
+
+    - os: linux
+      compiler: gcc
+      addons: &gcc48
+        apt:
+         sources: ['ubuntu-toolchain-r-test']
          packages: ['g++-4.8']
-      env: COMPILER='g++-4.8'
+      env: COMPILER='g++-4.8' BUILD_TYPE='Release'
 
     - os: linux
       compiler: gcc
-      addons:
+      addons: *gcc48
+      env: COMPILER='g++-4.8' BUILD_TYPE='Debug'
+
+
+    - os: linux
+      compiler: gcc
+      addons: &gcc49
         apt:
-          sources: *all_sources
+          sources: ['ubuntu-toolchain-r-test']
           packages: ['g++-4.9']
-      env: COMPILER='g++-4.9'
+      env: COMPILER='g++-4.9' BUILD_TYPE='Release'
 
     - os: linux
       compiler: gcc
-      addons:
+      addons: *gcc49
+      env: COMPILER='g++-4.9' BUILD_TYPE='Debug'
+
+
+    - os: linux
+      compiler: gcc
+      addons: &gcc5
         apt:
-          sources: *all_sources
+          sources: ['ubuntu-toolchain-r-test']
           packages: ['g++-5']
-      env: COMPILER='g++-5'
+      env: COMPILER='g++-5' BUILD_TYPE='Release'
+
+    - os: linux
+      compiler: gcc
+      addons: *gcc5
+      env: COMPILER='g++-5' BUILD_TYPE='Debug'
+
 
     - os: linux
       compiler: gcc
       addons: &gcc6
         apt:
-          sources: *all_sources
+          sources: ['ubuntu-toolchain-r-test']
           packages: ['g++-6']
-      env: COMPILER='g++-6'
+      env: COMPILER='g++-6' BUILD_TYPE='Release'
 
     - os: linux
       compiler: gcc
-      addons: &gcc7
-        apt:
-          sources: *all_sources
-          packages: ['g++-7']
-      env: COMPILER='g++-7'
+      addons: *gcc6
+      env: COMPILER='g++-6' BUILD_TYPE='Debug'
+
+    # 3a/ Linux C++11 GCC builds
+    - os: linux
+      compiler: gcc
+      addons: *gcc48
+      env: COMPILER='g++-4.8' BUILD_TYPE='Release' CPP11=1
 
     - os: linux
       compiler: gcc
-      addons: &gcc8
-        apt:
-          sources: *all_sources
-          packages: ['g++-8']
-      env: COMPILER='g++-8'
+      addons: *gcc48
+      env: COMPILER='g++-4.8' BUILD_TYPE='Debug' CPP11=1
 
-    # 3b/ Linux C++14 Clang builds
-    # Note that we need newer libstdc++ for C++14 support
+    # 3b/ Linux C++11 Clang builds
     - os: linux
       compiler: clang
-      addons:
-          apt:
-              packages: ['clang-3.8', 'libstdc++-6-dev']
-              sources:
-                  - ubuntu-toolchain-r-test
-                  - llvm-toolchain-trusty
-      env: COMPILER='clang++-3.8' CPP14=1
+      addons: *clang38
+      env: COMPILER='clang++-3.8' BUILD_TYPE='Release' CPP11=1
 
     - os: linux
       compiler: clang
-      addons:
-          apt:
-              sources: *all_sources
-              packages: ['clang-3.9', 'libstdc++-6-dev']
-      env: COMPILER='clang++-3.9' CPP14=1
-
-    - os: linux
-      compiler: clang
-      addons:
-          apt:
-              sources: *all_sources
-              packages: ['clang-4.0', 'libstdc++-6-dev']
-      env: COMPILER='clang++-4.0' CPP14=1
-
-    - os: linux
-      compiler: clang
-      addons:
-          apt:
-              sources: *all_sources
-              packages: ['clang-5.0', 'libstdc++-6-dev']
-      env: COMPILER='clang++-5.0' CPP14=1
-
-    - os: linux
-      compiler: clang
-      addons:
-          apt:
-              sources: *all_sources
-              packages: ['clang-6.0', 'libstdc++-6-dev']
-      env: COMPILER='clang++-6.0' CPP14=1
-
+      addons: *clang38
+      env: COMPILER='clang++-3.8' BUILD_TYPE='Debug' CPP11=1
 
     # 4a/ Linux C++14 GCC builds
     - os: linux
       compiler: gcc
       addons: *gcc6
-      env: COMPILER='g++-6' CPP14=1
+      env: COMPILER='g++-6' BUILD_TYPE='Release' CPP14=1
 
     - os: linux
       compiler: gcc
-      addons: *gcc7
-      env: COMPILER='g++-7' CPP14=1
+      addons: *gcc6
+      env: COMPILER='g++-6' BUILD_TYPE='Debug' CPP14=1
+
+    # 4b/ Linux C++14 Clang builds
+#    - os: linux
+#      compiler: clang
+#      addons: *clang38
+#      env: COMPILER='clang++-3.8' BUILD_TYPE='Release' CPP14=1
+#
+#    - os: linux
+#      compiler: clang
+#      addons: *clang38
+#      env: COMPILER='clang++-3.8' BUILD_TYPE='Debug' CPP14=1
 
-    - os: linux
-      compiler: gcc
-      addons: *gcc8
-      env: COMPILER='g++-8' CPP14=1
 
     # 5/ OSX Clang Builds
     - os: osx
       osx_image: xcode7.3
       compiler: clang
-      env: COMPILER='clang++'
+      env: COMPILER='clang++' BUILD_TYPE='Debug'
+
+    - os: osx
+      osx_image: xcode7.3
+      compiler: clang
+      env: COMPILER='clang++' BUILD_TYPE='Release'
 
     - os: osx
       osx_image: xcode8
       compiler: clang
-      env: COMPILER='clang++'
+      env: COMPILER='clang++' BUILD_TYPE='Debug'
 
     - os: osx
-      osx_image: xcode9
+      osx_image: xcode8
       compiler: clang
-      env: COMPILER='clang++'
+      env: COMPILER='clang++' BUILD_TYPE='Release'
 
     - os: osx
-      osx_image: xcode9.1
+      osx_image: xcode8
       compiler: clang
-      env: COMPILER='clang++'
+      env: COMPILER='clang++' BUILD_TYPE='Debug' USE_CPP11=1
 
     - os: osx
-      osx_image: xcode9.1
+      osx_image: xcode8
       compiler: clang
-      env: COMPILER='clang++' CPP14=1
-
-    # 6/ Special builds -- examples, coverage, valgrind, etc.
-    - os: linux
-      compiler: gcc
-      addons:
-        apt:
-          sources: *all_sources
-          packages: ['lcov', 'g++-7']
-      env: COMPILER='g++-7' CPP14=1 EXAMPLES=1 COVERAGE=1 EXTRAS=1
-
-    - os: linux
-      compiler: clang
-      addons:
-        apt:
-          packages: ['clang-3.8', 'lcov']
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty
-      env: COMPILER='clang++-3.8' EXAMPLES=1 COVERAGE=1 EXTRAS=1
-
-    - os: linux
-      compiler: gcc
-      addons:
-        apt:
-          sources: *all_sources
-          packages: ['valgrind', 'lcov', 'g++-7']
-      env: COMPILER='g++-7' CPP14=1 VALGRIND=1
+      env: COMPILER='clang++' BUILD_TYPE='Release' USE_CPP11=1
 
     - os: osx
-      osx_image: xcode9.1
+      osx_image: xcode8
       compiler: clang
-      env: COMPILER='clang++' CPP14=1 EXAMPLES=1 COVERAGE=1 EXTRAS=1
+      env: COMPILER='clang++' BUILD_TYPE='Debug' USE_CPP14=1
 
-    # 7/ C++17 builds
-    - os: linux
-      compiler: gcc
-      addons: *gcc7
-      env: COMPILER='g++-7' CPP17=1
-
-    - os: linux
-      compiler: gcc
-      addons: *gcc7
-      env: COMPILER='g++-7' EXAMPLES=1 COVERAGE=1 EXTRAS=1 CPP17=1
-
-    - os: linux
+    - os: osx
+      osx_image: xcode8
       compiler: clang
-      addons:
-          apt:
-              sources: *all_sources
-              packages: ['clang-6.0', 'libstdc++-8-dev']
-      env: COMPILER='clang++-6.0' CPP17=1
+      env: COMPILER='clang++' BUILD_TYPE='Release' USE_CPP14=1
 
-    - os: linux
-      compiler: clang
-      addons:
-          apt:
-              sources: *all_sources
-              packages: ['clang-6.0', 'libstdc++-8-dev']
-      env: COMPILER='clang++-6.0' CPP17=1 EXAMPLES=1 COVERAGE=1 EXTRAS=1
-
-    # 8/ Conan
-    - language: python
-      python:
-        - "3.7"
-      dist: xenial
-      install:
-        - pip install conan==1.10.2 conan-package-tools
-      env:
-        - CONAN_GCC_VERSIONS=8
-        - CONAN_DOCKER_IMAGE=conanio/gcc8
-      script:
-        - python .conan/build.py
 
 install:
   - DEPS_DIR="${TRAVIS_BUILD_DIR}/deps"
   - mkdir -p ${DEPS_DIR} && cd ${DEPS_DIR}
   - |
     if [[ "${TRAVIS_OS_NAME}" == "linux" ]]; then
-      CMAKE_URL="http://cmake.org/files/v3.8/cmake-3.8.2-Linux-x86_64.tar.gz"
+      CMAKE_URL="http://www.cmake.org/files/v3.3/cmake-3.3.2-Linux-x86_64.tar.gz"
       mkdir cmake && travis_retry wget --no-check-certificate --quiet -O - ${CMAKE_URL} | tar --strip-components=1 -xz -C cmake
       export PATH=${DEPS_DIR}/cmake/bin:${PATH}
     elif [[ "${TRAVIS_OS_NAME}" == "osx" ]]; then
-        which cmake || brew install cmake;
+      which cmake || brew install cmake
     fi
 
 before_script:
   - export CXX=${COMPILER}
   - cd ${TRAVIS_BUILD_DIR}
-  # Regenerate single header file, so it is tested in the examples...
-  - python scripts/generateSingleHeader.py
-
-    # Use Debug builds for running Valgrind and building examples
-  - cmake -H. -BBuild-Debug -DCMAKE_BUILD_TYPE=Debug -Wdev -DUSE_CPP14=${CPP14} -DUSE_CPP17=${CPP17} -DCATCH_USE_VALGRIND=${VALGRIND} -DCATCH_BUILD_EXAMPLES=${EXAMPLES} -DCATCH_ENABLE_COVERAGE=${COVERAGE} -DCATCH_BUILD_EXTRA_TESTS=${EXTRAS}
-    # Don't bother with release build for coverage build
-  - cmake -H. -BBuild-Release -DCMAKE_BUILD_TYPE=Release -Wdev -DUSE_CPP14=${CPP14} -DUSE_CPP17=${CPP17}
-
+  - cmake -H. -BBuild -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -Wdev -DUSE_CPP11=${CPP11} -DUSE_CPP14=${CPP14}
+  - cd Build
 
 script:
-  - cd Build-Debug
   - make -j 2
-  - CTEST_OUTPUT_ON_FAILURE=1 ctest -j 2
-    # Coverage collection does not work for OS X atm
-  - |
-    if [[ "${TRAVIS_OS_NAME}" == "linux" ]] && [[ "${COVERAGE}" == "1" ]]; then
-      make gcov
-      make lcov
-      bash <(curl -s https://codecov.io/bash) -X gcov || echo "Codecov did not collect coverage reports"
-    fi
-  - # Go to release build
-  - cd ../Build-Release
-  - make -j 2
-  - CTEST_OUTPUT_ON_FAILURE=1 ctest -j 2
+  - ctest -V -j 2

CMake/Catch2Config.cmake.in

@@ -1,10 +0,0 @@
-@PACKAGE_INIT@
-
-
-# Avoid repeatedly including the targets
-if(NOT TARGET Catch2::Catch2)
-    # Provide path for scripts
-    list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}")
-
-    include(${CMAKE_CURRENT_LIST_DIR}/Catch2Targets.cmake)
-endif()

CMake/FindGcov.cmake

@@ -1,157 +0,0 @@
-# This file is part of CMake-codecov.
-#
-# Copyright (c)
-#   2015-2017 RWTH Aachen University, Federal Republic of Germany
-#
-# See the LICENSE file in the package base directory for details
-#
-# Written by Alexander Haase, alexander.haase@rwth-aachen.de
-#
-
-
-# include required Modules
-include(FindPackageHandleStandardArgs)
-
-
-# Search for gcov binary.
-set(CMAKE_REQUIRED_QUIET_SAVE ${CMAKE_REQUIRED_QUIET})
-set(CMAKE_REQUIRED_QUIET ${codecov_FIND_QUIETLY})
-
-get_property(ENABLED_LANGUAGES GLOBAL PROPERTY ENABLED_LANGUAGES)
-foreach (LANG ${ENABLED_LANGUAGES})
-	# Gcov evaluation is dependent on the used compiler. Check gcov support for
-	# each compiler that is used. If gcov binary was already found for this
-	# compiler, do not try to find it again.
-	if (NOT GCOV_${CMAKE_${LANG}_COMPILER_ID}_BIN)
-		get_filename_component(COMPILER_PATH "${CMAKE_${LANG}_COMPILER}" PATH)
-
-		if ("${CMAKE_${LANG}_COMPILER_ID}" STREQUAL "GNU")
-			# Some distributions like OSX (homebrew) ship gcov with the compiler
-			# version appended as gcov-x. To find this binary we'll build the
-			# suggested binary name with the compiler version.
-			string(REGEX MATCH "^[0-9]+" GCC_VERSION
-				"${CMAKE_${LANG}_COMPILER_VERSION}")
-
-			find_program(GCOV_BIN NAMES gcov-${GCC_VERSION} gcov
-				HINTS ${COMPILER_PATH})
-
-		elseif ("${CMAKE_${LANG}_COMPILER_ID}" STREQUAL "Clang")
-			# Some distributions like Debian ship llvm-cov with the compiler
-			# version appended as llvm-cov-x.y. To find this binary we'll build
-			# the suggested binary name with the compiler version.
-			string(REGEX MATCH "^[0-9]+.[0-9]+" LLVM_VERSION
-				"${CMAKE_${LANG}_COMPILER_VERSION}")
-
-			# llvm-cov prior version 3.5 seems to be not working with coverage
-			# evaluation tools, but these versions are compatible with the gcc
-			# gcov tool.
-			if(LLVM_VERSION VERSION_GREATER 3.4)
-				find_program(LLVM_COV_BIN NAMES "llvm-cov-${LLVM_VERSION}"
-					"llvm-cov" HINTS ${COMPILER_PATH})
-				mark_as_advanced(LLVM_COV_BIN)
-
-				if (LLVM_COV_BIN)
-					find_program(LLVM_COV_WRAPPER "llvm-cov-wrapper" PATHS
-						${CMAKE_MODULE_PATH})
-					if (LLVM_COV_WRAPPER)
-						set(GCOV_BIN "${LLVM_COV_WRAPPER}" CACHE FILEPATH "")
-
-						# set additional parameters
-						set(GCOV_${CMAKE_${LANG}_COMPILER_ID}_ENV
-							"LLVM_COV_BIN=${LLVM_COV_BIN}" CACHE STRING
-							"Environment variables for llvm-cov-wrapper.")
-						mark_as_advanced(GCOV_${CMAKE_${LANG}_COMPILER_ID}_ENV)
-					endif ()
-				endif ()
-			endif ()
-
-			if (NOT GCOV_BIN)
-				# Fall back to gcov binary if llvm-cov was not found or is
-				# incompatible. This is the default on OSX, but may crash on
-				# recent Linux versions.
-				find_program(GCOV_BIN gcov HINTS ${COMPILER_PATH})
-			endif ()
-		endif ()
-
-
-		if (GCOV_BIN)
-			set(GCOV_${CMAKE_${LANG}_COMPILER_ID}_BIN "${GCOV_BIN}" CACHE STRING
-				"${LANG} gcov binary.")
-
-			if (NOT CMAKE_REQUIRED_QUIET)
-				message("-- Found gcov evaluation for "
-				"${CMAKE_${LANG}_COMPILER_ID}: ${GCOV_BIN}")
-			endif()
-
-			unset(GCOV_BIN CACHE)
-		endif ()
-	endif ()
-endforeach ()
-
-
-
-
-# Add a new global target for all gcov targets. This target could be used to
-# generate the gcov files for the whole project instead of calling <TARGET>-gcov
-# for each target.
-if (NOT TARGET gcov)
-	add_custom_target(gcov)
-endif (NOT TARGET gcov)
-
-
-
-# This function will add gcov evaluation for target <TNAME>. Only sources of
-# this target will be evaluated and no dependencies will be added. It will call
-# Gcov on any source file of <TNAME> once and store the gcov file in the same
-# directory.
-function (add_gcov_target TNAME)
-	set(TDIR ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${TNAME}.dir)
-
-	# We don't have to check, if the target has support for coverage, thus this
-	# will be checked by add_coverage_target in Findcoverage.cmake. Instead we
-	# have to determine which gcov binary to use.
-	get_target_property(TSOURCES ${TNAME} SOURCES)
-	set(SOURCES "")
-	set(TCOMPILER "")
-	foreach (FILE ${TSOURCES})
-		codecov_path_of_source(${FILE} FILE)
-		if (NOT "${FILE}" STREQUAL "")
-			codecov_lang_of_source(${FILE} LANG)
-			if (NOT "${LANG}" STREQUAL "")
-				list(APPEND SOURCES "${FILE}")
-				set(TCOMPILER ${CMAKE_${LANG}_COMPILER_ID})
-			endif ()
-		endif ()
-	endforeach ()
-
-	# If no gcov binary was found, coverage data can't be evaluated.
-	if (NOT GCOV_${TCOMPILER}_BIN)
-		message(WARNING "No coverage evaluation binary found for ${TCOMPILER}.")
-		return()
-	endif ()
-
-	set(GCOV_BIN "${GCOV_${TCOMPILER}_BIN}")
-	set(GCOV_ENV "${GCOV_${TCOMPILER}_ENV}")
-
-
-	set(BUFFER "")
-	foreach(FILE ${SOURCES})
-		get_filename_component(FILE_PATH "${TDIR}/${FILE}" PATH)
-
-		# call gcov
-		add_custom_command(OUTPUT ${TDIR}/${FILE}.gcov
-			COMMAND ${GCOV_ENV} ${GCOV_BIN} ${TDIR}/${FILE}.gcno > /dev/null
-			DEPENDS ${TNAME} ${TDIR}/${FILE}.gcno
-			WORKING_DIRECTORY ${FILE_PATH}
-		)
-
-		list(APPEND BUFFER ${TDIR}/${FILE}.gcov)
-	endforeach()
-
-
-	# add target for gcov evaluation of <TNAME>
-	add_custom_target(${TNAME}-gcov DEPENDS ${BUFFER})
-
-	# add evaluation target to the global gcov target.
-	add_dependencies(gcov ${TNAME}-gcov)
-endfunction (add_gcov_target)

CMake/FindLcov.cmake

@@ -1,354 +0,0 @@
-# This file is part of CMake-codecov.
-#
-# Copyright (c)
-#   2015-2017 RWTH Aachen University, Federal Republic of Germany
-#
-# See the LICENSE file in the package base directory for details
-#
-# Written by Alexander Haase, alexander.haase@rwth-aachen.de
-#
-
-
-# configuration
-set(LCOV_DATA_PATH "${CMAKE_BINARY_DIR}/lcov/data")
-set(LCOV_DATA_PATH_INIT "${LCOV_DATA_PATH}/init")
-set(LCOV_DATA_PATH_CAPTURE "${LCOV_DATA_PATH}/capture")
-set(LCOV_HTML_PATH "${CMAKE_BINARY_DIR}/lcov/html")
-
-
-
-
-# Search for Gcov which is used by Lcov.
-find_package(Gcov)
-
-
-
-
-# This function will add lcov evaluation for target <TNAME>. Only sources of
-# this target will be evaluated and no dependencies will be added. It will call
-# geninfo on any source file of <TNAME> once and store the info file in the same
-# directory.
-#
-# Note: This function is only a wrapper to define this function always, even if
-#   coverage is not supported by the compiler or disabled. This function must
-#   be defined here, because the module will be exited, if there is no coverage
-#   support by the compiler or it is disabled by the user.
-function (add_lcov_target TNAME)
-	if (LCOV_FOUND)
-		# capture initial coverage data
-		lcov_capture_initial_tgt(${TNAME})
-
-		# capture coverage data after execution
-		lcov_capture_tgt(${TNAME})
-	endif ()
-endfunction (add_lcov_target)
-
-
-
-
-# include required Modules
-include(FindPackageHandleStandardArgs)
-
-# Search for required lcov binaries.
-find_program(LCOV_BIN lcov)
-find_program(GENINFO_BIN geninfo)
-find_program(GENHTML_BIN genhtml)
-find_package_handle_standard_args(lcov
-	REQUIRED_VARS LCOV_BIN GENINFO_BIN GENHTML_BIN
-)
-
-# enable genhtml C++ demangeling, if c++filt is found.
-set(GENHTML_CPPFILT_FLAG "")
-find_program(CPPFILT_BIN c++filt)
-if (NOT CPPFILT_BIN STREQUAL "")
-	set(GENHTML_CPPFILT_FLAG "--demangle-cpp")
-endif (NOT CPPFILT_BIN STREQUAL "")
-
-# enable no-external flag for lcov, if available.
-if (GENINFO_BIN AND NOT DEFINED GENINFO_EXTERN_FLAG)
-	set(FLAG "")
-	execute_process(COMMAND ${GENINFO_BIN} --help OUTPUT_VARIABLE GENINFO_HELP)
-	string(REGEX MATCH "external" GENINFO_RES "${GENINFO_HELP}")
-	if (GENINFO_RES)
-		set(FLAG "--no-external")
-	endif ()
-
-	set(GENINFO_EXTERN_FLAG "${FLAG}"
-		CACHE STRING "Geninfo flag to exclude system sources.")
-endif ()
-
-# If Lcov was not found, exit module now.
-if (NOT LCOV_FOUND)
-	return()
-endif (NOT LCOV_FOUND)
-
-
-
-
-# Create directories to be used.
-file(MAKE_DIRECTORY ${LCOV_DATA_PATH_INIT})
-file(MAKE_DIRECTORY ${LCOV_DATA_PATH_CAPTURE})
-
-set(LCOV_REMOVE_PATTERNS "")
-
-# This function will merge lcov files to a single target file. Additional lcov
-# flags may be set with setting LCOV_EXTRA_FLAGS before calling this function.
-function (lcov_merge_files OUTFILE ...)
-	# Remove ${OUTFILE} from ${ARGV} and generate lcov parameters with files.
-	list(REMOVE_AT ARGV 0)
-
-	# Generate merged file.
-	string(REPLACE "${CMAKE_BINARY_DIR}/" "" FILE_REL "${OUTFILE}")
-	add_custom_command(OUTPUT "${OUTFILE}.raw"
-		COMMAND cat ${ARGV} > ${OUTFILE}.raw
-		DEPENDS ${ARGV}
-		COMMENT "Generating ${FILE_REL}"
-	)
-
-	add_custom_command(OUTPUT "${OUTFILE}"
-		COMMAND ${LCOV_BIN} --quiet -a ${OUTFILE}.raw --output-file ${OUTFILE}
-			--base-directory ${PROJECT_SOURCE_DIR} ${LCOV_EXTRA_FLAGS}
-		COMMAND ${LCOV_BIN} --quiet -r ${OUTFILE} ${LCOV_REMOVE_PATTERNS}
-			--output-file ${OUTFILE} ${LCOV_EXTRA_FLAGS}
-		DEPENDS ${OUTFILE}.raw
-		COMMENT "Post-processing ${FILE_REL}"
-	)
-endfunction ()
-
-
-
-
-# Add a new global target to generate initial coverage reports for all targets.
-# This target will be used to generate the global initial info file, which is
-# used to gather even empty report data.
-if (NOT TARGET lcov-capture-init)
-	add_custom_target(lcov-capture-init)
-	set(LCOV_CAPTURE_INIT_FILES "" CACHE INTERNAL "")
-endif (NOT TARGET lcov-capture-init)
-
-
-# This function will add initial capture of coverage data for target <TNAME>,
-# which is needed to get also data for objects, which were not loaded at
-# execution time. It will call geninfo for every source file of <TNAME> once and
-# store the info file in the same directory.
-function (lcov_capture_initial_tgt TNAME)
-	# We don't have to check, if the target has support for coverage, thus this
-	# will be checked by add_coverage_target in Findcoverage.cmake. Instead we
-	# have to determine which gcov binary to use.
-	get_target_property(TSOURCES ${TNAME} SOURCES)
-	set(SOURCES "")
-	set(TCOMPILER "")
-	foreach (FILE ${TSOURCES})
-		codecov_path_of_source(${FILE} FILE)
-		if (NOT "${FILE}" STREQUAL "")
-			codecov_lang_of_source(${FILE} LANG)
-			if (NOT "${LANG}" STREQUAL "")
-				list(APPEND SOURCES "${FILE}")
-				set(TCOMPILER ${CMAKE_${LANG}_COMPILER_ID})
-			endif ()
-		endif ()
-	endforeach ()
-
-	# If no gcov binary was found, coverage data can't be evaluated.
-	if (NOT GCOV_${TCOMPILER}_BIN)
-		message(WARNING "No coverage evaluation binary found for ${TCOMPILER}.")
-		return()
-	endif ()
-
-	set(GCOV_BIN "${GCOV_${TCOMPILER}_BIN}")
-	set(GCOV_ENV "${GCOV_${TCOMPILER}_ENV}")
-
-
-	set(TDIR ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${TNAME}.dir)
-	set(GENINFO_FILES "")
-	foreach(FILE ${SOURCES})
-		# generate empty coverage files
-		set(OUTFILE "${TDIR}/${FILE}.info.init")
-		list(APPEND GENINFO_FILES ${OUTFILE})
-
-		add_custom_command(OUTPUT ${OUTFILE} COMMAND ${GCOV_ENV} ${GENINFO_BIN}
-				--quiet --base-directory ${PROJECT_SOURCE_DIR} --initial
-				--gcov-tool ${GCOV_BIN} --output-filename ${OUTFILE}
-				${GENINFO_EXTERN_FLAG} ${TDIR}/${FILE}.gcno
-			DEPENDS ${TNAME}
-			COMMENT "Capturing initial coverage data for ${FILE}"
-		)
-	endforeach()
-
-	# Concatenate all files generated by geninfo to a single file per target.
-	set(OUTFILE "${LCOV_DATA_PATH_INIT}/${TNAME}.info")
-	set(LCOV_EXTRA_FLAGS "--initial")
-	lcov_merge_files("${OUTFILE}" ${GENINFO_FILES})
-	add_custom_target(${TNAME}-capture-init ALL DEPENDS ${OUTFILE})
-
-	# add geninfo file generation to global lcov-geninfo target
-	add_dependencies(lcov-capture-init ${TNAME}-capture-init)
-	set(LCOV_CAPTURE_INIT_FILES "${LCOV_CAPTURE_INIT_FILES}"
-		"${OUTFILE}" CACHE INTERNAL ""
-	)
-endfunction (lcov_capture_initial_tgt)
-
-
-# This function will generate the global info file for all targets. It has to be
-# called after all other CMake functions in the root CMakeLists.txt file, to get
-# a full list of all targets that generate coverage data.
-function (lcov_capture_initial)
-	# Skip this function (and do not create the following targets), if there are
-	# no input files.
-	if ("${LCOV_CAPTURE_INIT_FILES}" STREQUAL "")
-		return()
-	endif ()
-
-	# Add a new target to merge the files of all targets.
-	set(OUTFILE "${LCOV_DATA_PATH_INIT}/all_targets.info")
-	lcov_merge_files("${OUTFILE}" ${LCOV_CAPTURE_INIT_FILES})
-	add_custom_target(lcov-geninfo-init ALL	DEPENDS ${OUTFILE}
-		lcov-capture-init
-	)
-endfunction (lcov_capture_initial)
-
-
-
-
-# Add a new global target to generate coverage reports for all targets. This
-# target will be used to generate the global info file.
-if (NOT TARGET lcov-capture)
-	add_custom_target(lcov-capture)
-	set(LCOV_CAPTURE_FILES "" CACHE INTERNAL "")
-endif (NOT TARGET lcov-capture)
-
-
-# This function will add capture of coverage data for target <TNAME>, which is
-# needed to get also data for objects, which were not loaded at execution time.
-# It will call geninfo for every source file of <TNAME> once and store the info
-# file in the same directory.
-function (lcov_capture_tgt TNAME)
-	# We don't have to check, if the target has support for coverage, thus this
-	# will be checked by add_coverage_target in Findcoverage.cmake. Instead we
-	# have to determine which gcov binary to use.
-	get_target_property(TSOURCES ${TNAME} SOURCES)
-	set(SOURCES "")
-	set(TCOMPILER "")
-	foreach (FILE ${TSOURCES})
-		codecov_path_of_source(${FILE} FILE)
-		if (NOT "${FILE}" STREQUAL "")
-			codecov_lang_of_source(${FILE} LANG)
-			if (NOT "${LANG}" STREQUAL "")
-				list(APPEND SOURCES "${FILE}")
-				set(TCOMPILER ${CMAKE_${LANG}_COMPILER_ID})
-			endif ()
-		endif ()
-	endforeach ()
-
-	# If no gcov binary was found, coverage data can't be evaluated.
-	if (NOT GCOV_${TCOMPILER}_BIN)
-		message(WARNING "No coverage evaluation binary found for ${TCOMPILER}.")
-		return()
-	endif ()
-
-	set(GCOV_BIN "${GCOV_${TCOMPILER}_BIN}")
-	set(GCOV_ENV "${GCOV_${TCOMPILER}_ENV}")
-
-
-	set(TDIR ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${TNAME}.dir)
-	set(GENINFO_FILES "")
-	foreach(FILE ${SOURCES})
-		# Generate coverage files. If no .gcda file was generated during
-		# execution, the empty coverage file will be used instead.
-		set(OUTFILE "${TDIR}/${FILE}.info")
-		list(APPEND GENINFO_FILES ${OUTFILE})
-
-		add_custom_command(OUTPUT ${OUTFILE}
-			COMMAND test -f "${TDIR}/${FILE}.gcda"
-				&& ${GCOV_ENV} ${GENINFO_BIN} --quiet --base-directory
-					${PROJECT_SOURCE_DIR} --gcov-tool ${GCOV_BIN}
-					--output-filename ${OUTFILE} ${GENINFO_EXTERN_FLAG}
-					${TDIR}/${FILE}.gcda
-				|| cp ${OUTFILE}.init ${OUTFILE}
-			DEPENDS ${TNAME} ${TNAME}-capture-init
-			COMMENT "Capturing coverage data for ${FILE}"
-		)
-	endforeach()
-
-	# Concatenate all files generated by geninfo to a single file per target.
-	set(OUTFILE "${LCOV_DATA_PATH_CAPTURE}/${TNAME}.info")
-	lcov_merge_files("${OUTFILE}" ${GENINFO_FILES})
-	add_custom_target(${TNAME}-geninfo DEPENDS ${OUTFILE})
-
-	# add geninfo file generation to global lcov-capture target
-	add_dependencies(lcov-capture ${TNAME}-geninfo)
-	set(LCOV_CAPTURE_FILES "${LCOV_CAPTURE_FILES}" "${OUTFILE}" CACHE INTERNAL
-		""
-	)
-
-	# Add target for generating html output for this target only.
-	file(MAKE_DIRECTORY ${LCOV_HTML_PATH}/${TNAME})
-	add_custom_target(${TNAME}-genhtml
-		COMMAND ${GENHTML_BIN} --quiet --sort --prefix ${PROJECT_SOURCE_DIR}
-			--baseline-file ${LCOV_DATA_PATH_INIT}/${TNAME}.info
-			--output-directory ${LCOV_HTML_PATH}/${TNAME}
-			--title "${CMAKE_PROJECT_NAME} - target ${TNAME}"
-			${GENHTML_CPPFILT_FLAG} ${OUTFILE}
-		DEPENDS ${TNAME}-geninfo ${TNAME}-capture-init
-	)
-endfunction (lcov_capture_tgt)
-
-
-# This function will generate the global info file for all targets. It has to be
-# called after all other CMake functions in the root CMakeLists.txt file, to get
-# a full list of all targets that generate coverage data.
-function (lcov_capture)
-	# Skip this function (and do not create the following targets), if there are
-	# no input files.
-	if ("${LCOV_CAPTURE_FILES}" STREQUAL "")
-		return()
-	endif ()
-
-	# Add a new target to merge the files of all targets.
-	set(OUTFILE "${LCOV_DATA_PATH_CAPTURE}/all_targets.info")
-	lcov_merge_files("${OUTFILE}" ${LCOV_CAPTURE_FILES})
-	add_custom_target(lcov-geninfo DEPENDS ${OUTFILE} lcov-capture)
-
-	# Add a new global target for all lcov targets. This target could be used to
-	# generate the lcov html output for the whole project instead of calling
-	# <TARGET>-geninfo and <TARGET>-genhtml for each target. It will also be
-	# used to generate a html site for all project data together instead of one
-	# for each target.
-	if (NOT TARGET lcov)
-		file(MAKE_DIRECTORY ${LCOV_HTML_PATH}/all_targets)
-		add_custom_target(lcov
-			COMMAND ${GENHTML_BIN} --quiet --sort
-				--baseline-file ${LCOV_DATA_PATH_INIT}/all_targets.info
-				--output-directory ${LCOV_HTML_PATH}/all_targets
-				--title "${CMAKE_PROJECT_NAME}" --prefix "${PROJECT_SOURCE_DIR}"
-				${GENHTML_CPPFILT_FLAG} ${OUTFILE}
-			DEPENDS lcov-geninfo-init lcov-geninfo
-		)
-	endif ()
-endfunction (lcov_capture)
-
-
-
-
-# Add a new global target to generate the lcov html report for the whole project
-# instead of calling <TARGET>-genhtml for each target (to create an own report
-# for each target). Instead of the lcov target it does not require geninfo for
-# all targets, so you have to call <TARGET>-geninfo to generate the info files
-# the targets you'd like to have in your report or lcov-geninfo for generating
-# info files for all targets before calling lcov-genhtml.
-file(MAKE_DIRECTORY ${LCOV_HTML_PATH}/selected_targets)
-if (NOT TARGET lcov-genhtml)
-	add_custom_target(lcov-genhtml
-		COMMAND ${GENHTML_BIN}
-			--quiet
-			--output-directory ${LCOV_HTML_PATH}/selected_targets
-			--title \"${CMAKE_PROJECT_NAME} - targets  `find
-				${LCOV_DATA_PATH_CAPTURE} -name \"*.info\" ! -name
-				\"all_targets.info\" -exec basename {} .info \\\;`\"
-			--prefix ${PROJECT_SOURCE_DIR}
-			--sort
-			${GENHTML_CPPFILT_FLAG}
-			`find ${LCOV_DATA_PATH_CAPTURE} -name \"*.info\" ! -name
-				\"all_targets.info\"`
-	)
-endif (NOT TARGET lcov-genhtml)

CMake/Findcodecov.cmake

@@ -1,258 +0,0 @@
-# This file is part of CMake-codecov.
-#
-# Copyright (c)
-#   2015-2017 RWTH Aachen University, Federal Republic of Germany
-#
-# See the LICENSE file in the package base directory for details
-#
-# Written by Alexander Haase, alexander.haase@rwth-aachen.de
-#
-
-
-# Add an option to choose, if coverage should be enabled or not. If enabled
-# marked targets will be build with coverage support and appropriate targets
-# will be added. If disabled coverage will be ignored for *ALL* targets.
-option(ENABLE_COVERAGE "Enable coverage build." OFF)
-
-set(COVERAGE_FLAG_CANDIDATES
-	# gcc and clang
-	"-O0 -g -fprofile-arcs -ftest-coverage"
-
-	# gcc and clang fallback
-	"-O0 -g --coverage"
-)
-
-
-# Add coverage support for target ${TNAME} and register target for coverage
-# evaluation. If coverage is disabled or not supported, this function will
-# simply do nothing.
-#
-# Note: This function is only a wrapper to define this function always, even if
-#   coverage is not supported by the compiler or disabled. This function must
-#   be defined here, because the module will be exited, if there is no coverage
-#   support by the compiler or it is disabled by the user.
-function (add_coverage TNAME)
-	# only add coverage for target, if coverage is support and enabled.
-	if (ENABLE_COVERAGE)
-		foreach (TNAME ${ARGV})
-			add_coverage_target(${TNAME})
-		endforeach ()
-	endif ()
-endfunction (add_coverage)
-
-
-# Add global target to gather coverage information after all targets have been
-# added. Other evaluation functions could be added here, after checks for the
-# specific module have been passed.
-#
-# Note: This function is only a wrapper to define this function always, even if
-#   coverage is not supported by the compiler or disabled. This function must
-#   be defined here, because the module will be exited, if there is no coverage
-#   support by the compiler or it is disabled by the user.
-function (coverage_evaluate)
-	# add lcov evaluation
-	if (LCOV_FOUND)
-		lcov_capture_initial()
-		lcov_capture()
-	endif (LCOV_FOUND)
-endfunction ()
-
-
-# Exit this module, if coverage is disabled. add_coverage is defined before this
-# return, so this module can be exited now safely without breaking any build-
-# scripts.
-if (NOT ENABLE_COVERAGE)
-	return()
-endif ()
-
-
-
-
-# Find the reuired flags foreach language.
-set(CMAKE_REQUIRED_QUIET_SAVE ${CMAKE_REQUIRED_QUIET})
-set(CMAKE_REQUIRED_QUIET ${codecov_FIND_QUIETLY})
-
-get_property(ENABLED_LANGUAGES GLOBAL PROPERTY ENABLED_LANGUAGES)
-foreach (LANG ${ENABLED_LANGUAGES})
-	# Coverage flags are not dependent on language, but the used compiler. So
-	# instead of searching flags foreach language, search flags foreach compiler
-	# used.
-	set(COMPILER ${CMAKE_${LANG}_COMPILER_ID})
-	if (NOT COVERAGE_${COMPILER}_FLAGS)
-		foreach (FLAG ${COVERAGE_FLAG_CANDIDATES})
-			if(NOT CMAKE_REQUIRED_QUIET)
-				message(STATUS "Try ${COMPILER} code coverage flag = [${FLAG}]")
-			endif()
-
-			set(CMAKE_REQUIRED_FLAGS "${FLAG}")
-			unset(COVERAGE_FLAG_DETECTED CACHE)
-
-			if (${LANG} STREQUAL "C")
-				include(CheckCCompilerFlag)
-				check_c_compiler_flag("${FLAG}" COVERAGE_FLAG_DETECTED)
-
-			elseif (${LANG} STREQUAL "CXX")
-				include(CheckCXXCompilerFlag)
-				check_cxx_compiler_flag("${FLAG}" COVERAGE_FLAG_DETECTED)
-
-			elseif (${LANG} STREQUAL "Fortran")
-				# CheckFortranCompilerFlag was introduced in CMake 3.x. To be
-				# compatible with older Cmake versions, we will check if this
-				# module is present before we use it. Otherwise we will define
-				# Fortran coverage support as not available.
-				include(CheckFortranCompilerFlag OPTIONAL
-					RESULT_VARIABLE INCLUDED)
-				if (INCLUDED)
-					check_fortran_compiler_flag("${FLAG}"
-						COVERAGE_FLAG_DETECTED)
-				elseif (NOT CMAKE_REQUIRED_QUIET)
-					message("-- Performing Test COVERAGE_FLAG_DETECTED")
-					message("-- Performing Test COVERAGE_FLAG_DETECTED - Failed"
-						" (Check not supported)")
-				endif ()
-			endif()
-
-			if (COVERAGE_FLAG_DETECTED)
-				set(COVERAGE_${COMPILER}_FLAGS "${FLAG}"
-					CACHE STRING "${COMPILER} flags for code coverage.")
-				mark_as_advanced(COVERAGE_${COMPILER}_FLAGS)
-				break()
-			else ()
-				message(WARNING "Code coverage is not available for ${COMPILER}"
-				        " compiler. Targets using this compiler will be "
-				        "compiled without it.")
-			endif ()
-		endforeach ()
-	endif ()
-endforeach ()
-
-set(CMAKE_REQUIRED_QUIET ${CMAKE_REQUIRED_QUIET_SAVE})
-
-
-
-
-# Helper function to get the language of a source file.
-function (codecov_lang_of_source FILE RETURN_VAR)
-	get_filename_component(FILE_EXT "${FILE}" EXT)
-	string(TOLOWER "${FILE_EXT}" FILE_EXT)
-	string(SUBSTRING "${FILE_EXT}" 1 -1 FILE_EXT)
-
-	get_property(ENABLED_LANGUAGES GLOBAL PROPERTY ENABLED_LANGUAGES)
-	foreach (LANG ${ENABLED_LANGUAGES})
-		list(FIND CMAKE_${LANG}_SOURCE_FILE_EXTENSIONS "${FILE_EXT}" TEMP)
-		if (NOT ${TEMP} EQUAL -1)
-			set(${RETURN_VAR} "${LANG}" PARENT_SCOPE)
-			return()
-		endif ()
-	endforeach()
-
-	set(${RETURN_VAR} "" PARENT_SCOPE)
-endfunction ()
-
-
-# Helper function to get the relative path of the source file destination path.
-# This path is needed by FindGcov and FindLcov cmake files to locate the
-# captured data.
-function (codecov_path_of_source FILE RETURN_VAR)
-	string(REGEX MATCH "TARGET_OBJECTS:([^ >]+)" _source ${FILE})
-
-	# If expression was found, SOURCEFILE is a generator-expression for an
-	# object library. Currently we found no way to call this function automatic
-	# for the referenced target, so it must be called in the directoryso of the
-	# object library definition.
-	if (NOT "${_source}" STREQUAL "")
-		set(${RETURN_VAR} "" PARENT_SCOPE)
-		return()
-	endif ()
-
-
-	string(REPLACE "${CMAKE_CURRENT_BINARY_DIR}/" "" FILE "${FILE}")
-	if(IS_ABSOLUTE ${FILE})
-		file(RELATIVE_PATH FILE ${CMAKE_CURRENT_SOURCE_DIR} ${FILE})
-	endif()
-
-	# get the right path for file
-	string(REPLACE ".." "__" PATH "${FILE}")
-
-	set(${RETURN_VAR} "${PATH}" PARENT_SCOPE)
-endfunction()
-
-
-
-
-# Add coverage support for target ${TNAME} and register target for coverage
-# evaluation.
-function(add_coverage_target TNAME)
-	# Check if all sources for target use the same compiler. If a target uses
-	# e.g. C and Fortran mixed and uses different compilers (e.g. clang and
-	# gfortran) this can trigger huge problems, because different compilers may
-	# use different implementations for code coverage.
-	get_target_property(TSOURCES ${TNAME} SOURCES)
-	set(TARGET_COMPILER "")
-	set(ADDITIONAL_FILES "")
-	foreach (FILE ${TSOURCES})
-		# If expression was found, FILE is a generator-expression for an object
-		# library. Object libraries will be ignored.
-		string(REGEX MATCH "TARGET_OBJECTS:([^ >]+)" _file ${FILE})
-		if ("${_file}" STREQUAL "")
-			codecov_lang_of_source(${FILE} LANG)
-			if (LANG)
-				list(APPEND TARGET_COMPILER ${CMAKE_${LANG}_COMPILER_ID})
-
-				list(APPEND ADDITIONAL_FILES "${FILE}.gcno")
-				list(APPEND ADDITIONAL_FILES "${FILE}.gcda")
-			endif ()
-		endif ()
-	endforeach ()
-
-	list(REMOVE_DUPLICATES TARGET_COMPILER)
-	list(LENGTH TARGET_COMPILER NUM_COMPILERS)
-
-	if (NUM_COMPILERS GREATER 1)
-		message(WARNING "Can't use code coverage for target ${TNAME}, because "
-		        "it will be compiled by incompatible compilers. Target will be "
-		        "compiled without code coverage.")
-		return()
-
-	elseif (NUM_COMPILERS EQUAL 0)
-		message(WARNING "Can't use code coverage for target ${TNAME}, because "
-		        "it uses an unknown compiler. Target will be compiled without "
-		        "code coverage.")
-		return()
-
-	elseif (NOT DEFINED "COVERAGE_${TARGET_COMPILER}_FLAGS")
-		# A warning has been printed before, so just return if flags for this
-		# compiler aren't available.
-		return()
-	endif()
-
-
-	# enable coverage for target
-	set_property(TARGET ${TNAME} APPEND_STRING
-		PROPERTY COMPILE_FLAGS " ${COVERAGE_${TARGET_COMPILER}_FLAGS}")
-	set_property(TARGET ${TNAME} APPEND_STRING
-		PROPERTY LINK_FLAGS " ${COVERAGE_${TARGET_COMPILER}_FLAGS}")
-
-
-	# Add gcov files generated by compiler to clean target.
-	set(CLEAN_FILES "")
-	foreach (FILE ${ADDITIONAL_FILES})
-		codecov_path_of_source(${FILE} FILE)
-		list(APPEND CLEAN_FILES "CMakeFiles/${TNAME}.dir/${FILE}")
-	endforeach()
-
-	set_directory_properties(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES
-		"${CLEAN_FILES}")
-
-
-	add_gcov_target(${TNAME})
-	add_lcov_target(${TNAME})
-endfunction(add_coverage_target)
-
-
-
-
-# Include modules for parsing the collected data and output it in a readable
-# format (like gcov and lcov).
-find_package(Gcov)
-find_package(Lcov)

CMake/MiscFunctions.cmake

@@ -1,26 +0,0 @@
-#checks that the given hard-coded list contains all headers + sources in the given folder
-function(CheckFileList LIST_VAR FOLDER)
-  set(MESSAGE " should be added to the variable ${LIST_VAR}")
-  set(MESSAGE "${MESSAGE} in ${CMAKE_CURRENT_LIST_FILE}\n")
-  file(GLOB GLOBBED_LIST "${FOLDER}/*.cpp"
-                         "${FOLDER}/*.hpp"
-                         "${FOLDER}/*.h")
-  list(REMOVE_ITEM GLOBBED_LIST ${${LIST_VAR}})
-  foreach(EXTRA_ITEM ${GLOBBED_LIST})
-    string(REPLACE "${CATCH_DIR}/" "" RELATIVE_FILE_NAME "${EXTRA_ITEM}")
-    message(AUTHOR_WARNING "The file \"${RELATIVE_FILE_NAME}\"${MESSAGE}")
-  endforeach()
-endfunction()
-
-function(CheckFileListRec LIST_VAR FOLDER)
-  set(MESSAGE " should be added to the variable ${LIST_VAR}")
-  set(MESSAGE "${MESSAGE} in ${CMAKE_CURRENT_LIST_FILE}\n")
-  file(GLOB_RECURSE GLOBBED_LIST "${FOLDER}/*.cpp"
-                                 "${FOLDER}/*.hpp"
-                                 "${FOLDER}/*.h")
-  list(REMOVE_ITEM GLOBBED_LIST ${${LIST_VAR}})
-  foreach(EXTRA_ITEM ${GLOBBED_LIST})
-    string(REPLACE "${CATCH_DIR}/" "" RELATIVE_FILE_NAME "${EXTRA_ITEM}")
-    message(AUTHOR_WARNING "The file \"${RELATIVE_FILE_NAME}\"${MESSAGE}")
-  endforeach()
-endfunction()

CMake/catch2.pc.in

@@ -1,7 +0,0 @@
-includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
-
-Name: Catch2
-Description: A modern, C++-native, header-only, test framework for C++11
-URL: https://github.com/catchorg/Catch2
-Version: @Catch2_VERSION@
-Cflags: -I${includedir}

CMake/llvm-cov-wrapper

@@ -1,56 +0,0 @@
-#!/bin/sh
-
-# This file is part of CMake-codecov.
-#
-# Copyright (c)
-#   2015-2017 RWTH Aachen University, Federal Republic of Germany
-#
-# See the LICENSE file in the package base directory for details
-#
-# Written by Alexander Haase, alexander.haase@rwth-aachen.de
-#
-
-if [ -z "$LLVM_COV_BIN" ]
-then
-	echo "LLVM_COV_BIN not set!" >& 2
-	exit 1
-fi
-
-
-# Get LLVM version to find out.
-LLVM_VERSION=$($LLVM_COV_BIN -version | grep -i "LLVM version" \
-	| sed "s/^\([A-Za-z ]*\)\([0-9]\).\([0-9]\).*$/\2.\3/g")
-
-if [ "$1" = "-v" ]
-then
-	echo "llvm-cov-wrapper $LLVM_VERSION"
-	exit 0
-fi
-
-
-if [ -n "$LLVM_VERSION" ]
-then
-	MAJOR=$(echo $LLVM_VERSION | cut -d'.' -f1)
-	MINOR=$(echo $LLVM_VERSION | cut -d'.' -f2)
-
-	if [ $MAJOR -eq 3 ] && [ $MINOR -le 4 ]
-	then
-		if [ -f "$1" ]
-		then
-			filename=$(basename "$1")
-			extension="${filename##*.}"
-
-			case "$extension" in
-				"gcno") exec $LLVM_COV_BIN --gcno="$1" ;;
-				"gcda") exec $LLVM_COV_BIN --gcda="$1" ;;
-			esac
-		fi
-	fi
-
-	if [ $MAJOR -eq 3 ] && [ $MINOR -le 5 ]
-	then
-		exec $LLVM_COV_BIN $@
-	fi
-fi
-
-exec $LLVM_COV_BIN gcov $@

CMakeLists.txt

@@ -1,29 +1,6 @@
-cmake_minimum_required(VERSION 3.5)
-
-# detect if Catch is being bundled,
-# disable testsuite in that case
-if(NOT DEFINED PROJECT_NAME)
-  set(NOT_SUBPROJECT ON)
-endif()
-
-project(Catch2 LANGUAGES CXX VERSION 2.7.2)
-
-# Provide path for scripts
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/CMake")
-
-include(GNUInstallDirs)
-include(CMakePackageConfigHelpers)
-include(CTest)
-
-option(CATCH_USE_VALGRIND "Perform SelfTests with Valgrind" OFF)
-option(CATCH_BUILD_TESTING "Build SelfTest project" ON)
-option(CATCH_BUILD_EXAMPLES "Build documentation examples" OFF)
-option(CATCH_BUILD_EXTRA_TESTS "Build extra tests" OFF)
-option(CATCH_ENABLE_COVERAGE "Generate coverage for codecov.io" OFF)
-option(CATCH_ENABLE_WERROR "Enable all warnings as errors" ON)
-option(CATCH_INSTALL_DOCS "Install documentation alongside library" ON)
-option(CATCH_INSTALL_HELPERS "Install contrib alongside library" ON)
+cmake_minimum_required(VERSION 3.0)
 
+project(CatchSelfTest)
 
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 
@@ -33,187 +10,275 @@ set(SELF_TEST_DIR ${CATCH_DIR}/projects/SelfTest)
 set(BENCHMARK_DIR ${CATCH_DIR}/projects/Benchmark)
 set(HEADER_DIR ${CATCH_DIR}/include)
 
+if(USE_CPP11)
+    ## We can't turn this on by default, since it breaks on travis
+    message(STATUS "Enabling C++11")
+    set(CMAKE_CXX_FLAGS "-std=c++11 ${CMAKE_CXX_FLAGS}")
+elseif(USE_CPP14)
+    message(STATUS "Enabling C++14")
+    set(CMAKE_CXX_FLAGS "-std=c++14 ${CMAKE_CXX_FLAGS}")
+endif()
+
 if(USE_WMAIN)
     set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /ENTRY:wmainCRTStartup")
 endif()
 
-if (BUILD_TESTING AND CATCH_BUILD_TESTING AND NOT_SUBPROJECT)
-    find_package(PythonInterp)
-    if (NOT PYTHONINTERP_FOUND)
-        message(FATAL_ERROR "Python not found, but required for tests")
+#checks that the given hard-coded list contains all headers + sources in the given folder
+function(CheckFileList LIST_VAR FOLDER)
+  set(MESSAGE " should be added to the variable ${LIST_VAR}")
+  set(MESSAGE "${MESSAGE} in ${CMAKE_CURRENT_LIST_FILE}\n")
+  file(GLOB GLOBBED_LIST "${FOLDER}/*.cpp"
+                         "${FOLDER}/*.hpp"
+                         "${FOLDER}/*.h")
+  list(REMOVE_ITEM GLOBBED_LIST ${${LIST_VAR}})
+  foreach(EXTRA_ITEM ${GLOBBED_LIST})
+    string(REPLACE "${CATCH_DIR}/" "" RELATIVE_FILE_NAME "${EXTRA_ITEM}")
+    message(AUTHOR_WARNING "The file \"${RELATIVE_FILE_NAME}\"${MESSAGE}")
+  endforeach()
+endfunction()
+
+function(CheckFileListRec LIST_VAR FOLDER)
+  set(MESSAGE " should be added to the variable ${LIST_VAR}")
+  set(MESSAGE "${MESSAGE} in ${CMAKE_CURRENT_LIST_FILE}\n")
+  file(GLOB_RECURSE GLOBBED_LIST "${FOLDER}/*.cpp"
+                                 "${FOLDER}/*.hpp"
+                                 "${FOLDER}/*.h")
+  list(REMOVE_ITEM GLOBBED_LIST ${${LIST_VAR}})
+  foreach(EXTRA_ITEM ${GLOBBED_LIST})
+    string(REPLACE "${CATCH_DIR}/" "" RELATIVE_FILE_NAME "${EXTRA_ITEM}")
+    message(AUTHOR_WARNING "The file \"${RELATIVE_FILE_NAME}\"${MESSAGE}")
+  endforeach()
+endfunction()
+
+# define the sources of the self test
+# Please keep these ordered alphabetically
+set(TEST_SOURCES
+        ${SELF_TEST_DIR}/ApproxTests.cpp
+        ${SELF_TEST_DIR}/BDDTests.cpp
+        ${SELF_TEST_DIR}/ClassTests.cpp
+        ${SELF_TEST_DIR}/CmdLineTests.cpp
+        ${SELF_TEST_DIR}/CompilationTests.cpp
+        ${SELF_TEST_DIR}/ConditionTests.cpp
+        ${SELF_TEST_DIR}/DecompositionTests.cpp
+        ${SELF_TEST_DIR}/EnumToString.cpp
+        ${SELF_TEST_DIR}/ExceptionTests.cpp
+        ${SELF_TEST_DIR}/GeneratorTests.cpp
+        ${SELF_TEST_DIR}/MessageTests.cpp
+        ${SELF_TEST_DIR}/MiscTests.cpp
+        ${SELF_TEST_DIR}/PartTrackerTests.cpp
+        ${SELF_TEST_DIR}/TagAliasTests.cpp
+        ${SELF_TEST_DIR}/TestMain.cpp
+        ${SELF_TEST_DIR}/ToStringGeneralTests.cpp
+        ${SELF_TEST_DIR}/ToStringPair.cpp
+        ${SELF_TEST_DIR}/ToStringTuple.cpp
+        ${SELF_TEST_DIR}/ToStringVector.cpp
+        ${SELF_TEST_DIR}/ToStringWhich.cpp
+        ${SELF_TEST_DIR}/TrickyTests.cpp
+        ${SELF_TEST_DIR}/VariadicMacrosTests.cpp
+        ${SELF_TEST_DIR}/MatchersTests.cpp
+        )
+CheckFileList(TEST_SOURCES ${SELF_TEST_DIR})
+
+# A set of impl files that just #include a single header
+# Please keep these ordered alphabetically
+set(IMPL_SOURCES
+        ${SELF_TEST_DIR}/SurrogateCpps/catch_common.cpp
+        ${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_generators.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_message.cpp
+        ${SELF_TEST_DIR}/SurrogateCpps/catch_option.cpp
+        ${SELF_TEST_DIR}/SurrogateCpps/catch_ptr.cpp
+        ${SELF_TEST_DIR}/SurrogateCpps/catch_stream.cpp
+        ${SELF_TEST_DIR}/SurrogateCpps/catch_streambuf.cpp
+        ${SELF_TEST_DIR}/SurrogateCpps/catch_test_spec.cpp
+        ${SELF_TEST_DIR}/SurrogateCpps/catch_xmlwriter.cpp
+        ${SELF_TEST_DIR}/SurrogateCpps/catch_test_case_tracker.cpp
+        )
+CheckFileList(IMPL_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})
+
+# Please keep these ordered alphabetically
+set(EXTERNAL_HEADERS
+        ${HEADER_DIR}/external/clara.h
+        ${HEADER_DIR}/external/tbc_text_format.h
+        )
+CheckFileList(EXTERNAL_HEADERS ${HEADER_DIR}/external)
+
+
+# Please keep these ordered alphabetically
+set(INTERNAL_HEADERS
+        ${HEADER_DIR}/internal/catch_approx.hpp
+        ${HEADER_DIR}/internal/catch_assertionresult.h
+        ${HEADER_DIR}/internal/catch_assertionresult.hpp
+        ${HEADER_DIR}/internal/catch_capture.hpp
+        ${HEADER_DIR}/internal/catch_clara.h
+        ${HEADER_DIR}/internal/catch_commandline.hpp
+        ${HEADER_DIR}/internal/catch_common.h
+        ${HEADER_DIR}/internal/catch_common.hpp
+        ${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_impl.hpp
+        ${HEADER_DIR}/internal/catch_context.h
+        ${HEADER_DIR}/internal/catch_context_impl.hpp
+        ${HEADER_DIR}/internal/catch_debugger.h
+        ${HEADER_DIR}/internal/catch_debugger.hpp
+        ${HEADER_DIR}/internal/catch_default_main.hpp
+        ${HEADER_DIR}/internal/catch_errno_guard.hpp
+        ${HEADER_DIR}/internal/catch_evaluate.hpp
+        ${HEADER_DIR}/internal/catch_exception_translator_registry.hpp
+        ${HEADER_DIR}/internal/catch_expression_lhs.hpp
+        ${HEADER_DIR}/internal/catch_fatal_condition.hpp
+        ${HEADER_DIR}/internal/catch_generators.hpp
+        ${HEADER_DIR}/internal/catch_generators_impl.hpp
+        ${HEADER_DIR}/internal/catch_impl.hpp
+        ${HEADER_DIR}/internal/catch_interfaces_capture.h
+        ${HEADER_DIR}/internal/catch_interfaces_config.h
+        ${HEADER_DIR}/internal/catch_interfaces_exception.h
+        ${HEADER_DIR}/internal/catch_interfaces_generators.h
+        ${HEADER_DIR}/internal/catch_interfaces_registry_hub.h
+        ${HEADER_DIR}/internal/catch_interfaces_reporter.h
+        ${HEADER_DIR}/internal/catch_interfaces_runner.h
+        ${HEADER_DIR}/internal/catch_interfaces_tag_alias_registry.h
+        ${HEADER_DIR}/internal/catch_interfaces_testcase.h
+        ${HEADER_DIR}/internal/catch_legacy_reporter_adapter.h
+        ${HEADER_DIR}/internal/catch_legacy_reporter_adapter.hpp
+        ${HEADER_DIR}/internal/catch_list.hpp
+        ${HEADER_DIR}/internal/catch_matchers.hpp
+        ${HEADER_DIR}/internal/catch_matchers_string.h
+        ${HEADER_DIR}/internal/catch_matchers_string.hpp
+        ${HEADER_DIR}/internal/catch_matchers_vector.h
+        ${HEADER_DIR}/internal/catch_message.h
+        ${HEADER_DIR}/internal/catch_message.hpp
+        ${HEADER_DIR}/internal/catch_notimplemented_exception.h
+        ${HEADER_DIR}/internal/catch_notimplemented_exception.hpp
+        ${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_ptr.hpp
+        ${HEADER_DIR}/internal/catch_reenable_warnings.h
+        ${HEADER_DIR}/internal/catch_registry_hub.hpp
+        ${HEADER_DIR}/internal/catch_reporter_registrars.hpp
+        ${HEADER_DIR}/internal/catch_reporter_registry.hpp
+        ${HEADER_DIR}/internal/catch_result_builder.h
+        ${HEADER_DIR}/internal/catch_result_builder.hpp
+        ${HEADER_DIR}/internal/catch_result_type.h
+        ${HEADER_DIR}/internal/catch_run_context.hpp
+        ${HEADER_DIR}/internal/catch_section.h
+        ${HEADER_DIR}/internal/catch_section.hpp
+        ${HEADER_DIR}/internal/catch_section_info.h
+        ${HEADER_DIR}/internal/catch_section_info.hpp
+        ${HEADER_DIR}/internal/catch_stream.h
+        ${HEADER_DIR}/internal/catch_stream.hpp
+        ${HEADER_DIR}/internal/catch_streambuf.h
+        ${HEADER_DIR}/internal/catch_suppress_warnings.h
+        ${HEADER_DIR}/internal/catch_tag_alias.h
+        ${HEADER_DIR}/internal/catch_tag_alias_registry.h
+        ${HEADER_DIR}/internal/catch_tag_alias_registry.hpp
+        ${HEADER_DIR}/internal/catch_test_case_info.h
+        ${HEADER_DIR}/internal/catch_test_case_info.hpp
+        ${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_text.h
+        ${HEADER_DIR}/internal/catch_timer.h
+        ${HEADER_DIR}/internal/catch_timer.hpp
+        ${HEADER_DIR}/internal/catch_tostring.h
+        ${HEADER_DIR}/internal/catch_tostring.hpp
+        ${HEADER_DIR}/internal/catch_totals.hpp
+        ${HEADER_DIR}/internal/catch_type_traits.hpp
+        ${HEADER_DIR}/internal/catch_version.h
+        ${HEADER_DIR}/internal/catch_version.hpp
+        ${HEADER_DIR}/internal/catch_wildcard_pattern.hpp
+        ${HEADER_DIR}/internal/catch_windows_h_proxy.h
+        ${HEADER_DIR}/internal/catch_xmlwriter.hpp
+        )
+CheckFileList(INTERNAL_HEADERS ${HEADER_DIR}/internal)
+
+# Please keep these ordered alphabetically
+set(REPORTER_HEADERS
+        ${HEADER_DIR}/reporters/catch_reporter_automake.hpp
+        ${HEADER_DIR}/reporters/catch_reporter_bases.hpp
+        ${HEADER_DIR}/reporters/catch_reporter_compact.hpp
+        ${HEADER_DIR}/reporters/catch_reporter_console.hpp
+        ${HEADER_DIR}/reporters/catch_reporter_junit.hpp
+        ${HEADER_DIR}/reporters/catch_reporter_multi.hpp
+        ${HEADER_DIR}/reporters/catch_reporter_tap.hpp
+        ${HEADER_DIR}/reporters/catch_reporter_teamcity.hpp
+        ${HEADER_DIR}/reporters/catch_reporter_xml.hpp
+        )
+CheckFileList(REPORTER_HEADERS ${HEADER_DIR}/reporters)
+
+# Specify the headers, too, so CLion recognises them as project files
+set(HEADERS
+        ${TOP_LEVEL_HEADERS}
+        ${EXTERNAL_HEADERS}
+        ${INTERNAL_HEADERS}
+        ${REPORTER_HEADERS}
+        )
+
+
+set(BENCH_SOURCES
+        ${BENCHMARK_DIR}/BenchMain.cpp
+        ${BENCHMARK_DIR}/StringificationBench.cpp
+        )
+CheckFileList(BENCH_SOURCES ${BENCHMARK_DIR})
+
+# Provide some groupings for IDEs
+SOURCE_GROUP("Tests" FILES ${TEST_SOURCES})
+SOURCE_GROUP("Surrogates" FILES ${IMPL_SOURCES})
+SOURCE_GROUP("Benchmarks" FILES ${BENCH_SOURCES})
+
+# configure the executable
+include_directories(${HEADER_DIR})
+
+# Projects consuming Catch via ExternalProject_Add might want to use install step
+# without building all of our selftests.
+if (NOT NO_SELFTEST)
+    add_executable(SelfTest ${TEST_SOURCES} ${IMPL_SOURCES} ${HEADERS})
+    add_executable(Benchmark ${BENCH_SOURCES} ${HEADERS})
+
+    # 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 )
     endif()
-    add_subdirectory(projects)
-endif()
-
-if(CATCH_BUILD_EXAMPLES)
-    add_subdirectory(examples)
-endif()
-
-if(CATCH_BUILD_EXTRA_TESTS)
-    add_subdirectory(projects/ExtraTests)
-endif()
-
-# add catch as a 'linkable' target
-add_library(Catch2 INTERFACE)
-
-
-
-# depend on some obvious c++11 features so the dependency is transitively added dependents
-target_compile_features(Catch2
-  INTERFACE
-    cxx_alignas
-    cxx_alignof
-    cxx_attributes
-    cxx_auto_type
-    cxx_constexpr
-    cxx_defaulted_functions
-    cxx_deleted_functions
-    cxx_final
-    cxx_lambdas
-    cxx_noexcept
-    cxx_override
-    cxx_range_for
-    cxx_rvalue_references
-    cxx_static_assert
-    cxx_strong_enums
-    cxx_trailing_return_types
-    cxx_unicode_literals
-    cxx_user_literals
-    cxx_variadic_macros
-)
-
-target_include_directories(Catch2
-  INTERFACE
-    $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/single_include>
-    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-)
-
-# provide a namespaced alias for clients to 'link' against if catch is included as a sub-project
-add_library(Catch2::Catch2 ALIAS Catch2)
-
-# Only perform the installation steps when Catch is not being used as
-# a subproject via `add_subdirectory`, or the destinations will break,
-# see https://github.com/catchorg/Catch2/issues/1373
-if (NOT_SUBPROJECT)
-    set(CATCH_CMAKE_CONFIG_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/Catch2")
-
-    configure_package_config_file(
-        ${CMAKE_CURRENT_LIST_DIR}/CMake/Catch2Config.cmake.in
-        ${CMAKE_CURRENT_BINARY_DIR}/Catch2Config.cmake
-        INSTALL_DESTINATION
-          ${CATCH_CMAKE_CONFIG_DESTINATION}
-    )
-
-
-    # create and install an export set for catch target as Catch2::Catch
-    install(
-      TARGETS
-        Catch2
-      EXPORT
-        Catch2Targets
-      DESTINATION
-        ${CMAKE_INSTALL_LIBDIR}
-    )
-
-
-    install(
-      EXPORT
-        Catch2Targets
-      NAMESPACE
-        Catch2::
-      DESTINATION
-        ${CATCH_CMAKE_CONFIG_DESTINATION}
-    )
-
-    # By default, FooConfigVersion is tied to architecture that it was
-    # generated on. Because Catch2 is header-only, it is arch-independent
-    # and thus Catch2ConfigVersion should not be tied to the architecture
-    # it was generated on.
-    #
-    # CMake does not provide a direct customization point for this in
-    # `write_basic_package_version_file`, but it can be accomplished
-    # indirectly by temporarily undefining `CMAKE_SIZEOF_VOID_P`.
-    set(CATCH2_CMAKE_SIZEOF_VOID_P ${CMAKE_SIZEOF_VOID_P})
-    unset(CMAKE_SIZEOF_VOID_P)
-    write_basic_package_version_file(
-      "${CMAKE_CURRENT_BINARY_DIR}/Catch2ConfigVersion.cmake"
-      COMPATIBILITY
-        SameMajorVersion
-    )
-    set(CMAKE_SIZEOF_VOID_P ${CATCH2_CMAKE_SIZEOF_VOID_P})
-
-    install(
-      DIRECTORY
-        "single_include/"
-      DESTINATION
-        "${CMAKE_INSTALL_INCLUDEDIR}"
-    )
-
-    install(
-      FILES
-        "${CMAKE_CURRENT_BINARY_DIR}/Catch2Config.cmake"
-        "${CMAKE_CURRENT_BINARY_DIR}/Catch2ConfigVersion.cmake"
-      DESTINATION
-        ${CATCH_CMAKE_CONFIG_DESTINATION}
-    )
-
-    # Install documentation
-    if(CATCH_INSTALL_DOCS)
-      install(
-        DIRECTORY
-          docs/
-        DESTINATION
-          "${CMAKE_INSTALL_DOCDIR}"
-      )
+    if ( CMAKE_CXX_COMPILER_ID MATCHES "MSVC" )
+        target_compile_options( SelfTest PRIVATE /W4 /w44265 /WX )
+        target_compile_options( Benchmark PRIVATE /W4 )
     endif()
 
-    if(CATCH_INSTALL_HELPERS)
-    # Install CMake scripts
-    install(
-      FILES
-        "contrib/ParseAndAddCatchTests.cmake"
-        "contrib/Catch.cmake"
-        "contrib/CatchAddTests.cmake"
-      DESTINATION
-        ${CATCH_CMAKE_CONFIG_DESTINATION}
-    )
 
-    # Install debugger helpers
-    install(
-      FILES
-        "contrib/gdbinit"
-        "contrib/lldbinit"
-      DESTINATION
-        ${CMAKE_INSTALL_DATAROOTDIR}/Catch2
-    )
-    endif()
+    # configure unit tests via CTest
+    enable_testing()
+    add_test(NAME RunTests COMMAND SelfTest)
 
-    ## Provide some pkg-config integration
-    set(PKGCONFIG_INSTALL_DIR
-        "${CMAKE_INSTALL_DATAROOTDIR}/pkgconfig"
-        CACHE PATH "Path where catch2.pc is installed"
-    )
-    configure_file(
-      ${CMAKE_CURRENT_SOURCE_DIR}/CMake/catch2.pc.in
-      ${CMAKE_CURRENT_BINARY_DIR}/catch2.pc
-      @ONLY
-    )
-    install(
-      FILES
-        "${CMAKE_CURRENT_BINARY_DIR}/catch2.pc"
-      DESTINATION
-        ${PKGCONFIG_INSTALL_DIR}
-    )
+    add_test(NAME ListTests COMMAND SelfTest --list-tests)
+    set_tests_properties(ListTests PROPERTIES PASS_REGULAR_EXPRESSION "[0-9]+ test cases")
 
-    # CPack/CMake started taking the package version from project version 3.12
-    # So we need to set the version manually for older CMake versions
-    if(${CMAKE_VERSION} VERSION_LESS "3.12.0")
-        set(CPACK_PACKAGE_VERSION ${PROJECT_VERSION})
-    endif()
+    add_test(NAME ListTags COMMAND SelfTest --list-tags)
+    set_tests_properties(ListTags PROPERTIES PASS_REGULAR_EXPRESSION "[0-9]+ tags")
 
-    set(CPACK_PACKAGE_CONTACT "https://github.com/catchorg/Catch2/")
+endif() # !NO_SELFTEST
 
 
-    include( CPack )
-
-endif(NOT_SUBPROJECT)
+install(DIRECTORY "single_include/" DESTINATION "include/catch")

README.md

@@ -1,38 +1,28 @@
-<a id="top"></a>
-![catch logo](artwork/catch2-logo-small.png)
+![catch logo](catch-logo-small.png)
 
-[![Github Releases](https://img.shields.io/github/release/catchorg/catch2.svg)](https://github.com/catchorg/catch2/releases)
-[![Build Status](https://travis-ci.org/catchorg/Catch2.svg?branch=master)](https://travis-ci.org/catchorg/Catch2)
-[![Build status](https://ci.appveyor.com/api/projects/status/github/catchorg/Catch2?svg=true)](https://ci.appveyor.com/project/catchorg/catch2)
-[![codecov](https://codecov.io/gh/catchorg/Catch2/branch/master/graph/badge.svg)](https://codecov.io/gh/catchorg/Catch2)
-[![Try online](https://img.shields.io/badge/try-online-blue.svg)](https://wandbox.org/permlink/rsEsNO9M0flb5NlQ)
-[![Join the chat in Discord: https://discord.gg/4CWS9zD](https://img.shields.io/badge/Discord-Chat!-brightgreen.svg)](https://discord.gg/4CWS9zD)
+[![Github Releases](https://img.shields.io/github/release/philsquared/catch.svg)](https://github.com/philsquared/catch/releases)
+[![Build Status](https://travis-ci.org/philsquared/Catch.svg?branch=master)](https://travis-ci.org/philsquared/Catch)
+[![Build status](https://ci.appveyor.com/api/projects/status/hrtk60hv6tw6fght/branch/master?svg=true)](https://ci.appveyor.com/project/philsquared/catch/branch/master)
+[![Try online](https://img.shields.io/badge/try-online-blue.svg)](https://wandbox.org/permlink/hgiYhcvH835lHvaA)
 
-
-<a href="https://github.com/catchorg/Catch2/releases/download/v2.7.2/catch.hpp">The latest version of the single header can be downloaded directly using this link</a>
-
-## Catch2 is released!
-
-If you've been using an earlier version of Catch, please see the
-Breaking Changes section of [the release notes](https://github.com/catchorg/Catch2/releases/tag/v2.0.1)
-before moving to Catch2. You might also like to read [this blog post](https://levelofindirection.com/blog/catch2-released.html) for more details.
+<a href="https://github.com/philsquared/Catch/releases/download/v1.12.0/catch.hpp">The latest, single header, version can be downloaded directly using this link</a>
 
 ## What's the Catch?
 
-Catch2 stands for C++ Automated Test Cases in a Header and is a
-multi-paradigm test framework for C++. which also supports Objective-C
-(and maybe C).
-It is primarily distributed as a single header file, although certain
-extensions may require additional headers.
+Catch stands for C++ Automated Test Cases in Headers and is a multi-paradigm automated test framework for C++ and Objective-C (and, maybe, C). It is implemented entirely in a set of header files, but is packaged up as a single header for extra convenience.
 
 ## How to use it
 This documentation comprises these three parts:
 
-* [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
+* [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
 
 ## More
-* Issues and bugs can be raised on the [Issue tracker on GitHub](https://github.com/catchorg/Catch2/issues)
-* For discussion or questions please use [the dedicated Google Groups forum](https://groups.google.com/forum/?fromgroups#!forum/catch-forum) or our [Discord](https://discord.gg/4CWS9zD)
-* See [who else is using Catch2](docs/opensource-users.md#top)
+* 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)
+
+## Help us out
+We're currently running [a survey](https://www.surveymonkey.co.uk/r/TLLYQJW) to help us shape the future of Catch.
+Please take a few moments to fill it out (there's only ten questions).

appveyor.yml

@@ -1,13 +1,10 @@
 # version string format -- This will be overwritten later anyway
 version: "{build}"
 
-branches:
-  except:
-    - /dev-travis.+/
-
 os:
   - Visual Studio 2017
   - Visual Studio 2015
+  - Visual Studio 2013
 
 environment:
     matrix:
@@ -19,51 +16,23 @@ environment:
 
         - additional_flags: "/D_UNICODE /DUNICODE"
           wmain: 1
-          coverage: 0
-
-        # Have a coverage dimension
-        - additional_flags: ""
-          wmain: 0
-          coverage: 1
-
-        # Have an examples dimension
-        - additional_flags: ""
-          wmain: 0
-          examples: 1
-
 
 matrix:
     exclude:
-        - os: Visual Studio 2015
-          additional_flags: "/permissive- /std:c++latest"
+        -
+            additional_flags: "/permissive- /std:c++latest"
+            os: Visual Studio 2015
+        -
+            additional_flags: "/permissive- /std:c++latest"
+            os: Visual Studio 2013
 
-        - os: Visual Studio 2015
-          additional_flags: "/D_UNICODE /DUNICODE"
+init:
+  - git config --global core.autocrlf input
+  # Set build version to git commit-hash
+  - ps: Update-AppveyorBuild -Version "$($env:APPVEYOR_REPO_BRANCH) - $($env:APPVEYOR_REPO_COMMIT)"
 
-        # Exclude unwanted coverage configurations
-        - coverage: 1
-          platform: Win32
-
-        - coverage: 1
-          os: Visual Studio 2015
-
-        - coverage: 1
-          configuration: Release
-
-        # Exclude unwanted examples configurations
-        - examples: 1
-          platform: Win32
-
-        - examples: 1
-          os: Visual Studio 2015
-
-        - examples: 1
-          configuration: Release
-
-
-install:
-  - ps: if (($env:CONFIGURATION) -eq "Debug" -And ($env:coverage) -eq "1" ) { python -m pip --disable-pip-version-check install codecov }
-  - ps: if (($env:CONFIGURATION) -eq "Debug" -And ($env:coverage) -eq "1" ) { .\misc\installOpenCppCoverage.ps1 }
+# fetch repository as zip archive
+shallow_clone: true
 
 # Win32 and x64 are CMake-compatible solution platform names.
 # This allows us to pass %PLATFORM% to CMake -A.
@@ -79,18 +48,14 @@ configuration:
 #Cmake will autodetect the compiler, but we set the arch
 before_build:
   - set CXXFLAGS=%additional_flags%
-  # Indirection because appveyor doesn't handle multiline batch scripts properly
-  # https://stackoverflow.com/questions/37627248/how-to-split-a-command-over-multiple-lines-in-appveyor-yml/37647169#37647169
-  # https://help.appveyor.com/discussions/questions/3888-multi-line-cmd-or-powershell-warning-ignore
-  - cmd: .\misc\appveyorBuildConfigurationScript.bat
-
+  - cmake -H. -BBuild -A%PLATFORM% -DUSE_WMAIN=%wmain%
 
 # build with MSBuild
 build:
-  project: Build\Catch2.sln             # path to Visual Studio solution or project
+  project: Build\CatchSelfTest.sln      # path to Visual Studio solution or project
   parallel: true                        # enable MSBuild parallel builds
   verbosity: normal                     # MSBuild verbosity level {quiet|minimal|normal|detailed}
 
 test_script:
-  - set CTEST_OUTPUT_ON_FAILURE=1
-  - cmd: .\misc\appveyorTestRunScript.bat
+  - cd Build
+  - ctest -V -j 2 -C %CONFIGURATION%

codecov.yml

@@ -1,24 +0,0 @@
-coverage:
-  precision: 2
-  round: nearest
-  range: "60...90"
-  status:
-    project:
-      default:
-        threshold: 2%
-    patch:
-      default:
-        target: 80%
-  ignore:
-    - "projects/SelfTest"
-    - "**/catch_reporter_tap.hpp"
-    - "**/catch_reporter_automake.hpp"
-    - "**/catch_reporter_teamcity.hpp"
-    - "**/external/clara.hpp"
-
-
-codecov:
-  branch: master
-
-comment:
-  layout: "diff"

conanfile.py

@@ -1,27 +1,19 @@
 #!/usr/bin/env python
-from conans import ConanFile, CMake
+from conans import ConanFile
 
 
 class CatchConan(ConanFile):
-    name = "Catch2"
+    name = "Catch"
+    version = "1.12.0"
     description = "A modern, C++-native, header-only, framework for unit-tests, TDD and BDD"
-    topics = ("conan", "catch2", "header-only", "unit-test", "tdd", "bdd")
-    url = "https://github.com/catchorg/Catch2"
-    homepage = url
-    license = "BSL-1.0"
-    exports = "LICENSE.txt"
-    exports_sources = ("single_include/*", "CMakeLists.txt", "CMake/*", "contrib/*")
+    author = "philsquared"
     generators = "cmake"
+    exports_sources = "single_include/*"
+    url = "https://github.com/philsquared/Catch"
+    license = "Boost Software License - Version 1.0. http://www.boost.org/LICENSE_1_0.txt"
 
     def package(self):
-        cmake = CMake(self)
-        cmake.definitions["BUILD_TESTING"] = "OFF"
-        cmake.definitions["CATCH_INSTALL_DOCS"] = "OFF"
-        cmake.definitions["CATCH_INSTALL_HELPERS"] = "ON"
-        cmake.configure()
-        cmake.install()
-
-        self.copy(pattern="LICENSE.txt", dst="licenses")
+        self.copy(pattern="catch.hpp", src="single_include", dst="include")
 
     def package_id(self):
-        self.info.header_only()
+            self.info.header_only()

contrib/Catch.cmake

@@ -1,175 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-#[=======================================================================[.rst:
-Catch
------
-
-This module defines a function to help use the Catch test framework.
-
-The :command:`catch_discover_tests` discovers tests by asking the compiled test
-executable to enumerate its tests.  This does not require CMake to be re-run
-when tests change.  However, it may not work in a cross-compiling environment,
-and setting test properties is less convenient.
-
-This command is intended to replace use of :command:`add_test` to register
-tests, and will create a separate CTest test for each Catch test case.  Note
-that this is in some cases less efficient, as common set-up and tear-down logic
-cannot be shared by multiple test cases executing in the same instance.
-However, it provides more fine-grained pass/fail information to CTest, which is
-usually considered as more beneficial.  By default, the CTest test name is the
-same as the Catch name; see also ``TEST_PREFIX`` and ``TEST_SUFFIX``.
-
-.. command:: catch_discover_tests
-
-  Automatically add tests with CTest by querying the compiled test executable
-  for available tests::
-
-    catch_discover_tests(target
-                         [TEST_SPEC arg1...]
-                         [EXTRA_ARGS arg1...]
-                         [WORKING_DIRECTORY dir]
-                         [TEST_PREFIX prefix]
-                         [TEST_SUFFIX suffix]
-                         [PROPERTIES name1 value1...]
-                         [TEST_LIST var]
-    )
-
-  ``catch_discover_tests`` sets up a post-build command on the test executable
-  that generates the list of tests by parsing the output from running the test
-  with the ``--list-test-names-only`` argument.  This ensures that the full
-  list of tests is obtained.  Since test discovery occurs at build time, it is
-  not necessary to re-run CMake when the list of tests changes.
-  However, it requires that :prop_tgt:`CROSSCOMPILING_EMULATOR` is properly set
-  in order to function in a cross-compiling environment.
-
-  Additionally, setting properties on tests is somewhat less convenient, since
-  the tests are not available at CMake time.  Additional test properties may be
-  assigned to the set of tests as a whole using the ``PROPERTIES`` option.  If
-  more fine-grained test control is needed, custom content may be provided
-  through an external CTest script using the :prop_dir:`TEST_INCLUDE_FILES`
-  directory property.  The set of discovered tests is made accessible to such a
-  script via the ``<target>_TESTS`` variable.
-
-  The options are:
-
-  ``target``
-    Specifies the Catch executable, which must be a known CMake executable
-    target.  CMake will substitute the location of the built executable when
-    running the test.
-
-  ``TEST_SPEC arg1...``
-    Specifies test cases, wildcarded test cases, tags and tag expressions to
-    pass to the Catch executable with the ``--list-test-names-only`` argument.
-
-  ``EXTRA_ARGS arg1...``
-    Any extra arguments to pass on the command line to each test case.
-
-  ``WORKING_DIRECTORY dir``
-    Specifies the directory in which to run the discovered test cases.  If this
-    option is not provided, the current binary directory is used.
-
-  ``TEST_PREFIX prefix``
-    Specifies a ``prefix`` to be prepended to the name of each discovered test
-    case.  This can be useful when the same test executable is being used in
-    multiple calls to ``catch_discover_tests()`` but with different
-    ``TEST_SPEC`` or ``EXTRA_ARGS``.
-
-  ``TEST_SUFFIX suffix``
-    Similar to ``TEST_PREFIX`` except the ``suffix`` is appended to the name of
-    every discovered test case.  Both ``TEST_PREFIX`` and ``TEST_SUFFIX`` may
-    be specified.
-
-  ``PROPERTIES name1 value1...``
-    Specifies additional properties to be set on all tests discovered by this
-    invocation of ``catch_discover_tests``.
-
-  ``TEST_LIST var``
-    Make the list of tests available in the variable ``var``, rather than the
-    default ``<target>_TESTS``.  This can be useful when the same test
-    executable is being used in multiple calls to ``catch_discover_tests()``.
-    Note that this variable is only available in CTest.
-
-#]=======================================================================]
-
-#------------------------------------------------------------------------------
-function(catch_discover_tests TARGET)
-  cmake_parse_arguments(
-    ""
-    ""
-    "TEST_PREFIX;TEST_SUFFIX;WORKING_DIRECTORY;TEST_LIST"
-    "TEST_SPEC;EXTRA_ARGS;PROPERTIES"
-    ${ARGN}
-  )
-
-  if(NOT _WORKING_DIRECTORY)
-    set(_WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
-  endif()
-  if(NOT _TEST_LIST)
-    set(_TEST_LIST ${TARGET}_TESTS)
-  endif()
-
-  ## Generate a unique name based on the extra arguments
-  string(SHA1 args_hash "${_TEST_SPEC} ${_EXTRA_ARGS}")
-  string(SUBSTRING ${args_hash} 0 7 args_hash)
-
-  # Define rule to generate test list for aforementioned test executable
-  set(ctest_include_file "${CMAKE_CURRENT_BINARY_DIR}/${TARGET}_include-${args_hash}.cmake")
-  set(ctest_tests_file "${CMAKE_CURRENT_BINARY_DIR}/${TARGET}_tests-${args_hash}.cmake")
-  get_property(crosscompiling_emulator
-    TARGET ${TARGET}
-    PROPERTY CROSSCOMPILING_EMULATOR
-  )
-  add_custom_command(
-    TARGET ${TARGET} POST_BUILD
-    BYPRODUCTS "${ctest_tests_file}"
-    COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_TARGET=${TARGET}"
-            -D "TEST_EXECUTABLE=$<TARGET_FILE:${TARGET}>"
-            -D "TEST_EXECUTOR=${crosscompiling_emulator}"
-            -D "TEST_WORKING_DIR=${_WORKING_DIRECTORY}"
-            -D "TEST_SPEC=${_TEST_SPEC}"
-            -D "TEST_EXTRA_ARGS=${_EXTRA_ARGS}"
-            -D "TEST_PROPERTIES=${_PROPERTIES}"
-            -D "TEST_PREFIX=${_TEST_PREFIX}"
-            -D "TEST_SUFFIX=${_TEST_SUFFIX}"
-            -D "TEST_LIST=${_TEST_LIST}"
-            -D "CTEST_FILE=${ctest_tests_file}"
-            -P "${_CATCH_DISCOVER_TESTS_SCRIPT}"
-    VERBATIM
-  )
-
-  file(WRITE "${ctest_include_file}"
-    "if(EXISTS \"${ctest_tests_file}\")\n"
-    "  include(\"${ctest_tests_file}\")\n"
-    "else()\n"
-    "  add_test(${TARGET}_NOT_BUILT-${args_hash} ${TARGET}_NOT_BUILT-${args_hash})\n"
-    "endif()\n"
-  )
-
-  if(NOT ${CMAKE_VERSION} VERSION_LESS "3.10.0") 
-    # Add discovered tests to directory TEST_INCLUDE_FILES
-    set_property(DIRECTORY
-      APPEND PROPERTY TEST_INCLUDE_FILES "${ctest_include_file}"
-    )
-  else()
-    # Add discovered tests as directory TEST_INCLUDE_FILE if possible
-    get_property(test_include_file_set DIRECTORY PROPERTY TEST_INCLUDE_FILE SET)
-    if (NOT ${test_include_file_set})
-      set_property(DIRECTORY
-        PROPERTY TEST_INCLUDE_FILE "${ctest_include_file}"
-      )
-    else()
-      message(FATAL_ERROR
-        "Cannot set more than one TEST_INCLUDE_FILE"
-      )
-    endif()
-  endif()
-
-endfunction()
-
-###############################################################################
-
-set(_CATCH_DISCOVER_TESTS_SCRIPT
-  ${CMAKE_CURRENT_LIST_DIR}/CatchAddTests.cmake
-)

contrib/CatchAddTests.cmake

@@ -1,106 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-set(prefix "${TEST_PREFIX}")
-set(suffix "${TEST_SUFFIX}")
-set(spec ${TEST_SPEC})
-set(extra_args ${TEST_EXTRA_ARGS})
-set(properties ${TEST_PROPERTIES})
-set(script)
-set(suite)
-set(tests)
-
-function(add_command NAME)
-  set(_args "")
-  foreach(_arg ${ARGN})
-    if(_arg MATCHES "[^-./:a-zA-Z0-9_]")
-      set(_args "${_args} [==[${_arg}]==]") # form a bracket_argument
-    else()
-      set(_args "${_args} ${_arg}")
-    endif()
-  endforeach()
-  set(script "${script}${NAME}(${_args})\n" PARENT_SCOPE)
-endfunction()
-
-macro(_add_catch_test_labels LINE)
-  # convert to list of tags
-  string(REPLACE "][" "]\\;[" tags ${line})
-
-  add_command(
-    set_tests_properties "${prefix}${test}${suffix}"
-      PROPERTIES
-        LABELS "${tags}"
-  )
-endmacro()
-
-macro(_add_catch_test LINE)
-  set(test ${line})
-  # use escape commas to handle properly test cases with commans inside the name
-  string(REPLACE "," "\\," test_name ${test})
-  # ...and add to script
-  add_command(
-    add_test "${prefix}${test}${suffix}"
-      ${TEST_EXECUTOR}
-       "${TEST_EXECUTABLE}"
-       "${test_name}"
-       ${extra_args}
-     )
-
-  add_command(
-    set_tests_properties "${prefix}${test}${suffix}"
-      PROPERTIES
-        WORKING_DIRECTORY "${TEST_WORKING_DIR}"
-        ${properties}
-  )
-  list(APPEND tests "${prefix}${test}${suffix}")
-endmacro()
-
-# Run test executable to get list of available tests
-if(NOT EXISTS "${TEST_EXECUTABLE}")
-  message(FATAL_ERROR
-    "Specified test executable '${TEST_EXECUTABLE}' does not exist"
-  )
-endif()
-execute_process(
-  COMMAND ${TEST_EXECUTOR} "${TEST_EXECUTABLE}" ${spec} --list-tests
-  OUTPUT_VARIABLE output
-  RESULT_VARIABLE result
-)
-# Catch --list-test-names-only reports the number of tests, so 0 is... surprising
-if(${result} EQUAL 0)
-  message(WARNING
-    "Test executable '${TEST_EXECUTABLE}' contains no tests!\n"
-  )
-elseif(${result} LESS 0)
-  message(FATAL_ERROR
-    "Error running test executable '${TEST_EXECUTABLE}':\n"
-    "  Result: ${result}\n"
-    "  Output: ${output}\n"
-  )
-endif()
-
-string(REPLACE "\n" ";" output "${output}")
-set(test)
-set(tags_regex "(\\[([^\\[]*)\\])+$")
-
-# Parse output
-foreach(line ${output})
-  # lines without leading whitespaces are catch output not tests
-  if(${line} MATCHES "^[ \t]+")
-    # strip leading spaces and tabs
-    string(REGEX REPLACE "^[ \t]+" "" line ${line})
-
-    if(${line} MATCHES "${tags_regex}")
-      _add_catch_test_labels(${line})
-    else()
-      _add_catch_test(${line})
-    endif()
-  endif()
-endforeach()
-
-# Create a list of all discovered tests, which users may use to e.g. set
-# properties on the tests
-add_command(set ${TEST_LIST} ${tests})
-
-# Write CTest script
-file(WRITE "${CTEST_FILE}" "${script}")

contrib/ParseAndAddCatchTests.cmake

@@ -39,24 +39,9 @@
 #    PARSE_CATCH_TESTS_ADD_TO_CONFIGURE_DEPENDS (Default OFF)                                      #
 #    -- causes CMake to rerun when file with tests changes so that new tests will be discovered    #
 #                                                                                                  #
-# One can also set (locally) the optional variable OptionalCatchTestLauncher to precise the way    #
-# a test should be run. For instance to use test MPI, one can write                                #
-#     set(OptionalCatchTestLauncher ${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG} ${NUMPROC})                 #
-# just before calling this ParseAndAddCatchTests function                                          #
-#                                                                                                  #
-# The AdditionalCatchParameters optional variable can be used to pass extra argument to the test   #
-# command. For example, to include successful tests in the output, one can write                   #
-#     set(AdditionalCatchParameters --success)                                                     #
-#                                                                                                  #
-# After the script, the ParseAndAddCatchTests_TESTS property for the target, and for each source   #
-# file in the target is set, and contains the list of the tests extracted from that target, or     #
-# from that file. This is useful, for example to add further labels or properties to the tests.    #
-#                                                                                                  #
 #==================================================================================================#
 
-if (CMAKE_MINIMUM_REQUIRED_VERSION VERSION_LESS 2.8.8)
-  message(FATAL_ERROR "ParseAndAddCatchTests requires CMake 2.8.8 or newer")
-endif()
+cmake_minimum_required(VERSION 2.8.8)
 
 option(PARSE_CATCH_TESTS_VERBOSE "Print Catch to CTest parser debug messages" OFF)
 option(PARSE_CATCH_TESTS_NO_HIDDEN_TESTS "Exclude tests with [!hide], [.] or [.foo] tags" OFF)
@@ -64,7 +49,7 @@ option(PARSE_CATCH_TESTS_ADD_FIXTURE_IN_TEST_NAME "Add fixture class name to the
 option(PARSE_CATCH_TESTS_ADD_TARGET_IN_TEST_NAME "Add target name to the test name" ON)
 option(PARSE_CATCH_TESTS_ADD_TO_CONFIGURE_DEPENDS "Add test file to CMAKE_CONFIGURE_DEPENDS property" OFF)
 
-function(ParseAndAddCatchTests_PrintDebugMessage)
+function(PrintDebugMessage)
     if(PARSE_CATCH_TESTS_VERBOSE)
             message(STATUS "ParseAndAddCatchTests: ${ARGV}")
     endif()
@@ -75,7 +60,7 @@ endfunction()
 #  - full line comments (i.e. // ... )
 # contents have been read into '${CppCode}'.
 # !keep partial line comments
-function(ParseAndAddCatchTests_RemoveComments CppCode)
+function(RemoveComments CppCode)
   string(ASCII 2 CMakeBeginBlockComment)
   string(ASCII 3 CMakeEndBlockComment)
   string(REGEX REPLACE "/\\*" "${CMakeBeginBlockComment}" ${CppCode} "${${CppCode}}")
@@ -87,29 +72,24 @@ function(ParseAndAddCatchTests_RemoveComments CppCode)
 endfunction()
 
 # Worker function
-function(ParseAndAddCatchTests_ParseFile SourceFile TestTarget)
-    # If SourceFile is an object library, do not scan it (as it is not a file). Exit without giving a warning about a missing file.
-    if(SourceFile MATCHES "\\\$<TARGET_OBJECTS:.+>")
-        ParseAndAddCatchTests_PrintDebugMessage("Detected OBJECT library: ${SourceFile} this will not be scanned for tests.")
-        return()
-    endif()
+function(ParseFile SourceFile TestTarget)
     # According to CMake docs EXISTS behavior is well-defined only for full paths.
     get_filename_component(SourceFile ${SourceFile} ABSOLUTE)
     if(NOT EXISTS ${SourceFile})
         message(WARNING "Cannot find source file: ${SourceFile}")
         return()
     endif()
-    ParseAndAddCatchTests_PrintDebugMessage("parsing ${SourceFile}")
+    PrintDebugMessage("parsing ${SourceFile}")
     file(STRINGS ${SourceFile} Contents NEWLINE_CONSUME)
 
     # Remove block and fullline comments
-    ParseAndAddCatchTests_RemoveComments(Contents)
+    RemoveComments(Contents)
 
     # Find definition of test names
     string(REGEX MATCHALL "[ \t]*(CATCH_)?(TEST_CASE_METHOD|SCENARIO|TEST_CASE)[ \t]*\\([^\)]+\\)+[ \t\n]*{+[ \t]*(//[^\n]*[Tt][Ii][Mm][Ee][Oo][Uu][Tt][ \t]*[0-9]+)*" Tests "${Contents}")
 
     if(PARSE_CATCH_TESTS_ADD_TO_CONFIGURE_DEPENDS AND Tests)
-      ParseAndAddCatchTests_PrintDebugMessage("Adding ${SourceFile} to CMAKE_CONFIGURE_DEPENDS property")
+      PrintDebugMessage("Adding ${SourceFile} to CMAKE_CONFIGURE_DEPENDS property")
       set_property(
         DIRECTORY
         APPEND
@@ -124,7 +104,7 @@ function(ParseAndAddCatchTests_ParseFile SourceFile TestTarget)
         # Get test type and fixture if applicable
         string(REGEX MATCH "(CATCH_)?(TEST_CASE_METHOD|SCENARIO|TEST_CASE)[ \t]*\\([^,^\"]*" TestTypeAndFixture "${TestName}")
         string(REGEX MATCH "(CATCH_)?(TEST_CASE_METHOD|SCENARIO|TEST_CASE)" TestType "${TestTypeAndFixture}")
-        string(REGEX REPLACE "${TestType}\\([ \t]*" "" TestFixture "${TestTypeAndFixture}")
+        string(REPLACE "${TestType}(" "" TestFixture "${TestTypeAndFixture}")
 
         # Get string parts of test definition
         string(REGEX MATCHALL "\"+([^\\^\"]|\\\\\")+\"+" TestStrings "${TestName}")
@@ -163,13 +143,11 @@ function(ParseAndAddCatchTests_ParseFile SourceFile TestTarget)
             endif()
             string(REPLACE "]" ";" Tags "${Tags}")
             string(REPLACE "[" "" Tags "${Tags}")
-        else()
-          # unset tags variable from previous loop
-          unset(Tags)
         endif()
 
         list(APPEND Labels ${Tags})
 
+        list(FIND Labels "!hide" IndexOfHideLabel)
         set(HiddenTagFound OFF)
         foreach(label ${Labels})
             string(REGEX MATCH "^!hide|^\\." result ${label})
@@ -178,48 +156,30 @@ function(ParseAndAddCatchTests_ParseFile SourceFile TestTarget)
                 break()
             endif(result)
         endforeach(label)
-        if(PARSE_CATCH_TESTS_NO_HIDDEN_TESTS AND ${HiddenTagFound} AND ${CMAKE_VERSION} VERSION_LESS "3.9")
-            ParseAndAddCatchTests_PrintDebugMessage("Skipping test \"${CTestName}\" as it has [!hide], [.] or [.foo] label")
+        if(PARSE_CATCH_TESTS_NO_HIDDEN_TESTS AND ${HiddenTagFound})
+            PrintDebugMessage("Skipping test \"${CTestName}\" as it has [!hide], [.] or [.foo] label")
         else()
-            ParseAndAddCatchTests_PrintDebugMessage("Adding test \"${CTestName}\"")
+            PrintDebugMessage("Adding test \"${CTestName}\"")
             if(Labels)
-                ParseAndAddCatchTests_PrintDebugMessage("Setting labels to ${Labels}")
+                PrintDebugMessage("Setting labels to ${Labels}")
             endif()
 
-            # Escape commas in the test spec
-            string(REPLACE "," "\\," Name ${Name})
-
             # Add the test and set its properties
-            add_test(NAME "\"${CTestName}\"" COMMAND ${OptionalCatchTestLauncher} $<TARGET_FILE:${TestTarget}> ${Name} ${AdditionalCatchParameters})
-            # Old CMake versions do not document VERSION_GREATER_EQUAL, so we use VERSION_GREATER with 3.8 instead
-            if(PARSE_CATCH_TESTS_NO_HIDDEN_TESTS AND ${HiddenTagFound} AND ${CMAKE_VERSION} VERSION_GREATER "3.8")
-                ParseAndAddCatchTests_PrintDebugMessage("Setting DISABLED test property")
-                set_tests_properties("\"${CTestName}\"" PROPERTIES DISABLED ON)
-            else()
-                set_tests_properties("\"${CTestName}\"" PROPERTIES FAIL_REGULAR_EXPRESSION "No tests ran"
-                                                        LABELS "${Labels}")
-            endif()
-            set_property(
-              TARGET ${TestTarget}
-              APPEND
-              PROPERTY ParseAndAddCatchTests_TESTS "\"${CTestName}\"")
-            set_property(
-              SOURCE ${SourceFile}
-              APPEND
-              PROPERTY ParseAndAddCatchTests_TESTS "\"${CTestName}\"")
+            add_test(NAME "\"${CTestName}\"" COMMAND ${TestTarget} ${Name} ${AdditionalCatchParameters})
+            set_tests_properties("\"${CTestName}\"" PROPERTIES FAIL_REGULAR_EXPRESSION "No tests ran"
+                                                    LABELS "${Labels}")
         endif()
 
-
     endforeach()
 endfunction()
 
 # entry point
 function(ParseAndAddCatchTests TestTarget)
-    ParseAndAddCatchTests_PrintDebugMessage("Started parsing ${TestTarget}")
+    PrintDebugMessage("Started parsing ${TestTarget}")
     get_target_property(SourceFiles ${TestTarget} SOURCES)
-    ParseAndAddCatchTests_PrintDebugMessage("Found the following sources: ${SourceFiles}")
+    PrintDebugMessage("Found the following sources: ${SourceFiles}")
     foreach(SourceFile ${SourceFiles})
-        ParseAndAddCatchTests_ParseFile(${SourceFile} ${TestTarget})
+        ParseFile(${SourceFile} ${TestTarget})
     endforeach()
-    ParseAndAddCatchTests_PrintDebugMessage("Finished parsing ${TestTarget}")
+    PrintDebugMessage("Finished parsing ${TestTarget}")
 endfunction()

contrib/gdbinit

@@ -1,16 +0,0 @@
-#
-# This file provides a way to skip stepping into Catch code when debugging with gdb.
-#
-# With the gdb "skip" command you can tell gdb to skip files or functions during debugging.
-# see https://xaizek.github.io/2016-05-26/skipping-standard-library-in-gdb/ for an example
-#
-# Basically the following line tells gdb to skip all functions containing the
-# regexp "Catch", which matches the complete Catch namespace.
-# If you want to skip just some parts of the Catch code you can modify the
-# regexp accordingly.
-# 
-# If you want to permanently skip stepping into Catch code copy the following
-# line into your ~/.gdbinit file
-# 
-
-skip -rfu Catch

contrib/lldbinit

@@ -1,16 +0,0 @@
-#
-# This file provides a way to skip stepping into Catch code when debugging with lldb.
-#
-# With the setting "target.process.thread.step-avoid-regexp" you can tell lldb
-# to skip functions matching the regexp
-#
-# Basically the following line tells lldb to skip all functions containing the
-# regexp "Catch", which matches the complete Catch namespace.
-# If you want to skip just some parts of the Catch code you can modify the
-# regexp accordingly.
-#
-# If you want to permanently skip stepping into Catch code copy the following
-# line into your ~/.lldbinit file
-#
-
-settings set target.process.thread.step-avoid-regexp Catch

docs/Readme.md

@@ -1,39 +1,30 @@
-<a id="top"></a>
-# Reference
-
-To get the most out of Catch2, start with the [tutorial](tutorial.md#top).
+To get the most out of Catch, start with the [tutorial](tutorial.md).
 Once you're up and running consider the following reference material.
 
 Writing tests:
-* [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)
-* [Data Generators](generators.md#top)
-* [Other macros](other-macros.md#top)
+* [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)
 
 Fine tuning:
-* [Supplying your own main()](own-main.md#top)
-* [Compile-time configuration](configuration.md#top)
-* [String Conversions](tostring.md#top)
+* [Supplying your own main()](own-main.md)
+* [Compile-time configuration](configuration.md)
+* [String Conversions](tostring.md)
 
 Running:
-* [Command line](command-line.md#top)
-
-Odds and ends:
-* [CMake integration](cmake-integration.md#top)
-* [CI and other miscellaneous pieces](ci-and-misc.md#top)
+* [Command line](command-line.md)
+* [CI and Build system integration](build-systems.md)
 
 FAQ:
-* [Why are my tests slow to compile?](slow-compiles.md#top)
-* [Known limitations](limitations.md#top)
+* [Why are my tests slow to compile?](slow-compiles.md)
+* [Known limitations](limitations.md)
  
 Other:
-* [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)
-* [Deprecations and incoming changes](deprecations.md#top)
+* [Why Catch?](why-catch.md)
+* [Open Source Projects using Catch](opensource-users.md)
+* [Contributing](contributing.md)
+* [Release Notes](release-notes.md)

docs/assertions.md

@@ -1,16 +1,8 @@
-<a id="top"></a>
 # Assertion Macros
 
-**Contents**<br>
-[Natural Expressions](#natural-expressions)<br>
-[Exceptions](#exceptions)<br>
-[Matcher expressions](#matcher-expressions)<br>
-[Thread Safety](#thread-safety)<br>
-[Expressions with commas](#expressions-with-commas)<br>
-
 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 is a rich set of auxiliary macros as well. We'll describe all of these here.
+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.
 
 Most of these macros come in two forms:
 
@@ -22,7 +14,7 @@ The ```CHECK``` family are equivalent but execution continues in the same test c
 * **REQUIRE(** _expression_ **)** and  
 * **CHECK(** _expression_ **)**
 
-Evaluates the expression and records the result. If an exception is thrown, it is caught, reported, and counted as a failure. These are the macros you will use most of the time.
+Evaluates the expression and records the result. If an exception is thrown it is caught, reported, and counted as a failure. These are the macros you will use most of  the time
 
 Examples:
 ```
@@ -55,54 +47,37 @@ This expression is too complex because of the `||` operator. If you want to chec
 
 When comparing floating point numbers - especially if at least one of them has been computed - great care must be taken to allow for rounding errors and inexact representations.
 
-Catch provides a way to perform tolerant comparisons of floating point values through use of a wrapper class called `Approx`. `Approx` can be used on either side of a comparison expression. It overloads the comparisons operators to take a tolerance into account. Here's a simple example:
+Catch provides a way to perform tolerant comparisons of floating point values through use of a wrapper class called ```Approx```. ```Approx``` can be used on either side of a comparison expression. It overloads the comparisons operators to take a tolerance into account. Here's a simple example:
 
-```cpp
+```
 REQUIRE( performComputation() == Approx( 2.1 ) );
 ```
 
-Catch also provides a user-defined literal for `Approx`; `_a`. It resides in
-the `Catch::literals` namespace and can be used like so:
-```cpp
-using namespace Catch::literals;
-REQUIRE( performComputation() == 2.1_a );
-```
+This way `Approx` is constructed with reasonable defaults, covering most simple cases of rounding errors. If these are insufficient, each `Approx` instance has 3 tuning knobs, that can be used to customize it for your computation.
 
-`Approx` is constructed with defaults that should cover most simple cases.
-For the more complex cases, `Approx` provides 3 customization points:
-
-* __epsilon__ - epsilon serves to set the coefficient by which a result
-can differ from `Approx`'s value before it is rejected.
-_By default set to `std::numeric_limits<float>::epsilon()*100`._
-* __margin__ - margin serves to set the the absolute value by which
-a result can differ from `Approx`'s value before it is rejected.
-_By default set to `0.0`._
-* __scale__ - scale is used to change the magnitude of `Approx` for relative check.
-_By default set to `0.0`._
+* __epsilon__ - epsilon serves to set the percentage by which a result can be erroneous, before it is rejected. By default set to `std::numeric_limits<float>::epsilon()*100`.
+* __margin__ - margin serves to set the the absolute value by which a result can be erroneous before it is rejected. By default set to `0.0`.
+* __scale__ - scale serves to adjust the base for comparison used by epsilon. By default set to `1.0`.
 
 #### epsilon example
 ```cpp
 Approx target = Approx(100).epsilon(0.01);
 100.0 == target; // Obviously true
 200.0 == target; // Obviously still false
-100.5 == target; // True, because we set target to allow up to 1% difference
+100.5 == target; // True, because we set target to allow up to 1% error
 ```
 
 #### margin example
+_Margin check is used only if the relative (epsilon and scale based) check fails._
 ```cpp
 Approx target = Approx(100).margin(5);
 100.0 == target; // Obviously true
 200.0 == target; // Obviously still false
-104.0 == target; // True, because we set target to allow absolute difference of at most 5
+104.0 == target; // True, because we set target to allow absolute error up to 5
 ```
 
 #### scale
-Scale can be useful if the computation leading to the result worked
-on different scale than is used by the results. Since allowed difference
-between Approx's value and compared value is based primarily on Approx's value
-(the allowed difference is computed as
-`(Approx::scale + Approx::value) * epsilon`), the resulting comparison could
-need rescaling to be correct.
+Scale can be useful if the computation leading to the result worked on different scale, than is used by the results (and thus expected errors are on a different scale than would be expected based on the results alone), i.e. an additional not scaling difference will be accepted, because | current - target | < eps_rel + eps_abs (while eps_rel = max(current, target) * epsilon, eps_abs = epsilon * scale) will be checked.
 
 
 ## Exceptions
@@ -120,7 +95,7 @@ Expects that an exception (of any type) is be thrown during evaluation of the ex
 * **REQUIRE_THROWS_AS(** _expression_, _exception type_ **)** and  
 * **CHECK_THROWS_AS(** _expression_, _exception type_ **)**
 
-Expects that an exception of the _specified type_ is thrown during evaluation of the expression. Note that the _exception type_ is extended with `const&` and you should not include it yourself.
+Expects that an exception of the _specified type_ is thrown during evaluation of the expression. Note that the _exception type_ is used verbatim and you should include (const) reference.
 
 * **REQUIRE_THROWS_WITH(** _expression_, _string or string matcher_ **)** and  
 * **CHECK_THROWS_WITH(** _expression_, _string or string matcher_ **)**
@@ -133,13 +108,8 @@ REQUIRE_THROWS_WITH( openThePodBayDoors(), Contains( "afraid" ) && Contains( "ca
 REQUIRE_THROWS_WITH( dismantleHal(), "My mind is going" );
 ```
 
-* **REQUIRE_THROWS_MATCHES(** _expression_, _exception type_, _matcher for given exception type_ **)** and
-* **CHECK_THROWS_MATCHES(** _expression_, _exception type_, _matcher for given exception type_ **)**
 
-Expects that exception of _exception type_ is thrown and it matches provided matcher (see next section for Matchers).
-
-
-_Please note that the `THROW` family of assertions expects to be passed a single expression, not a statement or series of statements. If you want to check a more complicated sequence of operations, you can use a C++11 lambda function._
+Please note that the `THROW` family of assertions expects to be passed a single expression, not a statement or series of statements. If you want to check a more complicated sequence of operations, you can use a C++11 lambda function.
 
 ```cpp
 REQUIRE_NOTHROW([&](){
@@ -152,11 +122,9 @@ REQUIRE_NOTHROW([&](){
 }());
 ```
 
-
-
 ## Matcher expressions
 
-To support Matchers a slightly different form is used. Matchers have [their own documentation](matchers.md#top).
+To support Matchers a slightly different form is used. Matchers have [their own documentation](matchers.md).
 
 * **REQUIRE_THAT(** _lhs_, _matcher expression_ **)** and  
 * **CHECK_THAT(** _lhs_, _matcher expression_ **)**  
@@ -168,34 +136,6 @@ Matchers can be composed using `&&`, `||` and `!` operators.
 Currently assertions in Catch are not thread safe.
 For more details, along with workarounds, see the section on [the limitations page](limitations.md#thread-safe-assertions).
 
-## Expressions with commas
-
-Because the preprocessor parses code using different rules than the
-compiler, multiple-argument assertions (e.g. `REQUIRE_THROWS_AS`) have
-problems with commas inside the provided expressions. As an example
-`REQUIRE_THROWS_AS(std::pair<int, int>(1, 2), std::invalid_argument);`
-will fail to compile, because the preprocessor sees 3 arguments provided,
-but the macro accepts only 2. There are two possible workarounds.
-
-1) Use typedef:
-```cpp
-using int_pair = std::pair<int, int>;
-REQUIRE_THROWS_AS(int_pair(1, 2), std::invalid_argument);
-```
-
-This solution is always applicable, but makes the meaning of the code
-less clear.
-
-2) Parenthesize the expression:
-```cpp
-TEST_CASE_METHOD((Fixture<int, int>), "foo", "[bar]") {
-    SUCCEED();
-}
-```
-
-This solution is not always applicable, because it might require extra
-changes on the Catch's side to work.
-
 ---
 
-[Home](Readme.md#top)
+[Home](Readme.md)

docs/build-systems.md

@@ -1,22 +1,14 @@
-<a id="top"></a>
-# CI and other odd pieces
+# CI and build system integration
 
-**Contents**<br>
-[Continuous Integration systems](#continuous-integration-systems)<br>
-[Other reporters](#other-reporters)<br>
-[Low-level tools](#low-level-tools)<br>
-[CMake](#cmake)<br>
-
-This page talks about how Catch integrates with Continuous 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. 
@@ -25,7 +17,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 convert 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.
@@ -35,14 +27,9 @@ The advantage of this format is that the JUnit Ant schema is widely understood b
 The disadvantage is that this schema was designed to correspond to how JUnit works - and there is a significant mismatch with how Catch works. Additionally the format is not streamable (because opening elements hold counts of failed and passing tests as attributes) - so the whole test run must complete before it can be written.
 
 ## Other reporters
-Other reporters are not part of the single-header distribution and need
-to be downloaded and included separately. All reporters are stored in
-`single_include` directory in the git repository, and are named
-`catch_reporter_*.hpp`. For example, to use the TeamCity reporter you
-need to download `single_include/catch_reporter_teamcity.hpp` and include
-it after Catch itself.
+Other reporters are not part of the single-header distribution and need to be downloaded and included separately. All reporters are stored in `include/reporters` directory in the git repository, and are named `catch_reporter_*.hpp`. For example, to use the TeamCity reporter you need to download `include/reporters/catch_reporter_teamcity.hpp` and include it after Catch itself.
 
-```cpp
+```
 #define CATCH_CONFIG_MAIN
 #include "catch.hpp"
 #include "catch_reporter_teamcity.hpp"
@@ -65,44 +52,92 @@ 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
 
-### Precompiled headers (PCHs)
+## CMake
 
-Catch offers prototypal support for being included in precompiled headers, but because of its single-header nature it does need some actions by the user:
-* The precompiled header needs to define `CATCH_CONFIG_ALL_PARTS`
-* The implementation file needs to
-  * undefine `TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED`
-  * define `CATCH_CONFIG_IMPL_ONLY`
-  * define `CATCH_CONFIG_MAIN` or `CATCH_CONFIG_RUNNER`
-  * include "catch.hpp" again
+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
+cmake_minimum_required(VERSION 3.0)
 
+project(cmake_test)
+
+# Prepare "Catch" library for other executables
+set(CATCH_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/catch)
+add_library(Catch INTERFACE)
+target_include_directories(Catch INTERFACE ${CATCH_INCLUDE_DIR})
+
+# Make test executable
+set(TEST_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/main.cpp)
+add_executable(tests ${TEST_SOURCES})
+target_link_libraries(tests Catch)
+```
+Note that it assumes that the path to the Catch's header is `catch/catch.hpp` from the `CMakeLists.txt` file.
+
+
+You can also use the following CMake snippet to automatically fetch the entire Catch repository from github and configure it as an external project:
+```CMake
+cmake_minimum_required(VERSION 2.8.8)
+project(catch_builder CXX)
+include(ExternalProject)
+find_package(Git REQUIRED)
+
+ExternalProject_Add(
+    catch
+    PREFIX ${CMAKE_BINARY_DIR}/catch
+    GIT_REPOSITORY https://github.com/philsquared/Catch.git
+    TIMEOUT 10
+    UPDATE_COMMAND ${GIT_EXECUTABLE} pull
+    CONFIGURE_COMMAND ""
+    BUILD_COMMAND ""
+    INSTALL_COMMAND ""
+    LOG_DOWNLOAD ON
+   )
+
+# Expose required variable (CATCH_INCLUDE_DIR) to parent scope
+ExternalProject_Get_Property(catch source_dir)
+set(CATCH_INCLUDE_DIR ${source_dir}/single_include CACHE INTERNAL "Path to include folder for Catch")
+```
+
+If you put it in, e.g., `${PROJECT_SRC_DIR}/${EXT_PROJECTS_DIR}/catch/`, you can use it in your project by adding the following to your root CMake file:
+
+```CMake
+# Includes Catch in the project:
+add_subdirectory(${EXT_PROJECTS_DIR}/catch)
+include_directories(${CATCH_INCLUDE_DIR} ${COMMON_INCLUDES})
+enable_testing(true)  # Enables unit-testing.
+```
+
+The advantage of this approach is that you can always automatically update Catch to the latest release. The disadvantage is that it means bringing in lot more than you need.
+
+
+### Automatic test registration
+If you are also using ctest, `contrib/ParseAndAddCatchTests.cmake` is a CMake script that attempts to parse your test files and automatically register all test cases, using tags as labels. This means that these
+```cpp
+TEST_CASE("Test1", "[unit]") {
+    int a = 1;
+    int b = 2;
+    REQUIRE(a == b);
+}
+
+TEST_CASE("Test2") {
+    int a = 1;
+    int b = 2;
+    REQUIRE(a == b);
+}
+
+TEST_CASE("Test3", "[a][b][c]") {
+    int a = 1;
+    int b = 2;
+    REQUIRE(a == b);
+}
+```
+would be registered as 3 tests, `Test1`, `Test2` and `Test3`, and ctest 4 labels would be created, `a`, `b`, `c` and `unit`.
 
 ### CodeCoverage module (GCOV, LCOV...)
 
 If you are using GCOV tool to get testing coverage of your code, and are not sure how to integrate it with CMake and Catch, there should be an external example over at https://github.com/fkromer/catch_cmake_coverage
 
-
-### pkg-config
-
-Catch2 provides a rudimentary pkg-config integration, by registering itself
-under the name `catch2`. This means that after Catch2 is installed, you
-can use `pkg-config` to get its include path: `pkg-config --cflags catch2`.
-
-### gdb and lldb scripts
-
-Catch2's `contrib` folder also contains two simple debugger scripts,
-`gdbinit` for `gdb` and `lldbinit` for `lldb`. If loaded into their
-respective debugger, these will tell it to step over Catch2's internals
-when stepping through code.
-
-
-## CMake
-
-[As it has been getting kinda long, the documentation of Catch2's
-integration with CMake has been moved to its own page.](cmake-integration.md#top)
-
-
 ---
 
-[Home](Readme.md#top)
+[Home](Readme.md)

docs/cmake-integration.md

@@ -1,226 +0,0 @@
-<a id="top"></a>
-# CMake integration
-
-**Contents**<br>
-[CMake target](#cmake-target)<br>
-[Automatic test registration](#automatic-test-registration)<br>
-[CMake project options](#cmake-project-options)<br>
-[Installing Catch2 from git repository](#installing-catch2-from-git-repository)<br>
-
-Because we use CMake to build Catch2, we also provide a couple of
-integration points for our users.
-
-1) Catch2 exports a (namespaced) CMake target
-2) Catch2's repository contains CMake scripts for automatic registration
-of `TEST_CASE`s in CTest
-
-## CMake target
-
-Catch2's CMake build exports an interface target `Catch2::Catch2`. Linking
-against it will add the proper include path and all necessary capabilities
-to the resulting binary.
-
-This means that if Catch2 has been installed on the system, it should be
-enough to do:
-```cmake
-find_package(Catch2 REQUIRED)
-target_link_libraries(tests Catch2::Catch2)
-```
-
-
-This target is also provided when Catch2 is used as a subdirectory.
-Assuming that Catch2 has been cloned to `lib/Catch2`:
-```cmake
-add_subdirectory(lib/Catch2)
-target_link_libraries(tests Catch2::Catch2)
-```
-
-## Automatic test registration
-
-Catch2's repository also contains two CMake scripts that help users
-with automatically registering their `TEST_CASE`s with CTest. They
-can be found in the `contrib` folder, and are
-
-1) `Catch.cmake` (and its dependency `CatchAddTests.cmake`)
-2) `ParseAndAddCatchTests.cmake`
-
-If Catch2 has been installed in system, both of these can be used after
-doing `find_package(Catch2 REQUIRED)`. Otherwise you need to add them
-to your CMake module path.
-
-### `Catch.cmake` and `CatchAddTests.cmake`
-
-`Catch.cmake` provides function `catch_discover_tests` to get tests from
-a target. This function works by running the resulting executable with
-`--list-test-names-only` flag, and then parsing the output to find all
-existing tests.
-
-#### Usage
-```cmake
-cmake_minimum_required(VERSION 3.5)
-
-project(baz LANGUAGES CXX VERSION 0.0.1)
-
-find_package(Catch2 REQUIRED)
-add_executable(foo test.cpp)
-target_link_libraries(foo Catch2::Catch2)
-
-include(CTest)
-include(Catch)
-catch_discover_tests(foo)
-```
-
-
-#### Customization
-`catch_discover_tests` can be given several extra argumets:
-```cmake
-catch_discover_tests(target
-                     [TEST_SPEC arg1...]
-                     [EXTRA_ARGS arg1...]
-                     [WORKING_DIRECTORY dir]
-                     [TEST_PREFIX prefix]
-                     [TEST_SUFFIX suffix]
-                     [PROPERTIES name1 value1...]
-                     [TEST_LIST var]
-)
-```
-
-* `TEST_SPEC arg1...`
-
-Specifies test cases, wildcarded test cases, tags and tag expressions to
-pass to the Catch executable alongside the `--list-test-names-only` flag.
-
-
-* `EXTRA_ARGS arg1...`
-
-Any extra arguments to pass on the command line to each test case.
-
-
-* `WORKING_DIRECTORY dir`
-
-Specifies the directory in which to run the discovered test cases.  If this
-option is not provided, the current binary directory is used.
-
-
-* `TEST_PREFIX prefix`
-
-Specifies a _prefix_ to be added to the name of each discovered test case.
-This can be useful when the same test executable is being used in multiple
-calls to `catch_discover_tests()`, with different `TEST_SPEC` or `EXTRA_ARGS`.
-
-
-* `TEST_SUFFIX suffix`
-
-Same as `TEST_PREFIX`, except it specific the _suffix_ for the test names.
-Both `TEST_PREFIX` and `TEST_SUFFIX` can be specified at the same time.
-
-
-* `PROPERTIES name1 value1...`
-
-Specifies additional properties to be set on all tests discovered by this
-invocation of `catch_discover_tests`.
-
-
-* `TEST_LIST var`
-
-Make the list of tests available in the variable `var`, rather than the
-default `<target>_TESTS`.  This can be useful when the same test
-executable is being used in multiple calls to `catch_discover_tests()`.
-Note that this variable is only available in CTest.
-
-
-### `ParseAndAddCatchTests.cmake`
-
-`ParseAndAddCatchTests` works by parsing all implementation files
-associated with the provided target, and registering them via CTest's
-`add_test`. This approach has some limitations, such as the fact that
-commented-out tests will be registered anyway.
-
-
-#### Usage
-
-```cmake
-cmake_minimum_required(VERSION 3.5)
-
-project(baz LANGUAGES CXX VERSION 0.0.1)
-
-find_package(Catch2 REQUIRED)
-add_executable(foo test.cpp)
-target_link_libraries(foo Catch2::Catch2)
-
-include(CTest)
-include(ParseAndAddCatchTests)
-ParseAndAddCatchTests(foo)
-```
-
-
-#### Customization
-
-`ParseAndAddCatchTests` provides some customization points:
-* `PARSE_CATCH_TESTS_VERBOSE` -- When `ON`, the script prints debug
-messages. Defaults to `OFF`.
-* `PARSE_CATCH_TESTS_NO_HIDDEN_TESTS` -- When `ON`, hidden tests (tests
-tagged with any of `[!hide]`, `[.]` or `[.foo]`) will not be registered.
-Defaults to `OFF`.
-* `PARSE_CATCH_TESTS_ADD_FIXTURE_IN_TEST_NAME` -- When `ON`, adds fixture
-class name to the test name in CTest. Defaults to `ON`.
-* `PARSE_CATCH_TESTS_ADD_TARGET_IN_TEST_NAME` -- When `ON`, adds target
-name to the test name in CTest. Defaults to `ON`.
-* `PARSE_CATCH_TESTS_ADD_TO_CONFIGURE_DEPENDS` -- When `ON`, adds test
-file to `CMAKE_CONFIGURE_DEPENDS`. This means that the CMake configuration
-step will be re-ran when the test files change, letting new tests be
-automatically discovered. Defaults to `OFF`.
-
-
-Optionally, one can specify a launching command to run tests by setting the
-variable `OptionalCatchTestLauncher` before calling `ParseAndAddCatchTests`. For
-instance to run some tests using `MPI` and other sequentially, one can write
-```cmake
-set(OptionalCatchTestLauncher ${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG} ${NUMPROC})
-ParseAndAddCatchTests(mpi_foo)
-unset(OptionalCatchTestLauncher)
-ParseAndAddCatchTests(bar)
-```
-
-## CMake project options
-
-Catch2's CMake project also provides some options for other projects
-that consume it. These are
-
-* `CATCH_BUILD_TESTING` -- When `ON`, Catch2's SelfTest project will be
-built. Defaults to `ON`. Note that Catch2 also obeys `BUILD_TESTING` CMake
-variable, so _both_ of them need to be `ON` for the SelfTest to be built,
-and either of them can be set to `OFF` to disable building SelfTest.
-* `CATCH_BUILD_EXAMPLES` -- When `ON`, Catch2's usage examples will be
-built. Defaults to `OFF`.
-* `CATCH_INSTALL_DOCS` -- When `ON`, Catch2's documentation will be
-included in the installation. Defaults to `ON`.
-* `CATCH_INSTALL_HELPERS` -- When `ON`, Catch2's contrib folder will be
-included in the installation. Defaults to `ON`.
-* `BUILD_TESTING` -- When `ON` and the project is not used as a subproject,
-Catch2's test binary will be built. Defaults to `ON`.
-
-
-## Installing Catch2 from git repository
-
-If you cannot install Catch2 from a package manager (e.g. Ubuntu 16.04
-provides catch only in version 1.2.0) you might want to install it from
-the repository instead. Assuming you have enough rights, you can just
-install it to the default location, like so:
-```
-$ git clone https://github.com/catchorg/Catch2.git
-$ cd Catch2
-$ cmake -Bbuild -H. -DBUILD_TESTING=OFF
-$ sudo cmake --build build/ --target install
-```
-
-If you do not have superuser rights, you will also need to specify
-[CMAKE_INSTALL_PREFIX](https://cmake.org/cmake/help/latest/variable/CMAKE_INSTALL_PREFIX.html)
-when configuring the build, and then modify your calls to
-[find_package](https://cmake.org/cmake/help/latest/command/find_package.html)
-accordingly.
-
-
----
-
-[Home](Readme.md#top)

docs/command-line.md

@@ -1,33 +1,5 @@
-<a id="top"></a>
-# Command line
-
-**Contents**<br>
-[Specifying which tests to run](#specifying-which-tests-to-run)<br>
-[Choosing a reporter to use](#choosing-a-reporter-to-use)<br>
-[Breaking into the debugger](#breaking-into-the-debugger)<br>
-[Showing results for successful tests](#showing-results-for-successful-tests)<br>
-[Aborting after a certain number of failures](#aborting-after-a-certain-number-of-failures)<br>
-[Listing available tests, tags or reporters](#listing-available-tests-tags-or-reporters)<br>
-[Sending output to a file](#sending-output-to-a-file)<br>
-[Naming a test run](#naming-a-test-run)<br>
-[Eliding assertions expected to throw](#eliding-assertions-expected-to-throw)<br>
-[Make whitespace visible](#make-whitespace-visible)<br>
-[Warnings](#warnings)<br>
-[Reporting timings](#reporting-timings)<br>
-[Load test names to run from a file](#load-test-names-to-run-from-a-file)<br>
-[Just test names](#just-test-names)<br>
-[Specify the order test cases are run](#specify-the-order-test-cases-are-run)<br>
-[Specify a seed for the Random Number Generator](#specify-a-seed-for-the-random-number-generator)<br>
-[Identify framework and version according to the libIdentify standard](#identify-framework-and-version-according-to-the-libidentify-standard)<br>
-[Wait for key before continuing](#wait-for-key-before-continuing)<br>
-[Specify multiples of clock resolution to run benchmarks for](#specify-multiples-of-clock-resolution-to-run-benchmarks-for)<br>
-[Usage](#usage)<br>
-[Specify the section to run](#specify-the-section-to-run)<br>
-[Filenames as tags](#filenames-as-tags)<br>
-[Override output colouring](#override-output-colouring)<br>
-
 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 following links to take you straight to that option - or scroll on to browse the available options.
+Click one of the followings links to take you straight to that option - or scroll on to browse the available options.
 
 <a href="#specifying-which-tests-to-run">               `    <test-spec> ...`</a><br />
 <a href="#usage">                                       `    -h, -?, --help`</a><br />
@@ -57,8 +29,6 @@ Click one of the following links to take you straight to that option - or scroll
 <a href="#rng-seed">                                    `    --rng-seed`</a><br />
 <a href="#libidentify">                                 `    --libidentify`</a><br />
 <a href="#wait-for-keypress">                           `    --wait-for-keypress`</a><br />
-<a href="#benchmark-resolution-multiple">               `    --benchmark-resolution-multiple`</a><br />
-<a href="#use-colour">                                  `    --use-colour`</a><br />
 
 </br>
 
@@ -80,7 +50,7 @@ Wildcards consist of the `*` character at the beginning and/or end of test case
 
 Test specs are case insensitive.
 
-If a spec is prefixed with `exclude:` or the `~` character then the pattern matches an exclusion. This means that tests matching the pattern are excluded from the set - even if a prior inclusion spec included them. Subsequent inclusion specs will take precedence, however.
+If a spec is prefixed with `exclude:` or the `~` character then the pattern matches an exclusion. This means that tests matching the pattern are excluded from the set - even if a prior inclusion spec included them. Subsequent inclusion specs will take precendence, however.
 Inclusions and exclusions are evaluated in left-to-right order.
 
 Test case examples:
@@ -96,7 +66,7 @@ a* ~ab* abc             Matches all tests that start with 'a', except those that
 </pre>
 
 Names within square brackets are interpreted as tags.
-A series of tags form an AND expression whereas a comma-separated sequence forms an OR expression. e.g.:
+A series of tags form an AND expression wheras a comma-separated sequence forms an OR expression. e.g.:
 
 <pre>[one][two],[three]</pre>
 This matches all tests tagged `[one]` and `[two]`, as well as all tests tagged `[three]`
@@ -124,9 +94,7 @@ The JUnit reporter is an xml format that follows the structure of the JUnit XML
 ## Breaking into the debugger
 <pre>-b, --break</pre>
 
-Under most debuggers Catch2 is capable of automatically breaking on a test
-failure. This allows the user to see the current state of the test during
-failure.
+In some IDEs (currently XCode and Visual Studio) it is possible for Catch to break into the debugger on a test failure. This can be very helpful during debug sessions - especially when there is more than one path through a particular test.
 
 <a id="showing-results-for-successful-tests"></a>
 ## Showing results for successful tests
@@ -196,16 +164,9 @@ This option transforms tabs and newline characters into ```\t``` and ```\n``` re
 ## Warnings
 <pre>-w, --warn &lt;warning name></pre>
 
-Enables reporting of suspicious test states. There are currently two
-available warnings
-
-```
-    NoAssertions   // Fail test case / leaf section if no assertions
-                   // (e.g. `REQUIRE`) is encountered.
-    NoTests        // Return non-zero exit code when no test cases were run
-                   // Also calls reporter's noMatchingTestCases method
-```
+Enables reporting of warnings (only one, at time of this writing). If a warning is issued it fails the test.
 
+The ony available warning, presently, is ```NoAssertions```. This warning fails a test case, or (leaf) section if no assertions (```REQUIRE```/ ```CHECK``` etc) are encountered.
 
 <a id="reporting-timings"></a>
 ## Reporting timings
@@ -267,13 +228,6 @@ See [The LibIdentify repo for more information and examples](https://github.com/
 Will cause the executable to print a message and wait until the return/ enter key is pressed before continuing -
 either before running any tests, after running all tests - or both, depending on the argument.
 
-<a id="benchmark-resolution-multiple"></a>
-## Specify multiples of clock resolution to run benchmarks for
-<pre>--benchmark-resolution-multiple &lt;multiplier&gt;</pre>
-
-When running benchmarks the clock resolution is estimated. Benchmarks are then run for exponentially increasing
-numbers of iterations until some multiple of the estimated resolution is exceed. By default that multiple is 100, but 
-it can be overridden here.
 
 <a id="usage"></a>
 ## Usage
@@ -333,17 +287,7 @@ filename it is found in, with any extension stripped, prefixed with the `#` char
 
 So, for example,  tests within the file `~\Dev\MyProject\Ferrets.cpp` would be tagged `[#Ferrets]`.
 
-<a id="use-colour"></a>
-## Override output colouring
-<pre>--use-colour &lt;yes|no|auto&gt;</pre>
-
-Catch colours output for terminals, but omits colouring when it detects that
-output is being sent to a pipe. This is done to avoid interfering with automated
-processing of output.
-
-`--use-colour yes` forces coloured output, `--use-colour no` disables coloured
-output. The default behaviour is `--use-colour auto`.
 
 ---
 
-[Home](Readme.md#top)
+[Home](Readme.md)

docs/commercial-users.md

@@ -1,7 +1,6 @@
-<a id="top"></a>
 # Commercial users of Catch
 
-As well as [Open Source](opensource-users.md#top) users Catch is widely used within proprietary code bases too.
+As well as [Open Source](opensource-users.md) 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. 
@@ -13,7 +12,5 @@ fact then please let us know - either directly, via a PR or
 [issue](https://github.com/philsquared/Catch/issues), or on the [forums](https://groups.google.com/forum/?fromgroups#!forum/catch-forum).
  
  - Bloomberg
- - [Bloomlife](https://bloomlife.com)
  - NASA
  - [Inscopix Inc.](https://www.inscopix.com/)
- - [Makimo](https://makimo.pl/)

docs/configuration.md

@@ -1,53 +1,26 @@
-<a id="top"></a>
-# Compile-time configuration
-
-**Contents**<br>
-[main()/ implementation](#main-implementation)<br>
-[Reporter / Listener interfaces](#reporter--listener-interfaces)<br>
-[Prefixing Catch macros](#prefixing-catch-macros)<br>
-[Terminal colour](#terminal-colour)<br>
-[Console width](#console-width)<br>
-[stdout](#stdout)<br>
-[Fallback stringifier](#fallback-stringifier)<br>
-[Default reporter](#default-reporter)<br>
-[C++11 toggles](#c11-toggles)<br>
-[C++17 toggles](#c17-toggles)<br>
-[Other toggles](#other-toggles)<br>
-[Windows header clutter](#windows-header-clutter)<br>
-[Enabling stringification](#enabling-stringification)<br>
-[Disabling exceptions](#disabling-exceptions)<br>
-
 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
+	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*.
 
-## Reporter / Listener interfaces
+#  Prefixing Catch macros
 
-    CATCH_CONFIG_EXTERNAL_INTERFACES  // Brings in necessary 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
+	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
-    CATCH_CONFIG_COLOUR_ANSI      // forces ANSI colour codes to be used
+	CATCH_CONFIG_COLOUR_NONE	// completely disables all text colouring
+	CATCH_CONFIG_COLOUR_WINDOWS	// forces the Win32 console API to be used
+	CATCH_CONFIG_COLOUR_ANSI	// forces ANSI colour codes to be used
 
 Yes, I am English, so I will continue to spell "colour" with a 'u'.
 
@@ -59,96 +32,82 @@ 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_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
+	CATCH_CONFIG_NOSTDOUT
 
-To support platforms that do not provide `std::cout`, `std::cerr` and
-`std::clog`, Catch does not usem the directly, but rather calls
-`Catch::cout`, `Catch::cerr` and `Catch::clog`. You can replace their
-implementation by defining `CATCH_CONFIG_NOSTDOUT` and implementing
-them yourself, their signatures are:
+Catch does not use ```std::cout```, ```std::cerr``` and ```std::clog``` directly but gets them from ```Catch::cout()```, ```Catch::cerr()``` and ```Catch::clog``` respectively. If the above identifier is defined these functions are left unimplemented and you must implement them yourself. Their signatures are:
 
     std::ostream& cout();
     std::ostream& cerr();
     std::ostream& clog();
 
-[You can see an example of replacing these functions here.](
-../examples/231-Cfg-OutputStreams.cpp)
+This can be useful on certain platforms that do not provide the standard iostreams, such as certain embedded systems.
 
+# Default reporter
 
-## Fallback stringifier
+    CATCH_CONFIG_DEFAULT_REPORTER <reporter>
 
-By default, when Catch's stringification machinery has to stringify
-a type that does not specialize `StringMaker`, does not overload `operator<<`,
-is not an enumeration and is not a range, it uses `"{?}"`. This can be
-overridden by defining `CATCH_CONFIG_FALLBACK_STRINGIFIER` to name of a
-function that should perform the stringification instead.
+The default reporter (reporter used when no reporters are explicitly specified) can be overriden during compilation time by using the above macro. Note that desired value of the macro is a C string and quotes have to be escaped during compilation: `clang++ test.cpp -DCATCH_CONFIG_DEFAULT_REPORTER=\"xml\"`.
 
-All types that do not provide `StringMaker` specialization or `operator<<`
-overload will be sent to this function (this includes enums and ranges).
-The provided function must return `std::string` and must accept any type,
-e.g. via overloading.
+# C++ conformance toggles
 
-_Note that if the provided function does not handle a type and this type
-requires to be stringified, the compilation will fail._
+    CATCH_CONFIG_CPP11_NULLPTR                 // nullptr is supported?
+    CATCH_CONFIG_CPP11_NOEXCEPT                // noexcept is supported?
+    CATCH_CONFIG_CPP11_GENERATED_METHODS       // delete and default keywords for methods
+    CATCH_CONFIG_CPP11_IS_ENUM                 // std::is_enum is supported?
+    CATCH_CONFIG_CPP11_TUPLE                   // std::tuple is supported
+    CATCH_CONFIG_VARIADIC_MACROS               // Usually pre-C++11 compiler extensions are sufficient
+    CATCH_CONFIG_CPP11_LONG_LONG               // generates overloads for the long long type
+    CATCH_CONFIG_CPP11_OVERRIDE                // CATCH_OVERRIDE expands to override (for virtual function implementations)
+    CATCH_CONFIG_CPP11_UNIQUE_PTR              // Use std::unique_ptr instead of std::auto_ptr
+    CATCH_CONFIG_CPP11_SHUFFLE                 // Use std::shuffle instead of std::random_shuffle
+    CATCH_CONFIG_CPP11_TYPE_TRAITS             // Use std::enable_if and <type_traits>
+    CATCH_CONFIG_CPP11_STREAM_INSERTABLE_CHECK // Use C++11 expression SFINAE to check if class can be inserted to std::ostream
 
+Catch has some basic compiler detection that will attempt to select the appropriate mix of these macros. However being incomplete - and often without access to the respective compilers - this detection tends to be conservative.
+So overriding control is given to the user. If a compiler supports a feature (and Catch does not already detect it) then one or more of these may be defined to enable it (or suppress it, in some cases). If you do do this please raise an issue, specifying your compiler version (ideally with an idea of how to detect it) and stating that it has such support.
+You may also suppress any of these features by using the `_NO_` form, e.g. `CATCH_CONFIG_CPP11_NO_NULLPTR`.
 
-## Default reporter
+All C++11 support can be disabled with `CATCH_CONFIG_NO_CPP11`
 
-Catch's default reporter can be changed by defining macro
-`CATCH_CONFIG_DEFAULT_REPORTER` to string literal naming the desired
-default reporter.
+## `CATCH_CONFIG_CPP11_STREAM_INSERTABLE_CHECK`
 
-This means that defining `CATCH_CONFIG_DEFAULT_REPORTER` to `"console"`
-is equivalent with the out-of-the-box experience.
+This flag is off by default, but allows you to resolve problems caused by types with private base class that are streamable, but the classes themselves are not. Without it, the following code will cause a compilation error:
+```cpp
+#define CATCH_CONFIG_MAIN
+#include <catch.hpp>
+struct A {};
+std::ostream &operator<< (std::ostream &o, const A &v) { return o << 0; }
 
+struct B : private A {
+    bool operator==(int){ return true;}
+};
 
-## C++11 toggles
+B f ();
+std::ostream g ();
 
-    CATCH_CONFIG_CPP11_TO_STRING // Use `std::to_string`
+TEST_CASE ("Error in streamable check") {
+    B x;
+    REQUIRE (x == 4);
+}
+```
 
-Because we support platforms whose standard library does not contain
-`std::to_string`, it is possible to force Catch to use a workaround
-based on `std::stringstream`. On platforms other than Android,
-the default is to use `std::to_string`. On Android, the default is to
-use the `stringstream` workaround. As always, it is possible to override
-Catch's selection, by defining either `CATCH_CONFIG_CPP11_TO_STRING` or
-`CATCH_CONFIG_NO_CPP11_TO_STRING`.
-
-
-## C++17 toggles
-
-    CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS  // Use std::uncaught_exceptions instead of std::uncaught_exception
-    CATCH_CONFIG_CPP17_STRING_VIEW          // Provide StringMaker specialization for std::string_view
-    CATCH_CONFIG_CPP17_VARIANT              // Override C++17 detection for CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
-
-Catch contains basic compiler/standard detection and attempts to use
-some C++17 features whenever appropriate. This automatic detection
-can be manually overridden in both directions, that is, a feature
-can be enabled by defining the macro in the table above, and disabled
-by using `_NO_` in the macro, e.g. `CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS`.
-
-
-## 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
     CATCH_CONFIG_FAST_COMPILE               // Sacrifices some (rather minor) features for compilation speed
-    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
-    CATCH_CONFIG_WCHAR                      // Enables use of wchart_t
-    CATCH_CONFIG_EXPERIMENTAL_REDIRECT      // Enables the new (experimental) way of capturing stdout/stderr
 
 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.
 
@@ -156,92 +115,26 @@ Currently Catch enables `CATCH_CONFIG_WINDOWS_SEH` only when compiled with MSVC,
 
 `CATCH_CONFIG_WINDOWS_CRTDBG` is off by default. If enabled, Windows's CRT is used to check for memory leaks, and displays them after the tests finish running.
 
-`CATCH_CONFIG_WCHAR` is on by default, but can be disabled. Currently
-it is only used in support for DJGPP cross-compiler.
+Just as with the C++11 conformance toggles, these toggles can be disabled by using `_NO_` form of the toggle, e.g. `CATCH_CONFIG_NO_WINDOWS_SEH`.
 
-With the exception of `CATCH_CONFIG_EXPERIMENTAL_REDIRECT`,
-these toggles can be disabled by using `_NO_` form of the toggle,
-e.g. `CATCH_CONFIG_NO_WINDOWS_SEH`.
+## `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.
 
-### `CATCH_CONFIG_FAST_COMPILE`
-This compile-time flag speeds up compilation of assertion macros by ~20%,
-by disabling the generation of assertion-local try-catch blocks for
-non-exception family of assertion macros ({`REQUIRE`,`CHECK`}{``,`_FALSE`, `_THAT`}).
-This disables translation of exceptions thrown under these assertions, 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_FAST_COMPILE` has to be either defined, or not defined,
-in all translation units that are linked into single test binary.
+## `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).
 
-### `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).
-
-### `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
+# 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:
 
     CATCH_CONFIG_NO_NOMINMAX            // Stops Catch from using NOMINMAX macro 
     CATCH_CONFIG_NO_WIN32_LEAN_AND_MEAN // Stops Catch from using WIN32_LEAN_AND_MEAN macro
 
-
-## Enabling stringification
-
-By default, Catch does not stringify some types from the standard library. This is done to avoid dragging in various standard library headers by default. However, Catch does contain these and can be configured to provide them, using these macros:
-
-    CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER     // Provide StringMaker specialization for std::pair
-    CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER    // Provide StringMaker specialization for std::tuple
-    CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER   // Provide StringMaker specialization for std::chrono::duration, std::chrono::timepoint
-    CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER  // Provide StringMaker specialization for std::variant, std::monostate (on C++17)
-    CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER // Provide StringMaker specialization for std::optional (on C++17)
-    CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS     // Defines all of the above
-
-
-## Disabling exceptions
-
-By default, Catch2 uses exceptions to signal errors and to abort tests
-when an assertion from the `REQUIRE` family of assertions fails. We also
-provide an experimental support for disabling exceptions. Catch2 should
-automatically detect when it is compiled with exceptions disabled, but
-it can be forced to compile without exceptions by defining
-
-    CATCH_CONFIG_DISABLE_EXCEPTIONS
-
-Note that when using Catch2 without exceptions, there are 2 major
-limitations:
-
-1) If there is an error that would normally be signalled by an exception,
-the exception's message will instead be written to `Catch::cerr` and
-`std::terminate` will be called.
-2) If an assertion from the `REQUIRE` family of macros fails,
-`std::terminate` will be called after the active reporter returns.
-
-
-There is also a customization point for the exact behaviour of what
-happens instead of exception being thrown. To use it, define
-
-    CATCH_CONFIG_DISABLE_EXCEPTIONS_CUSTOM_HANDLER
-
-and provide a definition for this function:
-
-```cpp
-namespace Catch {
-    [[noreturn]]
-    void throw_exception(std::exception const&);
-}
-```
-
 ---
 
-[Home](Readme.md#top)
+[Home](Readme.md)

docs/contributing.md

@@ -1,8 +1,7 @@
-<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
-additional compilers - or just a fix to the documentation - all contributions are very welcome and very much appreciated.
+So you want to contribute something to Catch? That's great! Whether it's a bug fix, a new feature, support for 
+additional compilers - or just a fix to the documentation - all contributions are very welcome and very much appreciated. 
 Of course so are bug reports and other comments and questions.
 
 If you are contributing to the code base there are a few simple guidelines to keep in mind. This also includes notes to
@@ -16,7 +15,7 @@ Ongoing development is currently on _master_. At some point an integration branc
 
 ## Directory structure
 
-_Users_ of Catch primarily use the single header version. _Maintainers_ should work with the full source (which is still,
+_Users_ of Catch primarily use the single header version. _Maintainers_ should work with the full source (which is still, 
 primarily, in headers). This can be found in the `include` folder. There are a set of test files, currently under
 `projects/SelfTest`. The test app can be built via CMake from the `CMakeLists.txt` file in the root, or you can generate
 project files for Visual Studio, XCode, and others (instructions in the `projects` folder). If you have access to CLion,
@@ -37,73 +36,25 @@ as these are managed by the scripts!__
 
 ## Testing your changes
 
-Obviously all changes to Catch's code should be tested. If you added new
-functionality, you should add tests covering and showcasing it. Even if you have
-only made changes to Catch internals (i.e. you implemented some performance
-improvements), you should still test your changes.
+Obviously all changes to Catch's code should be tested. If you added new functionality, you should add tests covering and
+showcasing it. Even if you have only made changes to Catch internals (ie you implemented some performance improvements),
+you should still test your changes.
 
-This means 2 things
+This means 3 things
 
-* Compiling Catch's SelfTest project:
-```
-$ cd Catch2
-$ cmake -Bdebug-build -H. -DCMAKE_BUILD_TYPE=Debug
-$ cmake --build debug-build
-```
-because code that does not compile is evidently incorrect. Obviously,
-you are not expected to have access to all the compilers and platforms
-supported by Catch2, but you should at least smoke test your changes
-on your platform. Our CI pipeline will check your PR against most of
-the supported platforms, but it takes an hour to finish -- compiling
-locally takes just a few minutes.
+* Compiling Catch's SelfTest project -- code that does not compile is evidently incorrect. Obviously, you are not expected to
+have access to all compilers and platforms Catch supports, Catch's CI pipeline will compile your code using supported compilers
+once you open a PR.
+* Running the SelfTest binary. There should be no unexpected failures on simple run.
+* Running Catch's approval tests. Approval tests compare current output of the SelfTest binary in various configurations against
+known good output. Catch's repository provides utility scripts `approvalTests.py` to help you with this. It needs to be passed
+the SelfTest binary compiled with your changes, like so: `$ ./scripts/approvalTests.py clang-build/SelfTest`. The output should
+be fairly self-explanatory.
 
 
-* Running the tests via CTest:
-```
-$ cd debug-build
-$ ctest -j 2 --output-on-failure
-```
-If you added new tests, approval tests are very likely to fail. If they
-do not, it means that your changes weren't run as part of them. This
-_might_ be intentional, but usually is not.
 
-The approval tests compare current output of the SelfTest binary in various
-configurations against known good outputs. The reason it fails is,
-_usually_, that you've added new tests but have not yet approved the changes
-they introduce. This is done with the `scripts/approve.py` script, but
-before you do so, you need to check that the introduced changes are indeed
-intentional.
-
-
-## Code constructs to watch out for
-
-This section is a (sadly incomplete) listing of various constructs that
-are problematic and are not always caught by our CI infrastructure.
-
-### Naked exceptions and exceptions-related function
-
-If you are throwing an exception, it should be done via `CATCH_ERROR`
-or `CATCH_RUNTIME_ERROR` in `catch_enforce.h`. These macros will handle
-the differences between compilation with or without exceptions for you.
-However, some platforms (IAR) also have problems with exceptions-related
-functions, such as `std::current_exceptions`. We do not have IAR in our
-CI, but luckily there should not be too many reasons to use these.
-However, if you do, they should be kept behind a
-`CATCH_CONFIG_DISABLE_EXCEPTIONS` macro.
-
-### Unqualified usage of functions from C's stdlib
-
-If you are using a function from C's stdlib, please include the header
-as `<cfoo>` and call the function qualified. The common knowledge that
-there is no difference is wrong, QNX and VxWorks won't compile if you
-include the header as `<cfoo>` and call the function unqualified.
-
-
-----
-
-_This documentation will always be in-progress as new information comes
-up, but we are trying to keep it as up to date as possible._
+ *this document is still in-progress...*
 
 ---
 
-[Home](Readme.md#top)
+[Home](Readme.md)

docs/deprecations.md

@@ -1,93 +0,0 @@
-<a id="top"></a>
-# Deprecations and incoming changes
-
-This page documents current deprecations and upcoming planned changes
-inside Catch2. The difference between these is that a deprecated feature
-will be removed, while a planned change to a feature means that the
-feature will behave differently, but will still be present. Obviously,
-either of these is a breaking change, and thus will not happen until
-at least the next major release.
-
-
-## Deprecations
-
-### `--list-*` return values
-
-The return codes of the `--list-*` family of command line arguments
-will no longer be equal to the number of tests/tags/etc found, instead
-it will be 0 for success and non-zero for failure.
-
-
-### `--list-test-names-only`
-
-`--list-test-names-only` command line argument will be removed.
-
-
-### `ANON_TEST_CASE`
-
-`ANON_TEST_CASE` is scheduled for removal, as it can be fully replaced
-by a `TEST_CASE` with no arguments.
-
-
-### Secondary description amongst tags
-
-Currently, the tags part of `TEST_CASE` (and others) macro can also
-contain text that is not part of tags. This text is then separated into
-a "description" of the test case, but the description is then never used
-apart from writing it out for `--list-tests -v high`.
-
-Because it isn't actually used nor documented, and brings complications
-to Catch2's internals, description support will be removed.
-
-
-## Planned changes
-
-
-### Reporter verbosities
-
-The current implementation of verbosities, where the reporter is checked
-up-front whether it supports the requested verbosity, is fundamentally
-misguided and will be changed. The new implementation will no longer check
-whether the specified reporter supports the requested verbosity, instead
-it will be up to the reporters to deal with verbosities as they see fit
-(with an expectation that unsupported verbosities will be, at most,
-warnings, but not errors).
-
-
-### Output format of `--list-*` command line parameters
-
-The various list operations will be piped through reporters. This means
-that e.g. XML reporter will write the output as machine-parseable XML,
-while the Console reporter will keep the current, human-oriented output.
-
-
-### `CHECKED_IF` and `CHECKED_ELSE`
-
-To make the `CHECKED_IF` and `CHECKED_ELSE` macros more useful, they will
-be marked as "OK to fail" (`Catch::ResultDisposition::SuppressFail` flag
-will be added), which means that their failure will not fail the test,
-making the `else` actually useful.
-
-
-### Change semantics of `[.]` and tag exclusion
-
-Currently, given these 2 tests
-```cpp
-TEST_CASE("A", "[.][foo]") {}
-TEST_CASE("B", "[.][bar]") {}
-```
-specifying `[foo]` as the testspec will run test "A" and specifying
-`~[foo]` will run test "B", even though it is hidden. Also, specifying
-`~[baz]` will run both tests. This behaviour is often surprising and will
-be changed so that hidden tests are included in a run only if they
-positively match a testspec.
-
-
-### Console Colour API
-
-The API for Catch2's console colour will be changed to take an extra
-argument, the stream to which the colour code should be applied.
-
----
-
-[Home](Readme.md#top)

docs/event-listeners.md

@@ -1,4 +1,3 @@
-<a id="top"></a>
 # Event Listeners
 
 A `Listener` is a class you can register with Catch that will then be passed events,
@@ -13,13 +12,12 @@ 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`.
 
-Then register it using `CATCH_REGISTER_LISTENER`.
+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`.
 
-For example ([complete source code](../examples/210-Evt-EventListeners.cpp)):
+For example:
 
 ```c++
 #define CATCH_CONFIG_MAIN
@@ -29,13 +27,13 @@ struct MyListener : Catch::TestEventListenerBase {
 
     using TestEventListenerBase::TestEventListenerBase; // inherit constructor
 
-    void testCaseStarting( Catch::TestCaseInfo const& testInfo ) override {
+    virtual void testCaseStarting( Catch::TestCaseInfo const& testInfo ) override {
         // Perform some setup before a test case is run
     }
     
-    void testCaseEnded( Catch::TestCaseStats const& testCaseStats ) override {
+    virtual void testCaseEnded( Catch::TestCaseStats const& testCaseStats ) override {
         // Tear-down after a test case is run
-    }
+    }    
 };
 CATCH_REGISTER_LISTENER( MyListener )
 ```
@@ -44,7 +42,7 @@ _Note that you should not use any assertion macros within a Listener!_
 
 ## Events that can be hooked
 
-The following are the methods that can be overridden in the Listener:
+The following are the methods that can be overriden in the Listener:
 
 ```c++
 // The whole test run, starting and ending
@@ -72,4 +70,4 @@ just look in the source code to see what fields are available.
 
 ---
 
-[Home](Readme.md#top)
+[Home](Readme.md)

docs/generators.md

@@ -1,137 +0,0 @@
-<a id="top"></a>
-# Data Generators
-
-Data generators (also known as _data driven/parametrized test cases_)
-let you reuse the same set of assertions across different input values.
-In Catch2, this means that they respect the ordering and nesting
-of the `TEST_CASE` and `SECTION` macros, and their nested sections
-are run once per each value in a generator.
-
-This is best explained with an example:
-```cpp
-TEST_CASE("Generators") {
-    auto i = GENERATE(1, 2, 3);
-    SECTION("one") {
-        auto j = GENERATE( -3, -2, -1 );
-        REQUIRE(j < i);
-    }
-}
-```
-
-The assertion in this test case will be run 9 times, because there
-are 3 possible values for `i` (1, 2, and 3) and there are 3 possible
-values for `j` (-3, -2, and -1).
-
-
-There are 2 parts to generators in Catch2, the `GENERATE` macro together
-with the already provided generators, and the `IGenerator<T>` interface
-that allows users to implement their own generators.
-
-## Provided generators
-
-Catch2's provided generator functionality consists of three parts,
-
-* `GENERATE` macro,  that serves to integrate generator expression with
-a test case,
-* 2 fundamental generators
-  * `ValueGenerator<T>` -- contains only single element
-  * `ValuesGenerator<T>` -- contains multiple elements
-* 5 generic generators that modify other generators
-  * `FilterGenerator<T, Predicate>` -- filters out elements from a generator
-  for which the predicate returns "false"
-  * `TakeGenerator<T>` -- takes first `n` elements from a generator
-  * `RepeatGenerator<T>` -- repeats output from a generator `n` times
-  * `MapGenerator<T, U, Func>` -- returns the result of applying `Func`
-  on elements from a different generator
-  * `ChunkGenerator<T>` -- returns chunks (inside `std::vector`) of n elements from a generator
-* 3 specific purpose generators
-  * `RandomIntegerGenerator<Integral>` -- generates random Integrals from range
-  * `RandomFloatGenerator<Float>` -- generates random Floats from range
-  * `RangeGenerator<T>` -- generates all values inside a specific range
-
-The generators also have associated helper functions that infer their
-type, making their usage much nicer. These are
-
-* `value(T&&)` for `ValueGenerator<T>`
-* `values(std::initializer_list<T>)` for `ValuesGenerator<T>`
-* `filter(predicate, GeneratorWrapper<T>&&)` for `FilterGenerator<T, Predicate>`
-* `take(count, GeneratorWrapper<T>&&)` for `TakeGenerator<T>`
-* `repeat(repeats, GeneratorWrapper<T>&&)` for `RepeatGenerator<T>`
-* `map(func, GeneratorWrapper<T>&&)` for `MapGenerator<T, U, Func>` (map `U` to `T`, deduced from `Func`)
-* `map<T>(func, GeneratorWrapper<U>&&)` for `MapGenerator<T, U, Func>` (map `U` to `T`)
-* `chunk(chunk-size, GeneratorWrapper<T>&&)` for `ChunkGenerator<T>`
-* `random(IntegerOrFloat a, IntegerOrFloat b)` for `RandomIntegerGenerator` or `RandomFloatGenerator`
-* `range(start, end)` for `RangeGenerator<T>` with a step size of `1`
-* `range(start, end, step)` for `RangeGenerator<T>` with a custom step size
-
-
-And can be used as shown in the example below to create a generator
-that returns 100 odd random number:
-
-```cpp
-TEST_CASE("Generating random ints", "[example][generator]") {
-    SECTION("Deducing functions") {
-        auto i = GENERATE(take(100, filter([](int i) { return i % 2 == 1; }, random(-100, 100))));
-        REQUIRE(i > -100);
-        REQUIRE(i < 100);
-        REQUIRE(i % 2 == 1);
-    }
-}
-```
-
-
-Apart from registering generators with Catch2, the `GENERATE` macro has
-one more purpose, and that is to provide simple way of generating trivial
-generators, as seen in the first example on this page, where we used it
-as `auto i = GENERATE(1, 2, 3);`. This usage converted each of the three
-literals into a single `ValueGenerator<int>` and then placed them all in
-a special generator that concatenates other generators. It can also be
-used with other generators as arguments, such as `auto i = GENERATE(0, 2,
-take(100, random(300, 3000)));`. This is useful e.g. if you know that
-specific inputs are problematic and want to test them separately/first.
-
-**For safety reasons, you cannot use variables inside the `GENERATE` macro.
-This is done because the generator expression _will_ outlive the outside
-scope and thus capturing references is dangerous. If you need to use
-variables inside the generator expression, make sure you thought through
-the lifetime implications and use `GENERATE_COPY` or `GENERATE_REF`.**
-
-You can also override the inferred type by using `as<type>` as the first
-argument to the macro. This can be useful when dealing with string literals,
-if you want them to come out as `std::string`:
-
-```cpp
-TEST_CASE("type conversion", "[generators]") {
-    auto str = GENERATE(as<std::string>{}, "a", "bb", "ccc");
-    REQUIRE(str.size() > 0);
-}
-```
-
-## Generator interface
-
-You can also implement your own generators, by deriving from the
-`IGenerator<T>` interface:
-
-```cpp
-template<typename T>
-struct IGenerator : GeneratorUntypedBase {
-    // via GeneratorUntypedBase:
-    // Attempts to move the generator to the next element.
-    // Returns true if successful (and thus has another element that can be read)
-    virtual bool next() = 0;
-
-    // Precondition:
-    // The generator is either freshly constructed or the last call to next() returned true
-    virtual T const& get() const = 0;
-};
-```
-
-However, to be able to use your custom generator inside `GENERATE`, it
-will need to be wrapped inside a `GeneratorWrapper<T>`.
-`GeneratorWrapper<T>` is a value wrapper around a
-`std::unique_ptr<IGenerator<T>>`.
-
-For full example of implementing your own generator, look into Catch2's
-examples, specifically
-[Generators: Create your own generator](../examples/300-Gen-OwnGenerator.cpp).
-

docs/limitations.md

@@ -1,57 +1,12 @@
-<a id="top"></a>
 # Known limitations
 
-Over time, some limitations of Catch2 emerged. Some of these are due
-to implementation details that cannot be easily changed, some of these
-are due to lack of development resources on our part, and some of these
-are due to plain old 3rd party 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" );
-        }
-    }
-}
-```
-
-or with a `DYNAMIC_SECTION` macro (that was made for exactly this purpose):
-
-```cpp
-TEST_CASE( "Looped section" ) {
-    for (char i = '0'; i < '5'; ++i) {
-        DYNAMIC_SECTION( "Looped section " << i) {
-            SUCCEED( "Everything is OK" );
-        }
-    }
-}
-```
-
-### Tests might be run again if last section fails
-
-If the last section in a test fails, it might be run again. This is because
-Catch2 discovers `SECTION`s dynamically, as they are about to run, and
-if the last section in test case is aborted during execution (e.g. via
-the `REQUIRE` family of macros), Catch2 does not know that there are no
-more sections in that test case and must run the test case again.
-
+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.
 
 ## Features
 This section outlines some missing features, what is their status and their possible workarounds.
 
 ### Thread safe assertions
-Catch2's assertion macros are not thread safe. This does not mean that
-you cannot use threads inside Catch's test, but that only single thread
-can interact with Catch's assertions and other macros.
+Because threading support in standard C++98 is limited (well, non-existent), assertion macros in Catch are not thread safe. This does not mean that you cannot use threads inside Catch's test, but that only single thread can interact with Catch's assertions and other macros.
 
 This means that this is ok
 ```cpp
@@ -79,8 +34,8 @@ because only one thread passes the `REQUIRE` macro and this is not
     REQUIRE(cnt == 16);
 ```
 
-Because C++11 provides the necessary tools to do this, we are planning
-to remove this limitation in the future.
+
+_This limitation is highly unlikely to be lifted before Catch 2 is released._
 
 ### Process isolation in a test
 Catch does not support running tests in isolated (forked) processes. While this might in the future, the fact that Windows does not support forking and only allows full-on process creation and the desire to keep code as similar as possible across platforms, mean that this is likely to take significant development time, that is not currently available.
@@ -126,20 +81,34 @@ with expansion:
   ""\" == ""\"
 ```
 
-### Visual Studio 2015 -- Alignment compilation error (C2718)
 
-VS 2015 has a known bug, where `declval<T>` can cause compilation error
-if `T` has alignment requirements that it cannot meet.
+### 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
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"
 
+TEST_CASE("Syntax error with VC12") {
+    for ( auto x : { 1 , 2, 3 } )
+        REQUIRE( x < 3.14 );
+}
+```
+An easy workaround is possible, use braces:
+```cpp
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"
 
-A workaround is to explicitly specialize `Catch::is_range` for given
-type (this avoids code path that uses `declval<T>` in a SFINAE context).
+TEST_CASE("No longer a syntax error with VC12") {
+    for ( auto x : { 1 , 2, 3 } ) {
+        REQUIRE( x < 3.14 );
+    }
+}
+```
 
+### Visual Studio 2003 -- Syntax error caused by improperly expanded `__LINE__` macro
+Older version of Visual Studio can have trouble compiling Catch, not expanding the `__LINE__` macro properly when recompiling the test binary. This is caused by Edit and Continue being on.
 
-### Visual Studio 2015 -- Wrong line number reported in debug mode
-VS 2015 has a known bug where `__LINE__` macro can be improperly expanded under certain circumstances, while compiling multi-file project in Debug mode.
-
-A workaround is to compile the binary in Release mode.
+A workaround is to turn off Edit and Continue when compiling the test binary.
 
 ### Clang/G++ -- skipping leaf sections after an exception
 Some versions of `libc++` and `libstdc++` (or their runtimes) have a bug with `std::uncaught_exception()` getting stuck returning `true` after rethrow, even if there are no active exceptions. One such case is this snippet, which skipped the sections "a" and "b", when compiled against `libcxxrt` from master
@@ -160,19 +129,3 @@ TEST_CASE("b") {
 ```
 
 If you are seeing a problem like this, i.e. a weird test paths that trigger only under Clang with `libc++`, or only under very specific version of `libstdc++`, it is very likely you are seeing this. The only known workaround is to use a fixed version of your standard library.
-
-### Clang/G++ -- `Matches` string matcher always returns false
-This is a bug in `libstdc++-4.8`, where all matching methods from `<regex>` return false. Since `Matches` uses `<regex>` internally, if the underlying implementation does not work, it doesn't work either.
-
-Workaround: Use newer version of `libstdc++`.
-
-
-### libstdc++, `_GLIBCXX_DEBUG` macro and random ordering of tests
-
-Running a Catch2 binary compiled against libstdc++ with `_GLIBCXX_DEBUG`
-macro defined with `--order rand` will cause a debug check to trigger and
-abort the run due to self-assignment.
-[This is a known bug inside libstdc++](https://stackoverflow.com/questions/22915325/avoiding-self-assignment-in-stdshuffle/23691322)
-
-Workaround: Don't use `--order rand` when compiling against debug-enabled
-libstdc++.

docs/list-of-examples.md

@@ -1,48 +0,0 @@
-<a id="top"></a>
-# List of examples
-
-## Already available
-
-- Catch main: [Catch-provided main](../examples/000-CatchMain.cpp)
-- Test Case: [Single-file](../examples/010-TestCase.cpp)
-- Test Case: [Multiple-file 1](../examples/020-TestCase-1.cpp), [2](../examples/020-TestCase-2.cpp)
-- Assertion: [REQUIRE, CHECK](../examples/030-Asn-Require-Check.cpp)
-- Fixture: [Sections](../examples/100-Fix-Section.cpp)
-- Fixture: [Class-based fixtures](../examples/110-Fix-ClassFixture.cpp)
-- BDD: [SCENARIO, GIVEN, WHEN, THEN](../examples/120-Bdd-ScenarioGivenWhenThen.cpp)
-- Report: [Catch-provided main](../examples/200-Rpt-CatchMain.cpp)
-- Report: [TeamCity reporter](../examples/207-Rpt-TeamCityReporter.cpp)
-- Listener: [Listeners](../examples/210-Evt-EventListeners.cpp)
-- Configuration: [Provide your own output streams](../examples/231-Cfg-OutputStreams.cpp)
-- Generators: [Create your own generator](../examples/300-Gen-OwnGenerator.cpp)
-- Generators: [Use map to convert types in GENERATE expression](../examples/301-Gen-MapTypeConversion.cpp)
-- Generators: [Use variables in generator expressions](../examples/310-Gen-VariablesInGenerators.cpp)
-- Generators: [Use custom variable capture in generator expressions](../examples/311-Gen-CustomCapture.cpp)
-
-
-## Planned
-
-- Assertion: [REQUIRE_THAT and Matchers](../examples/040-Asn-RequireThat.cpp)
-- Assertion: [REQUIRE_NO_THROW](../examples/050-Asn-RequireNoThrow.cpp)
-- Assertion: [REQUIRE_THROWS](../examples/050-Asn-RequireThrows.cpp)
-- Assertion: [REQUIRE_THROWS_AS](../examples/070-Asn-RequireThrowsAs.cpp)
-- Assertion: [REQUIRE_THROWS_WITH](../examples/080-Asn-RequireThrowsWith.cpp)
-- Assertion: [REQUIRE_THROWS_MATCHES](../examples/090-Asn-RequireThrowsMatches.cpp)
-- Floating point: [Approx - Comparisons](../examples/130-Fpt-Approx.cpp)
-- Logging: [CAPTURE - Capture expression](../examples/140-Log-Capture.cpp)
-- Logging: [INFO - Provide information with failure](../examples/150-Log-Info.cpp)
-- Logging: [WARN - Issue warning](../examples/160-Log-Warn.cpp)
-- Logging: [FAIL, FAIL_CHECK - Issue message and force failure/continue](../examples/170-Log-Fail.cpp)
-- Logging: [SUCCEED - Issue message and continue](../examples/180-Log-Succeed.cpp)
-- Report: [User-defined type](../examples/190-Rpt-ReportUserDefinedType.cpp)
-- Report: [User-defined reporter](../examples/202-Rpt-UserDefinedReporter.cpp)
-- Report: [Automake reporter](../examples/205-Rpt-AutomakeReporter.cpp)
-- Report: [TAP reporter](../examples/206-Rpt-TapReporter.cpp)
-- Report: [Multiple reporter](../examples/208-Rpt-MultipleReporters.cpp)
-- Configuration: [Provide your own main()](../examples/220-Cfg-OwnMain.cpp)
-- Configuration: [Compile-time configuration](../examples/230-Cfg-CompileTimeConfiguration.cpp)
-- Configuration: [Run-time configuration](../examples/240-Cfg-RunTimeConfiguration.cpp)
-
----
-
-[Home](Readme.md#top)

docs/logging.md

@@ -1,7 +1,6 @@
-<a id="top"></a>
 # Logging macros
 
-Additional messages can be logged during a test case. Note that the messages logged with `INFO` are scoped and thus will not be reported if failure occurs in scope preceding the message declaration. An example:
+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:
 
 ```cpp
 TEST_CASE("Foo") {
@@ -28,64 +27,10 @@ The number is 1
 ```
 When the last `CHECK` fails in the "Bar" test case, then only one message will be printed: `Test case start`.
 
-## Logging without local scope
-
-`UNSCOPED_INFO` is similar to `INFO` with two key differences:
-
-- Lifetime of an unscoped message is not tied to its own scope.
-- An unscoped message can be reported by the first following assertion only, regardless of the result of that assertion.
-
-In other words, lifetime of `UNSCOPED_INFO` is limited by the following assertion (or by the end of test case/section, whichever comes first) whereas lifetime of `INFO` is limited by its own scope.
-
-These differences make this macro useful for reporting information from helper functions or inner scopes. An example:
-
-```cpp
-void print_some_info() {
-    UNSCOPED_INFO("Info from helper");
-}
-
-TEST_CASE("Baz") {
-    print_some_info();
-    for (int i = 0; i < 2; ++i) {
-        UNSCOPED_INFO("The number is " << i);
-    }
-    CHECK(false);
-}
-
-TEST_CASE("Qux") {
-    INFO("First info");
-    UNSCOPED_INFO("First unscoped info");
-    CHECK(false);
-
-    INFO("Second info");
-    UNSCOPED_INFO("Second unscoped info");
-    CHECK(false);
-}
-```
-
-"Baz" test case prints:
-```
-Info from helper
-The number is 0
-The number is 1
-```
-
-With "Qux" test case, two messages will be printed when the first `CHECK` fails:
-```
-First info
-First unscoped info
-```
-
-"First unscoped info" message will be cleared after the first `CHECK`, while "First info" message will persist until the end of the test case. Therefore, when the second `CHECK` fails, three messages will be printed:
-```
-First info
-Second info
-Second unscoped info
-```
 
 ## Streaming macros
 
-All these macros allow heterogeneous sequences of values to be streaming using the insertion operator (```<<```) in the same way that std::ostream, std::cout, etc support it.
+All these macros allow heterogenous sequences of values to be streaming using the insertion operator (```<<```) in the same way that std::ostream, std::cout, etc support it.
 
 E.g.:
 ```c++
@@ -97,14 +42,7 @@ These macros come in three forms:
 
 **INFO(** _message expression_ **)**
 
-The message is logged to a buffer, but only reported with next assertions that are logged. This allows you to log contextual information in case of failures which is not shown during a successful test run (for the console reporter, without -s). Messages are removed from the buffer at the end of their scope, so may be used, for example, in loops.
-
-_Note that in Catch2 2.x.x `INFO` can be used without a trailing semicolon as there is a trailing semicolon inside macro.
-This semicolon will be removed with next major version. It is highly advised to use a trailing semicolon after `INFO` macro._
-
-**UNSCOPED_INFO(** _message expression_ **)**
-
-Similar to `INFO`, but messages are not limited to their own scope: They are removed from the buffer after each assertion, section or test case, whichever comes first.
+The message is logged to a buffer, but only reported with the next assertion that is logged. This allows you to log contextual information in case of failures which is not shown during a successful test run (for the console reporter, without -s). Messages are removed from the buffer at the end of their scope, so may be used, for example, in loops.
 
 **WARN(** _message expression_ **)**
 
@@ -118,38 +56,27 @@ The message is reported and the test case fails.
 
 AS `FAIL`, but does not abort the test
 
-## Quickly capture value of variables or expressions
+## Quickly capture a variable value
 
-**CAPTURE(** _expression1_, _expression2_, ... **)**
+**CAPTURE(** _expression_ **)**
 
-Sometimes you just want to log a value of variable, or expression. For
-convenience, we provide the `CAPTURE` macro, that can take a variable,
-or an expression, and prints out that variable/expression and its value
-at the time of capture.
+Sometimes you just want to log the name and value of a variable. While you can easily do this with the INFO macro, above, as a convenience the CAPTURE macro handles the stringising of the variable name for you (actually it works with any expression, not just variables).
 
-e.g. `CAPTURE( theAnswer );` will log message "theAnswer := 42", while
-```cpp
-int a = 1, b = 2, c = 3;
-CAPTURE( a, b, c, a + b, c > b, a == 1);
-```
-will log a total of 6 messages:
-```
-a := 1
-b := 2
-c := 3
-a + b := 3
-c > b := true
-a == 1 := true
+E.g.
+```c++
+CAPTURE( theAnswer );
 ```
 
-You can also capture expressions that use commas inside parentheses
-(e.g. function calls), brackets, or braces (e.g. initializers). To
-properly capture expression that contains template parameters list
-(in other words, it contains commas between angle brackets), you need
-to enclose the expression inside parentheses:
-`CAPTURE( (std::pair<int, int>{1, 2}) );`
+This would log something like:
 
+<pre>"theAnswer := 42"</pre>
+
+## Deprecated macros
+
+**SCOPED_INFO and SCOPED_CAPTURE**
+
+These macros are now deprecated and are just aliases for INFO and CAPTURE (which were not previously scoped).
 
 ---
 
-[Home](Readme.md#top)
+[Home](Readme.md)

docs/matchers.md

@@ -1,4 +1,3 @@
-<a id="top"></a>
 # Matchers
 
 Matchers are an alternative way to do assertions which are easily extensible and composable.
@@ -36,41 +35,10 @@ REQUIRE_THAT( str,
 ```
 
 ## Built in matchers
-Catch currently provides some matchers, they are in the `Catch::Matchers` and `Catch` namespaces.
-
-### String matchers
-The string matchers are `StartsWith`, `EndsWith`, `Contains`, `Equals` and `Matches`. The first four match a literal (sub)string against a result, while `Matches` takes and matches an ECMAScript regex. Do note that `Matches` matches the string as a whole, meaning that "abc" will not match against "abcd", but "abc.*" will.
-
-Each of the provided `std::string` matchers also takes an optional second argument, that decides case sensitivity (by-default, they are case sensitive).
-
-
-### Vector matchers
+Currently Catch has some string matchers and some vector matchers. They are in the `Catch::Matchers` and `Catch` namespaces.
+The string matchers are `StartsWith`, `EndsWith`, `Contains` and `Equals`. Each of them also takes an optional second argument, that decides case sensitivity (by-default, they are case sensitive).
 The vector matchers are `Contains`, `VectorContains` and `Equals`. `VectorContains` looks for a single element in the matched vector, `Contains` looks for a set (vector) of elements inside the matched vector.
 
-### Floating point matchers
-The floating point matchers are `WithinULP` and `WithinAbs`. `WithinAbs` accepts floating point numbers that are within a certain margin of target. `WithinULP` performs an [ULP](https://en.wikipedia.org/wiki/Unit_in_the_last_place)-based comparison of two floating point numbers and accepts them if they are less than certain number of ULPs apart.
-
-Do note that ULP-based checks only make sense when both compared numbers are of the same type and `WithinULP` will use type of its argument as the target type. This means that `WithinULP(1.f, 1)` will expect to compare `float`s, but `WithinULP(1., 1)` will expect to compare `double`s.
-
-
-### Generic matchers
-Catch also aims to provide a set of generic matchers. Currently this set
-contains only a matcher that takes arbitrary callable predicate and applies
-it onto the provided object.
-
-Because of type inference limitations, the argument type of the predicate
-has to be provided explicitly. Example:
-```cpp
-REQUIRE_THAT("Hello olleH",
-             Predicate<std::string>(
-                 [] (std::string const& str) -> bool { return str.front() == str.back(); },
-                 "First and last character should be equal")
-);
-```
-
-The second argument is an optional description of the predicate, and is
-used only during reporting of the result.
-
 
 ## Custom matchers
 It's easy to provide your own matchers to extend Catch or just to work with your own types.
@@ -92,7 +60,7 @@ public:
     IntRange( int begin, int end ) : m_begin( begin ), m_end( end ) {}
 
     // Performs the test for this matcher
-    bool match( int const& i ) const override {
+    virtual bool match( int const& i ) const override {
         return i >= m_begin && i <= m_end;
     }
 
@@ -100,7 +68,7 @@ public:
     // include any provided data (the begin/ end in this case) and
     // be written as if it were stating a fact (in the output it will be
     // preceded by the value under test).
-    virtual std::string describe() const override {
+    virtual std::string describe() const {
         std::ostringstream ss;
         ss << "is between " << m_begin << " and " << m_end;
         return ss.str();
@@ -133,4 +101,4 @@ with expansion:
 
 ---
 
-[Home](Readme.md#top)
+[Home](Readme.md)

docs/opensource-users.md

@@ -1,63 +1,41 @@
-<a id="top"></a>
 # Open Source projects using Catch
 
-Catch is great for open source. With its [liberal license](../LICENSE.txt) and single-header, dependency-free, distribution
+Catch is great for open source. With its [liberal license](../LICENSE.txt) and single-header, dependency-free, distribution 
 it's easy to just drop the header into your project and start writing tests - what's not to like?
 
 As a result Catch is now being used in many Open Source projects, including some quite well known ones.
 This page is an attempt to track those projects. Obviously it can never be complete.
 This effort largely relies on the maintainers of the projects themselves updating this page and submitting a PR
-(or, if you prefer contact one of the maintainers of Catch directly, use the
+(or, if you prefer contact one of the maintainers of Catch directly, use the 
 [forums](https://groups.google.com/forum/?fromgroups#!forum/catch-forum)), or raise an [issue](https://github.com/philsquared/Catch/issues) to let us know).
 Of course users of those projects might want to update this page too. That's fine - as long you're confident the project maintainers won't mind.
-If you're an Open Source project maintainer and see your project listed here but would rather it wasn't -
+If you're an Open Source project maintainer and see your project listed here but would rather it wasn't - 
 just let us know via any of the previously mentioned means - although I'm sure there won't be many who feel that way.
-
+ 
 Listing a project here does not imply endorsement and the plan is to keep these ordered alphabetically to avoid an implication of relative importance.
 
 ## Libraries & Frameworks
 
-### [ApprovalTests.cpp](https://github.com/approvals/ApprovalTests.cpp)
-C++11 implementation of Approval Tests, for quick, convenient testing of legacy code.
-
 ### [Azmq](https://github.com/zeromq/azmq)
-Boost Asio style bindings for ZeroMQ.
+Boost Asio style bindings for ZeroMQ
 
 ### [ChakraCore](https://github.com/Microsoft/ChakraCore)
-The core part of the Chakra JavaScript engine that powers Microsoft Edge.
+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.
+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.
-
-### [cppcodec](https://github.com/tplgy/cppcodec)
-Header-only C++11 library to encode/decode base64, base64url, base32, base32hex and hex (a.k.a. base16) as specified in RFC 4648, plus Crockford's base32.
-
-### [DtCraft](https://github.com/twhuang-uiuc/DtCraft)
-A High-performance Cluster Computing Engine.
-
-### [forest](https://github.com/xorz57/forest)
-Template Library of Tree Data Structures.
-
-### [Fuxedo](https://github.com/fuxedo/fuxedo)
-Open source Oracle Tuxedo-like XATMI middleware for C and C++.
-
-### [Inja](https://github.com/pantor/inja)
-A header-only template engine for modern C++.
+The next-generation core storage and query engine for Couchbase Lite/
 
 ### [JSON for Modern C++](https://github.com/nlohmann/json)
 A, single-header, JSON parsing library that takes advantage of what C++ has to offer.
 
-### [libcluon](https://github.com/chrberger/libcluon)
-A single-header-only library written in C++14 to glue distributed software components (UDP, TCP, shared memory) supporting natively Protobuf, LCM/ZCM, MsgPack, and JSON for dynamic message transformations in-between. 
-
 ### [MNMLSTC Core](https://github.com/mnmlstc/core)
-A small and easy to use C++11 library that adds a functionality set that will be available in C++14 and later, as well as some useful additions.
+a small and easy to use C++11 library that adds a functionality set that will be available in C++14 and later, as well as some useful additions
 
 ### [nanodbc](https://github.com/lexicalunit/nanodbc/)
 A small C++ library wrapper for the native C ODBC API.
@@ -66,25 +44,22 @@ A small C++ library wrapper for the native C ODBC API.
 A header-only framework for benchmarking small snippets of C++ code.
 
 ### [SOCI](https://github.com/SOCI/soci)
-The C++ Database Access Library.
+The C++ Database Access Library
 
 ### [polymorphic_value](https://github.com/jbcoe/polymorphic_value)
-A polymorphic value-type for C++.
+A polymorphic value-type for C++
 
 ### [Ppconsul](https://github.com/oliora/ppconsul)
-A C++ client library for Consul. Consul is a distributed tool for discovering and configuring services in your infrastructure.
+A C++ client library for Consul. Consul is a distributed tool for discovering and configuring services in your infrastructure
 
 ### [Reactive-Extensions/ RxCpp](https://github.com/Reactive-Extensions/RxCpp)
-A library of algorithms for values-distributed-in-time.
-
-### [thor](https://github.com/xorz57/thor)
-Wrapper Library for CUDA.
+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.
+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.
+A thread safe header only mocking framework for C++14
 
 ### [args](https://github.com/Taywee/args)
 A simple header-only C++ argument parser library.
@@ -98,20 +73,14 @@ ArangoDB is a native multi-model database with flexible data models for document
 Minimal, open-source and cross-platform audio tool for live music production.
 
 ### [MAME](https://github.com/mamedev/mame)
-MAME originally stood for Multiple Arcade Machine Emulator.
+MAME originally stood for Multiple Arcade Machine Emulator
 
 ### [Newsbeuter](https://github.com/akrennmair/newsbeuter)
 Newsbeuter is an open-source RSS/Atom feed reader for text terminals.
 
-### [raspigcd](https://github.com/pantadeusz/raspigcd)
-Low level CLI app and library for execution of GCODE on Raspberry Pi without any additional microcontrolers (just RPi + Stepsticks).
-
-### [SpECTRE](https://github.com/sxs-collaboration/spectre)
-SpECTRE is a code for multi-scale, multi-physics problems in astrophysics and gravitational physics.
-
 ### [Standardese](https://github.com/foonathan/standardese)
-Standardese aims to be a nextgen Doxygen.
+Standardese aims to be a nextgen Doxygen
 
 ---
 
-[Home](Readme.md#top)
+[Home](Readme.md)

docs/other-macros.md

@@ -1,150 +0,0 @@
-<a id="top"></a>
-# Other macros
-
-This page serves as a reference for macros that are not documented
-elsewhere. For now, these macros are separated into 2 rough categories,
-"assertion related macros" and "test case related macros".
-
-## Assertion related macros
-
-* `CHECKED_IF` and `CHECKED_ELSE`
-
-`CHECKED_IF( expr )` is an `if` replacement, that also applies Catch2's
-stringification machinery to the _expr_ and records the result. As with
-`if`, the block after a `CHECKED_IF` is entered only if the expression
-evaluates to `true`. `CHECKED_ELSE( expr )` work similarly, but the block
-is entered only if the _expr_ evaluated to `false`.
-
-Example:
-```cpp
-int a = ...;
-int b = ...;
-CHECKED_IF( a == b ) {
-    // This block is entered when a == b
-} CHECKED_ELSE ( a == b ) {
-    // This block is entered when a != b
-}
-```
-
-* `CHECK_NOFAIL`
-
-`CHECK_NOFAIL( expr )` is a variant of `CHECK` that does not fail the test
-case if _expr_ evaluates to `false`. This can be useful for checking some
-assumption, that might be violated without the test necessarily failing.
-
-Example output:
-```
-main.cpp:6:
-FAILED - but was ok:
-  CHECK_NOFAIL( 1 == 2 )
-
-main.cpp:7:
-PASSED:
-  CHECK( 2 == 2 )
-```
-
-* `SUCCEED`
-
-`SUCCEED( msg )` is mostly equivalent with `INFO( msg ); REQUIRE( true );`.
-In other words, `SUCCEED` is for cases where just reaching a certain line
-means that the test has been a success.
-
-Example usage:
-```cpp
-TEST_CASE( "SUCCEED showcase" ) {
-    int I = 1;
-    SUCCEED( "I is " << I );
-}
-```
-
-* `STATIC_REQUIRE`
-
-`STATIC_REQUIRE( expr )` is a macro that can be used the same way as a
-`static_assert`, but also registers the success with Catch2, so it is
-reported as a success at runtime. The whole check can also be deferred
-to the runtime, by defining `CATCH_CONFIG_RUNTIME_STATIC_REQUIRE` before
-including the Catch2 header.
-
-Example:
-```cpp
-TEST_CASE("STATIC_REQUIRE showcase", "[traits]") {
-    STATIC_REQUIRE( std::is_void<void>::value );
-    STATIC_REQUIRE_FALSE( std::is_void<int>::value );
-}
-```
-
-## Test case related macros
-
-* `METHOD_AS_TEST_CASE`
-
-`METHOD_AS_TEST_CASE( member-function-pointer, description )` lets you
-register a member function of a class as a Catch2 test case. The class
-will be separately instantiated for each method registered in this way.
-
-```cpp
-class TestClass {
-    std::string s;
-
-public:
-    TestClass()
-        :s( "hello" )
-    {}
-
-    void testCase() {
-        REQUIRE( s == "hello" );
-    }
-};
-
-
-METHOD_AS_TEST_CASE( TestClass::testCase, "Use class's method as a test case", "[class]" )
-```
-
-* `REGISTER_TEST_CASE`
-
-`REGISTER_TEST_CASE( function, description )` let's you register
-a `function` as a test case. The function has to have `void()` signature,
-the description can contain both name and tags.
-
-Example:
-```cpp
-REGISTER_TEST_CASE( someFunction, "ManuallyRegistered", "[tags]" );
-```
-
-_Note that the registration still has to happen before Catch2's session
-is initiated. This means that it either needs to be done in a global
-constructor, or before Catch2's session is created in user's own main._
-
-
-* `ANON_TEST_CASE`
-
-`ANON_TEST_CASE` is a `TEST_CASE` replacement that will autogenerate
-unique name. The advantage of this is that you do not have to think
-of a name for the test case,`the disadvantage is that the name doesn't
-necessarily remain stable across different links, and thus it might be
-hard to run directly.
-
-Example:
-```cpp
-ANON_TEST_CASE() {
-    SUCCEED("Hello from anonymous test case");
-}
-```
-
-* `DYNAMIC_SECTION`
-
-`DYNAMIC_SECTION` is a `SECTION` where the user can use `operator<<` to
-create the final name for that section. This can be useful with e.g.
-generators, or when creating a `SECTION` dynamically, within a loop.
-
-Example:
-```cpp
-TEST_CASE( "looped SECTION tests" ) {
-    int a = 1;
-
-    for( int b = 0; b < 10; ++b ) {
-        DYNAMIC_SECTION( "b is currently: " << b ) {
-            CHECK( b > a );
-        }
-    }
-}
-```

docs/own-main.md

@@ -1,12 +1,5 @@
-<a id="top"></a>
 # Supplying main() yourself
 
-**Contents**<br>
-[Let Catch take full control of args and config](#let-catch-take-full-control-of-args-and-config)<br>
-[Amending the config](#amending-the-config)<br>
-[Adding your own command line options](#adding-your-own-command-line-options)<br>
-[Version detection](#version-detection)<br>
-
 The easiest way to use Catch is to let it supply ```main()``` for you and handle configuring itself from the command line.
 
 This is achieved by writing ```#define CATCH_CONFIG_MAIN``` before the ```#include "catch.hpp"``` in *exactly one* source file.
@@ -23,20 +16,21 @@ If you just need to have code that executes before and/ or after Catch this is t
 #define CATCH_CONFIG_RUNNER
 #include "catch.hpp"
 
-int main( int argc, char* argv[] ) {
+int main( int argc, char* argv[] )
+{
   // global setup...
 
   int result = Catch::Session().run( argc, argv );
 
   // global clean-up...
 
-  return result;
+  return ( result < 0xff ? result : 0xff );
 }
 ```
 
 ## Amending the config
 
-If you still want Catch to process the command line, but you want to programmatically tweak the config, you can do so in one of two ways:
+If you still want Catch to process the command line, but you want to programatically tweak the config, you can do so in one of two ways:
 
 ```c++
 #define CATCH_CONFIG_RUNNER
@@ -45,24 +39,23 @@ If you still want Catch to process the command line, but you want to programmati
 int main( int argc, char* argv[] )
 {
   Catch::Session session; // There must be exactly one instance
- 
+
   // writing to session.configData() here sets defaults
   // this is the preferred way to set them
-    
+
   int returnCode = session.applyCommandLine( argc, argv );
   if( returnCode != 0 ) // Indicates a command line error
-        return returnCode;
- 
+  	return returnCode;
+
   // writing to session.configData() or session.Config() here 
   // overrides command line args
   // only do this if you know you need to
 
   int numFailed = session.run();
-  
-  // numFailed is clamped to 255 as some unices only use the lower 8 bits.
-  // This clamping has already been applied, so just return it here
-  // You can also do any post run clean-up here
-  return numFailed;
+  // Note that on unices only the lower 8 bits are usually used, clamping
+  // the return value to 255 prevents false negative when some multiple
+  // of 256 tests has failed
+  return ( numFailed < 0xff ? numFailed : 0xff );
 }
 ```
 
@@ -72,60 +65,8 @@ To take full control of the config simply omit the call to ```applyCommandLine()
 
 ## Adding your own command line options
 
-Catch embeds a powerful command line parser called [Clara](https://github.com/philsquared/Clara). 
-As of Catch2 (and Clara 1.0) Clara allows you to write _composable_ option and argument parsers, 
-so extending Catch's own command line options is now easy.
-
-```c++
-#define CATCH_CONFIG_RUNNER
-#include "catch.hpp"
-
-int main( int argc, char* argv[] )
-{
-  Catch::Session session; // There must be exactly one instance
-  
-  int height = 0; // Some user variable you want to be able to set
-  
-  // Build a new parser on top of Catch's
-  using namespace Catch::clara;
-  auto cli 
-    = session.cli() // Get Catch's composite command line parser
-    | Opt( height, "height" ) // bind variable to a new option, with a hint string
-        ["-g"]["--height"]    // the option names it will respond to
-        ("how high?");        // description string for the help output
-        
-  // Now pass the new composite back to Catch so it uses that
-  session.cli( cli ); 
-  
-  // Let Catch (using Clara) parse the command line
-  int returnCode = session.applyCommandLine( argc, argv );
-  if( returnCode != 0 ) // Indicates a command line error
-      return returnCode;
-
-  // if set on the command line then 'height' is now set at this point
-  if( height > 0 )
-      std::cout << "height: " << height << std::endl;
-
-  return session.run();
-}
-```
-
-See the [Clara documentation](https://github.com/philsquared/Clara/blob/master/README.md) for more details.
-
-
-## Version detection
-
-Catch provides a triplet of macros providing the header's version, 
-
-* `CATCH_VERSION_MAJOR`
-* `CATCH_VERSION_MINOR`
-* `CATCH_VERSION_PATCH`
-
-these macros expand into a single number, that corresponds to the appropriate
-part of the version. As an example, given single header version v2.3.4,
-the macros would expand into `2`, `3`, and `4` respectively.
-
+Catch embeds a powerful command line parser which you can also use to parse your own options out. This capability is still in active development but will be documented here when it is ready.
 
 ---
 
-[Home](Readme.md#top)
+[Home](Readme.md)

docs/release-notes.md

@@ -1,557 +1,14 @@
-<a id="top"></a>
-
-# Release notes
-**Contents**<br>
-[2.7.2](#272)<br>
-[2.7.1](#271)<br>
-[2.7.0](#270)<br>
-[2.6.1](#261)<br>
-[2.6.0](#260)<br>
-[2.5.0](#250)<br>
-[2.4.2](#242)<br>
-[2.4.1](#241)<br>
-[2.4.0](#240)<br>
-[2.3.0](#230)<br>
-[2.2.3](#223)<br>
-[2.2.2](#222)<br>
-[2.2.1](#221)<br>
-[2.2.0](#220)<br>
-[2.1.2](#212)<br>
-[2.1.1](#211)<br>
-[2.1.0](#210)<br>
-[2.0.1](#201)<br>
-[Older versions](#older-versions)<br>
-[Even Older versions](#even-older-versions)<br>
-
-
-## 2.7.2
-
-### Improvements
-* Added an approximate vector matcher (#1499)
+# 1.12.0
 
 ### Fixes
-* Filters will no longer be shown if there were none
-* Fixed compilation error when using Homebrew GCC on OS X (#1588, #1589)
-* Fixed the console reporter not showing messages that start with a newline (#1455, #1470)
-* Modified JUnit reporter's output so that rng seed and filters are reported according to the JUnit schema (#1598)
-* Fixed some obscure warnings and static analysis passes
-
-### Miscellaneous
-* Various improvements to `ParseAndAddCatchTests` (#1559, #1601)
-  * When a target is parsed, it receives `ParseAndAddCatchTests_TESTS` property which summarizes found tests
-  * Fixed problem with tests not being found if the `OptionalCatchTestLauncher` variables is used
-  * Including the script will no longer forcefully modify `CMAKE_MINIMUM_REQUIRED_VERSION`
-  * CMake object libraries are ignored when parsing to avoid needless warnings
-* `CatchAddTests` now adds test's tags to their CTest labels (#1600)
-* Added basic CPack support to our build
-
-## 2.7.1
-
-### Improvements
-* Reporters now print out the filters applied to test cases (#1550, #1585)
-* Added `GENERATE_COPY` and `GENERATE_VAR` macros that can use variables inside the generator expression
-  * Because of the significant danger of lifetime issues, the default `GENERATE` macro still does not allow variables
-* The `map` generator helper now deduces the mapped return type (#1576)
-
-### Fixes
-* Fixed ObjC++ compilation (#1571)
-* Fixed test tag parsing so that `[.foo]` is now parsed as `[.][foo]`.
-* Suppressed warning caused by the Windows headers defining SE codes in different manners (#1575)
-
-## 2.7.0
-
-### Improvements
-* `TEMPLATE_PRODUCT_TEST_CASE` now uses the resulting type in the name, instead of the serial number (#1544)
-* Catch2's single header is now strictly ASCII (#1542)
-* Added generator for random integral/floating point types
-  * The types are inferred within the `random` helper
-* Added back RangeGenerator (#1526)
-  * RangeGenerator returns elements within a certain range
-* Added ChunkGenerator generic transform (#1538)
-  * A ChunkGenerator returns the elements from different generator in chunks of n elements
-* Added `UNSCOPED_INFO` (#415, #983, #1522)
-  * This is a variant of `INFO` that lives until next assertion/end of the test case.
-
-
-### Fixes
-* All calls to C stdlib functions are now `std::` qualified (#1541)
-  * Code brought in from Clara was also updated.
-* Running tests will no longer open the specified output file twice (#1545)
-  * This would cause trouble when the file was not a file, but rather a named pipe
-  * Fixes the CLion/Resharper integration with Catch
-* Fixed `-Wunreachable-code` occurring with (old) ccache+cmake+clang combination (#1540)
-* Fixed `-Wdefaulted-function-deleted` warning with Clang 8 (#1537)
-* Catch2's type traits and helpers are now properly namespaced inside `Catch::` (#1548)
-* Fixed std{out,err} redirection for failing test (#1514, #1525)
-  * Somehow, this bug has been present for well over a year before it was reported
-
-
-### Contrib
-* `ParseAndAddCatchTests` now properly escapes commas in the test name
-
-
-
-## 2.6.1
-
-### Improvements
-* The JUnit reporter now also reports random seed (#1520, #1521)
-
-### Fixes
-* The TAP reporter now formats comments with test name properly (#1529)
-* `CATCH_REQUIRE_THROWS`'s internals were unified with `REQUIRE_THROWS` (#1536)
-  * This fixes a potential `-Wunused-value` warning when used
-* Fixed a potential segfault when using any of the `--list-*` options (#1533, #1534)
-
-
-## 2.6.0
-
-**With this release the data generator feature is now fully supported.**
-
-
-### Improvements
-* Added `TEMPLATE_PRODUCT_TEST_CASE` (#1454, #1468)
-  * This allows you to easily test various type combinations, see documentation for details
-* The error message for `&&` and `||` inside assertions has been improved (#1273, #1480)
-* The error message for chained comparisons inside assertions has been improved (#1481)
-* Added `StringMaker` specialization for `std::optional` (#1510)
-* The generator interface has been redone once again (#1516)
-  * It is no longer considered experimental and is fully supported
-  * The new interface supports "Input" generators
-  * The generator documentation has been fully updated
-  * We also added 2 generator examples
-
-
-### Fixes
-* Fixed `-Wredundant-move` on newer Clang (#1474)
-* Removed unreachable mentions `std::current_exception`, `std::rethrow_exception` in no-exceptions mode (#1462)
-  * This should fix compilation with IAR
-* Fixed missing `<type_traits>` include (#1494)
-* Fixed various static analysis warnings
-  * Unrestored stream state in `XmlWriter` (#1489)
-  * Potential division by zero in `estimateClockResolution` (#1490)
-  * Uninitialized member in `RunContext` (#1491)
-  * `SourceLineInfo` move ops are now marked `noexcept`
-  * `CATCH_BREAK_INTO_DEBUGGER` is now always a function
-* Fix double run of a test case if user asks for a specific section (#1394, #1492)
-* ANSI colour code output now respects `-o` flag and writes to the file as well (#1502)
-* Fixed detection of `std::variant` support for compilers other than Clang (#1511)
-
-
-### Contrib
-* `ParseAndAddCatchTests` has learned how to use `DISABLED` CTest property (#1452)
-* `ParseAndAddCatchTests` now works when there is a whitspace before the test name (#1493)
-
-
-### Miscellaneous
-* We added new issue templates for reporting issues on GitHub
-* `contributing.md` has been updated to reflect the current test status (#1484)
-
-
-
-## 2.5.0
-
-### Improvements
-* Added support for templated tests via `TEMPLATE_TEST_CASE` (#1437)
-
-
-### Fixes
-* Fixed compilation of `PredicateMatcher<const char*>` by removing partial specialization of `MatcherMethod<T*>`
-* Listeners now implicitly support any verbosity (#1426)
-* Fixed compilation with Embarcadero builder by introducing `Catch::isnan` polyfill (#1438)
-* Fixed `CAPTURE` asserting for non-trivial captures (#1436, #1448)
-
-
-### Miscellaneous
-* We should now be providing first party Conan support via https://bintray.com/catchorg/Catch2 (#1443)
-* Added new section "deprecations and planned changes" to the documentation
-  * It contains summary of what is deprecated and might change with next major version
-* From this release forward, the released headers should be pgp signed (#430)
-  * KeyID `E29C 46F3 B8A7 5028 6079 3B7D ECC9 C20E 314B 2360`
-  * or https://codingnest.com/files/horenmar-publickey.asc
-
-
-## 2.4.2
-
-### Improvements
-* XmlReporter now also outputs the RNG seed that was used in a run (#1404)
-* `Catch::Session::applyCommandLine` now also accepts `wchar_t` arguments.
-  * However, Catch2 still does not support unicode.
-* Added `STATIC_REQUIRE` macro (#1356, #1362)
-* Catch2's singleton's are now cleaned up even if tests are run (#1411)
-  * This is mostly useful as a FP prevention for users who define their own main.
-* Specifying an invalid reporter via `-r` is now reported sooner (#1351, #1422)
-
-
-### Fixes
-* Stringification no longer assumes that `char` is signed (#1399, #1407)
-  * This caused a `Wtautological-compare` warning.
-* SFINAE for `operator<<` no longer sees different overload set than the actual insertion (#1403)
-
-
-### Contrib
-* `catch_discover_tests` correctly adds tests with comma in name (#1327, #1409)
-* Added a new customization point in how the tests are launched to `catch_discover_tests`
-
-
-## 2.4.1
-
-### Improvements
-* Added a StringMaker for `std::(w)string_view` (#1375, #1376)
-* Added a StringMaker for `std::variant` (#1380)
-  * This one is disabled by default to avoid increased compile-time drag
-* Added detection for cygwin environment without `std::to_string` (#1396, #1397)
-
-### Fixes
-* `UnorderedEqualsMatcher` will no longer accept erroneously accept
-vectors that share suffix, but are not permutation of the desired vector
-* Abort after (`-x N`) can no longer be overshot by nested `REQUIRES` and
-subsequently ignored (#1391, #1392)
-
-
-## 2.4.0
-
-**This release brings two new experimental features, generator support
-and a `-fno-exceptions` support. Being experimental means that they
-will not be subject to the usual stability guarantees provided by semver.**
-
-### Improvements
-* Various small runtime performance improvements
-* `CAPTURE` macro is now variadic
-* Added `AND_GIVEN` macro (#1360)
-* Added experimental support for data generators
-  * See [their documentation](generators.md) for details
-* Added support for compiling and running Catch without exceptions
-  * Doing so limits the functionality somewhat
-  * Look [into the documentation](configuration.md#disablingexceptions) for details
-
-### Fixes
-* Suppressed `-Wnon-virtual-dtor` warnings in Matchers (#1357)
-* Suppressed `-Wunreachable-code` warnings in floating point matchers (#1350)
-
-### CMake
-* It is now possible to override which Python is used to run Catch's tests (#1365)
-* Catch now provides infrastructure for adding tests that check compile-time configuration
-* Catch no longer tries to install itself when used as a subproject (#1373)
-* Catch2ConfigVersion.cmake is now generated as arch-independent (#1368)
-  * This means that installing Catch from 32-bit machine and copying it to 64-bit one works
-  * This fixes conan installation of Catch
-
-
-## 2.3.0
-
-**This release changes the include paths provided by our CMake and
-pkg-config integration. The proper include path for the single-header
-when using one of the above is now `<catch2/catch.hpp>`. This change
-also necessitated changes to paths inside the repository, so that the
-single-header version is now at `single_include/catch2/catch.hpp`, rather
-than `single_include/catch.hpp`.**
-
-
-
-### Fixes
-* Fixed Objective-C++ build
-* `-Wunused-variable` suppression no longer leaks from Catch's header under Clang
-* Implementation of the experimental new output capture can now be disabled (#1335)
-  * This allows building Catch2 on platforms that do not provide things like `dup` or `tmpfile`.
-* The JUnit and XML reporters will no longer skip over successful tests when running without `-s`  (#1264, #1267, #1310)
-  * See improvements for more details
-
-### Improvements
-* pkg-config and CMake integration has been rewritten
-  * If you use them, the new include path is `#include <catch2/catch.hpp>`
-  * CMake installation now also installs scripts from `contrib/`
-  * For details see the [new documentation](cmake-integration.md#top)
-* Reporters now have a new customization point, `ReporterPreferences::shouldReportAllAssertions`
-  * When this is set to `false` and the tests are run without `-s`, passing assertions are not sent to the reporter.
-  * Defaults to `false`.
-* Added `DYNAMIC_SECTION`, a section variant that constructs its name using stream
-  * This means that you can do `DYNAMIC_SECTION("For X := " << x)`.
-
-
-## 2.2.3
-
-**To fix some of the bugs, some behavior had to change in potentially breaking manner.**
-**This means that even though this is a patch release, it might not be a drop-in replacement.**
-
-### Fixes
-* Listeners are now called before reporter
-  * This was always documented to be the case, now it actually works that way
-* Catch's commandline will no longer accept multiple reporters
-  * This was done because multiple reporters never worked properly and broke things in non-obvious ways
-  * **This has potential to be a breaking change**
-* MinGW is now detected as Windows platform w/o SEH support (#1257)
-  * This means that Catch2 no longer tries to use POSIX signal handling when compiled with MinGW
-* Fixed potential UB in parsing tags using non-ASCII characters (#1266)
-  * Note that Catch2 still supports only ASCII test names/tags/etc
-* `TEST_CASE_METHOD` can now be used on classnames containing commas (#1245)
-  * You have to enclose the classname in extra set of parentheses
-* Fixed insufficient alt stack size for POSIX signal handling (#1225)
-* Fixed compilation error on Android due to missing `std::to_string` in C++11 mode (#1280)
-* Fixed the order of user-provided `FALLBACK_STRINGIFIER` in stringification machinery (#1024)
-  * It was intended to be replacement for built-in fallbacks, but it was used _after_ them.
-  * **This has potential to be a breaking change**
-* Fixed compilation error when a type has an `operator<<` with templated lhs (#1285, #1306)
-
-### Improvements
-* Added a new, experimental, output capture (#1243)
-  * This capture can also redirect output written via C apis, e.g. `printf`
-  * To opt-in, define `CATCH_CONFIG_EXPERIMENTAL_REDIRECT` in the implementation file
-* Added a new fallback stringifier for classes derived from `std::exception`
-  * Both `StringMaker` specialization and `operator<<` overload are given priority
-
-### Miscellaneous
-* `contrib/` now contains dbg scripts that skip over Catch's internals (#904, #1283)
-  * `gdbinit` for gdb `lldbinit` for lldb
-* `CatchAddTests.cmake` no longer strips whitespace from tests (#1265, #1281)
-* Online documentation now describes `--use-colour` option (#1263)
-
-
-## 2.2.2
-
-### Fixes
-* Fixed bug in `WithinAbs::match()` failing spuriously (#1228)
-* Fixed clang-tidy diagnostic about virtual call in destructor (#1226)
-* Reduced the number of GCC warnings suppression leaking out of the header (#1090, #1091)
-  * Only `-Wparentheses` should be leaking now
-* Added upper bound on the time benchmark timer calibration is allowed to take (#1237)
-  * On platforms where `std::chrono::high_resolution_clock`'s resolution is low, the calibration would appear stuck
-* Fixed compilation error when stringifying static arrays of `unsigned char`s (#1238)
-
-### Improvements
-* XML encoder now hex-encodes invalid UTF-8 sequences (#1207)
-  * This affects xml and junit reporters
-  * Some invalid UTF-8 parts are left as is, e.g. surrogate pairs. This is because certain extensions of UTF-8 allow them, such as WTF-8.
-* CLR objects (`T^`) can now be stringified (#1216)
-  * This affects code compiled as C++/CLI
-* Added `PredicateMatcher`, a matcher that takes an arbitrary predicate function (#1236)
-  * See [documentation for details](https://github.com/catchorg/Catch2/blob/master/docs/matchers.md)
-
-### Others
-* Modified CMake-installed pkg-config to allow `#include <catch.hpp>`(#1239)
-  * The plans to standardize on `#include <catch2/catch.hpp>` are still in effect
-
-
-## 2.2.1
-
-### Fixes
-* Fixed compilation error when compiling Catch2 with `std=c++17` against libc++ (#1214)
-  * Clara (Catch2's CLI parsing library) used `std::optional` without including it explicitly
-* Fixed Catch2 return code always being 0 (#1215)
-  * In the words of STL, "We feel superbad about letting this in"
-
-
-## 2.2.0
-
-### Fixes
-* Hidden tests are not listed by default when listing tests (#1175)
-  * This makes `catch_discover_tests` CMake script work better
-* Fixed regression that meant `<windows.h>` could potentially not be included properly (#1197)
-* Fixed installing `Catch2ConfigVersion.cmake` when Catch2 is a subproject.
-
-### Improvements
-* Added an option to warn (+ exit with error) when no tests were ran (#1158)
-  * Use as `-w NoTests`
-* Added provisional support for Emscripten (#1114)
-* [Added a way to override the fallback stringifier](https://github.com/catchorg/Catch2/blob/master/docs/configuration.md#fallback-stringifier) (#1024)
-  * This allows project's own stringification machinery to be easily reused for Catch
-* `Catch::Session::run()` now accepts `char const * const *`, allowing it to accept array of string literals (#1031, #1178)
-  * The embedded version of Clara was bumped to v1.1.3
-* Various minor performance improvements
-* Added support for DJGPP DOS crosscompiler (#1206)
-
-
-## 2.1.2
-
-### Fixes
-* Fixed compilation error with `-fno-rtti` (#1165)
-* Fixed NoAssertion warnings
-* `operator<<` is used before range-based stringification (#1172)
-* Fixed `-Wpedantic` warnings (extra semicolons and binary literals) (#1173)
-
-
-### Improvements
-* Added `CATCH_VERSION_{MAJOR,MINOR,PATCH}` macros (#1131)
-* Added `BrightYellow` colour for use in reporters (#979)
-  * It is also used by ConsoleReporter for reconstructed expressions
-
-### Other changes
-* Catch is now exported as a CMake package and linkable target (#1170)
-
-## 2.1.1
-
-### Improvements
-* Static arrays are now properly stringified like ranges across MSVC/GCC/Clang
-* Embedded newer version of Clara -- v1.1.1
-  * This should fix some warnings dragged in from Clara
-* MSVC's CLR exceptions are supported
-
-
-### Fixes
-* Fixed compilation when comparison operators do not return bool (#1147)
-* Fixed CLR exceptions blowing up the executable during translation (#1138)
-
-
-### Other changes
-* Many CMake changes
-  * `NO_SELFTEST` option is deprecated, use `BUILD_TESTING` instead.
-  * Catch specific CMake options were prefixed with `CATCH_` for namespacing purposes
-  * Other changes to simplify Catch2's packaging
-
-
-
-## 2.1.0
-
-### Improvements
-* Various performance improvements
-  * On top of the performance regression fixes
-* Experimental support for PCH was added (#1061)
-* `CATCH_CONFIG_EXTERNAL_INTERFACES` now brings in declarations of Console, Compact, XML and JUnit reporters
-* `MatcherBase` no longer has a pointless second template argument
-* Reduced the number of warning suppressions that leak into user's code
-  * Bugs in g++ 4.x and 5.x mean that some of them have to be left in
-
-
-### Fixes
-* Fixed performance regression from Catch classic
-  * One of the performance improvement patches for Catch classic was not applied to Catch2
-* Fixed platform detection for iOS (#1084)
-* Fixed compilation when `g++` is used together with `libc++` (#1110)
-* Fixed TeamCity reporter compilation with the single header version
-  * To fix the underlying issue we will be versioning reporters in single_include folder per release
-* The XML reporter will now report `WARN` messages even when not used with `-s`
-* Fixed compilation when `VectorContains` matcher was combined using `&&` (#1092)
-* Fixed test duration overflowing after 10 seconds (#1125, #1129)
-* Fixed `std::uncaught_exception` deprecation warning (#1124)
-
-
-### New features
-* New Matchers
-  * Regex matcher for strings, `Matches`.
-  * Set-equal matcher for vectors, `UnorderedEquals`
-  * Floating point matchers, `WithinAbs` and `WithinULP`.
-* Stringification now attempts to decompose all containers (#606)
-  * Containers are objects that respond to ADL `begin(T)` and `end(T)`.
-
-
-### Other changes
-* Reporters will now be versioned in the `single_include` folder to ensure their compatibility with the last released version
-
-
-
-
-## 2.0.1
-
-### 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
-* Removed support for non-const comparison operators
-  * Non-const comparison operators are an abomination that should not exist
-  * They were breaking support for comparing function to function pointer
-* `std::pair` and `std::tuple` are no longer stringified by default
-  * This is done to avoid dragging in `<tuple>` and `<utility>` headers in common path
-  * Their stringification can be enabled per-file via new configuration macros
-* `Approx` is subtly different and hopefully behaves more as users would expect
-  * `Approx::scale` defaults to `0.0`
-  * `Approx::epsilon` no longer applies to the larger of the two compared values, but only to the `Approx`'s value
-  * `INFINITY == Approx(INFINITY)` returns true
-
-
-### 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_MATCHES(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
-* Reporters/Listeners are now notified of fatal errors
-  * This means specific signals or structured exceptions
-  * The Reporter/Listener interface provides default, empty, implementation to preserve backward compatibility
-* Stringification of `std::chrono::duration` and `std::chrono::time_point` is now supported
-  * Needs to be enabled by a per-file compile time configuration option
-* Add `pkg-config` support to CMake install command
-
-
-### Fixes
-* Don't use console colour if running in XCode
-* Explicit constructor in reporter base class
-* Swept out `-Wweak-vtables`, `-Wexit-time-destructors`, `-Wglobal-constructors` warnings
-* Compilation for Universal Windows Platform (UWP) is supported
-  * SEH handling and colorized output are disabled when compiling for UWP
-* Implemented a workaround for `std::uncaught_exception` issues in libcxxrt
-  * These issues caused incorrect section traversals
-  * The workaround is only partial, user's test can still trigger the issue by using `throw;` to rethrow an exception
-* Suppressed C4061 warning under MSVC
-
-
-### 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.12.x
-
-#### 1.12.2
-##### Fixes
-* Fixed missing <cassert> include
-
-#### 1.12.1
-
-##### Fixes
-* Fixed deprecation warning in `ScopedMessage::~ScopedMessage`
-* All uses of `min` or `max` identifiers are now wrapped in parentheses
-  * This avoids problems when Windows headers define `min` and `max` macros
-
-#### 1.12.0
-
-##### Fixes
 * Fixed compilation for strict C++98 mode (ie not gnu++98) and older compilers (#1103)
 * `INFO` messages are included in the `xml` reporter output even without `-s` specified.
 
 
-### 1.11.x
 
-#### 1.11.0
+# 1.11.0
 
-##### Fixes
+### Fixes
 * The original expression in `REQUIRE_FALSE( expr )` is now reporter properly as `!( expr )` (#1051)
   * Previously the parentheses were missing and `x != y` would be expanded as `!x != x`
 * `Approx::Margin` is now inclusive (#952)
@@ -559,7 +16,7 @@ than `single_include/catch.hpp`.**
   * This means that `REQUIRE( 0.25f == Approx( 0.0f ).margin( 0.25f ) )` passes, instead of fails
 * `RandomNumberGenerator::result_type` is now unsigned (#1050)
 
-##### Improvements
+### Improvements
 * `__JETBRAINS_IDE__` macro handling is now CLion version specific (#1017)
   * When CLion 2017.3 or newer is detected, `__COUNTER__` is used instead of
 * TeamCity reporter now explicitly flushes output stream after each report (#1057)
@@ -567,35 +24,55 @@ than `single_include/catch.hpp`.**
 * `ParseAndAddCatchTests` now can add test files as dependency to CMake configuration
   * This means you do not have to manually rerun CMake configuration step to detect new tests
 
-### 1.10.x
 
-#### 1.10.0
+# 1.10.0
 
-##### Fixes
+### Fixes
 * Evaluation layer has been rewritten (backported from Catch 2)
   * The new layer is much simpler and fixes some issues (#981)
 * Implemented workaround for VS 2017 raw string literal stringification bug (#995)
 * Fixed interaction between `[!shouldfail]` and `[!mayfail]` tags and sections
   * Previously sections with failing assertions would be marked as failed, not failed-but-ok
 
-##### Improvements
+### Improvements
 * Added [libidentify](https://github.com/janwilmans/LibIdentify) support
 * Added "wait-for-keypress" option
 
-### 1.9.x
 
-#### 1.9.6
+# 1.9.7
 
-##### Improvements
+### Fixes
+* Various warnings from clang-tidy, Resharper-C++ and PVS Studio have been addressed (#957)
+* Dynamically generated sections are now properly reported (#963)
+* Writes to `std::clog` are redirected for reporters (#989)
+  * Previously only `std::cerr` writes were redirected
+  * Interleaved writes to `std::cerr` and `std::clog` are combined properly
+* Assertions failed before signals/structured exceptions fails test case are properly reported as failed (#990)
+
+### Improvements
+* Catch's runtime overhead has been decreased further (#940)
+* Added support for IBM i ILE c++ compiler (#976)
+  * This means that AS/400 is now supported.
+* The default reporter can be configured at compile time (#978)
+  * That is, the reporter used if no reporter is explicitly specified
+
+### Other
+* `ParseAndAddCatchTests` cmake script has couple new customization options
+
+
+
+# 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)
@@ -603,35 +80,35 @@ than `single_include/catch.hpp`.**
   * 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.
@@ -639,22 +116,22 @@ than `single_include/catch.hpp`.**
 * 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
@@ -668,7 +145,7 @@ than `single_include/catch.hpp`.**
 * 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.
@@ -677,18 +154,16 @@ than `single_include/catch.hpp`.**
   * [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.x
-
-#### 1.8.2
+# 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)
@@ -698,11 +173,11 @@ than `single_include/catch.hpp`.**
   * 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#top).
+* Listeners are now finally [documented](event-listeners.md).
   * 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)
@@ -719,25 +194,25 @@ than `single_include/catch.hpp`.**
 * 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#top).
+  * For details see [Matchers documentation](matchers.md).
 * 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)_
@@ -748,38 +223,36 @@ 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#top).
+  * For details see [documentation about integrating with build systems](build-systems.md).
 *  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#top).
+  * It has also received [new documentation](assertions.md).
 
-##### 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
   * Signal handling is no longer compiled by default.
   * Usage of `gettimeofday` inside Catch should no longer cause compilation errors.
-* Improved `-Wparentheses` suppression for gcc (#674)
-  * When compiled with gcc 4.8 or newer, the suppression is localized to assertions only
-  * Otherwise it is suppressed for the whole TU
+* Improved `-Wparentheses` supression for gcc (#674)
+  * When compiled with gcc 4.8 or newer, the supression is localized to assertions only
+  * 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.x
+# 1.7.2
 
-#### 1.7.2
-
-##### Fixes and minor improvements
+### Fixes and minor improvements
 Xml:
 
 (technically the first two are breaking changes but are also fixes and arguably break few if any people)
 * C-escape control characters instead of XML encoding them (which requires XML 1.1)
 * Revert XML output to XML 1.0
 * Can provide stylesheet references by extending the XML reporter
-* Added description and tags attributes to XML Reporter
+* Added description and tags attribites to XML Reporter
 * Tags are closed and the stream flushed more eagerly to avoid stdout interpolation
 
 
@@ -791,26 +264,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#top).
+  * For specifics, look into the [documentation](configuration.md).
 * 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#top).
+  * For now the support is only basic (no wildcards or tags), for details see the [documentation](command-line.md).
 * 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).
@@ -819,63 +292,61 @@ 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.x
+## 1.6.1
 
-#### 1.6.1
-
-##### Features/ Changes:
+### 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 suppressed when Catch is parsed by CLion
+* 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#top) for details.
+  * This can be disabled if needed, see [documentation](configuration.md) 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
 
 
-## Even Older versions
+# 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#top)
+[Home](Readme.md)

docs/release-process.md

@@ -1,72 +1,63 @@
-<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 process in doing so, that no steps are forgotten. Note that all referenced scripts can be found in the `scripts/` directory.
+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.
 
-## Necessary steps
+## Neccessary steps
 
-These steps are necessary and have to be performed before each new release. They serve to make sure that the new release is correct and linked-to from the standard places.
+These steps are neccessary and have to be performed before each new release. They serve to make sure that the new release is correct and linked-to from the standard places.
 
 
-### Testing
+### Approval testing
 
-All of the tests are currently run in our CI setup based on TravisCI and
-AppVeyor. As long as the last commit tested green, the release can
-proceed.
+Catch's releases are primarily validated against output from previous release, stored in `projects/SelfTest/Baselines`. To validate current sources, build the SelfTest binary and pass it to the `approvalTests.py` script: `approvalTests.py <path/to/SelfTest>`.
+
+There should be no differences, as Approval tests should be updated when changes to Catch are made, but if there are, then they need to be manually reviewed and either approved (using `approve.py`) or Catch requires other fixes.
 
 
 ### Incrementing version number
 
-Catch uses a variant of [semantic versioning](http://semver.org/), with breaking API changes (and thus major version increments) being very rare. Thus, the release will usually increment the patch version, when it only contains couple of bugfixes, or minor version, when it contains new functionality, or larger changes in implementation of current functionality.
+Catch uses a variant of [semantic versioning](http://semver.org/), with breaking API changes (and thus major version increments) being very rare. Thus, the release will usually increment the patch version, when it only contains couple of bugfixes, or minor version, when it contains new functionality, or larger changes in implementation of current functionality. 
 
 After deciding which part of version number should be incremented, you can use one of the `*Release.py` scripts to perform the required changes to Catch.
 
-This will take care of generating the single include header, updating
-version numbers everywhere and pushing the new version to Wandbox.
+
+### Generate updated single-include header
+
+After updating version number, regenerate single-include header using `generateSingleHeader.py`.
 
 
 ### Release notes
 
-Once a release is ready, release notes need to be written. They should summarize changes done since last release. For rough idea of expected notes see previous releases. Once written, release notes should be added to `docs/release-notes.md`.
+Once a release is ready, release notes need to be written. They should summarize changes done since last release. For rough idea of expected notes see previous releases. Once written, release notes should be placed in `docs/release-notes.md`.
 
 
 ### Commit and push update to GitHub
 
-After version number is incremented, single-include header is regenerated and release notes are updated, changes should be committed and pushed to GitHub.
+After version number is incremented, single-include header is regenerated and release notes are updated, changes should be commited and pushed to GitHub. 
 
 
 ### Release on GitHub
 
-After pushing changes to GitHub, GitHub release *needs* to be created.
-Tag version and release title should be same as the new version,
-description should contain the release notes for the current release.
-Single header version of `catch.hpp` *needs* to be attached as a binary,
-as that is where the official download link links to. Preferably
-it should use linux line endings. All non-bundled reporters (Automake,
-TAP, TeamCity) should also be attached as binaries, as they might be
-dependent on a specific version of the single-include header.
+After pushing changes to GitHub, GitHub release *needs* to be created. Tag version and release title should be same as the new version, description should contain the release notes for the current release. Single header version of `catch.hpp` *needs* to be attached as a binary, as that is where the official download link links to. Preferably it should use linux line endings.
 
-Since 2.5.0, the release tag and the "binaries" (headers) should be PGP
-signed.
+## Optional steps
 
-#### Signing a tag
+The following steps are optional, and do not have to be performed when releasing new version of Catch. However, they are *should* happen, but they can happen the next day without losing anything significant.
 
-To create a signed tag, use `git tag -s <VERSION>`, where `<VERSION>`
-is the version being released, e.g. `git tag -s v2.6.0`.
 
-Use the version name as the short message and the release notes as
-the body (long) message.
+### vcpkg update
 
-#### Signing the headers
-
-This will create ASCII-armored signatures for the headers that are
-uploaded to the GitHub release:
+Catch is maintaining its own port in Microsoft's package manager [vcpkg](https://github.com/Microsoft/vcpkg). This means that when new version of Catch is released, it should be posted there as well. `updateVcpkgPackage.py` can do a lot of neccessary work for you, it creates a branch and commits neccessary changes. You should review these changes, push and open a PR against vcpkg's upstream.
 
+Note that the script assumes you have your fork of vcpkg checked out in a directory next to the directory where you have checked out Catch, like so:
 ```
-$ gpg2 --armor --output catch.hpp.asc --detach-sig catch.hpp
-$ gpg2 --armor --output catch_reporter_automake.hpp.asc --detach-sig catch_reporter_automake.hpp
-$ gpg2 --armor --output catch_reporter_teamcity.hpp.asc --detach-sig catch_reporter_teamcity.hpp
-$ gpg2 --armor --output catch_reporter_tap.hpp.asc --detach-sig catch_reporter_tap.hpp
+GitHub
+    Catch
+    vcpkg
 ```
 
-_GPG does not support signing multiple files in single invocation._
+
+### Wandbox update
+
+Recently we also included a link to wandbox with preloaded Catch on the main page. Strictly speaking it is unneccessary to update this after every release, Catch usually does not change that much between versions, but it should be kept up to date anyway.
+

docs/reporters.md

@@ -1,4 +1,3 @@
-<a id="top"></a>
 # Reporters
 
 Catch has a modular reporting system and comes bundled with a handful of useful reporters built in.
@@ -18,15 +17,15 @@ 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.
+* `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).
 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.
 
 There are a few additional reporters, for specific build systems, in the Catch repository (in `include\reporters`) which you can `#include` in your project if you would like to make use of them.
-Do this in one source file - the same one you have `CATCH_CONFIG_MAIN` or `CATCH_CONFIG_RUNNER`.
+Do this in one source file - typically the same one you have `CATCH_CONFIG_MAIN` or `CATCH_CONFIG_RUNNER`.
 
-* `teamcity` writes the native, streaming, format that [TeamCity](https://www.jetbrains.com/teamcity/) understands. 
-Use this when building as part of a TeamCity build to see results as they happen ([code example](../examples/207-Rpt-TeamCityReporter.cpp)).
+* `teamcity` writes the native, streaming, format that [TeamCity](https://www.jetbrains.com/teamcity/) understands.
+Use this when building as part of a TeamCity build to see results as they happen.
 * `tap` writes in the TAP ([Test Anything Protocol](https://en.wikipedia.org/wiki/Test_Anything_Protocol)) format.
 * `automake` writes in a format that correspond to [automake  .trs](https://www.gnu.org/software/automake/manual/html_node/Log-files-generation-and-test-results-recording.html) files
 
@@ -43,4 +42,4 @@ but do keep in mind upcoming changes (these will be minor, simplifying, changes
 
 ---
 
-[Home](Readme.md#top)
+[Home](Readme.md)

docs/slow-compiles.md

@@ -1,12 +1,5 @@
-<a id="top"></a>
 # Why do my tests take so long to compile?
 
-**Contents**<br>
-[Short answer](#short-answer)<br>
-[Long answer](#long-answer)<br>
-[Practical example](#practical-example)<br>
-[Other possible solutions](#other-possible-solutions)<br>
-
 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:
@@ -25,7 +18,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#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`:
+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`:
 
 ```cpp
 // tests-main.cpp
@@ -68,4 +61,4 @@ You can also opt to sacrifice some features in order to speed-up Catch's compila
 
 ---
 
-[Home](Readme.md#top)
+[Home](Readme.md)

docs/test-cases-and-sections.md

@@ -1,12 +1,5 @@
-<a id="top"></a>
 # Test cases and sections
 
-**Contents**<br>
-[Tags](#tags)<br>
-[Tag aliases](#tag-aliases)<br>
-[BDD-style test cases](#bdd-style-test-cases)<br>
-[Type parametrised test cases](#type-parametrised-test-cases)<br>
-
 While Catch fully supports the traditional, xUnit, style of class-based fixtures containing test case methods this is not the preferred style.
 
 Instead Catch provides a powerful mechanism for nesting test case sections within a test case. For a more detailed discussion see the [tutorial](tutorial.md#test-cases-and-sections).
@@ -18,7 +11,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#top)
+For examples see the [Tutorial](tutorial.md)
 
 ## Tags
 
@@ -26,10 +19,10 @@ Tags allow an arbitrary number of additional strings to be associated with a tes
 
 As an example - given the following test cases:
 
-    TEST_CASE( "A", "[widget]" ) { /* ... */ }
-    TEST_CASE( "B", "[widget]" ) { /* ... */ }
-    TEST_CASE( "C", "[gadget]" ) { /* ... */ }
-    TEST_CASE( "D", "[widget][gadget]" ) { /* ... */ }
+	TEST_CASE( "A", "[widget]" ) { /* ... */ }
+	TEST_CASE( "B", "[widget]" ) { /* ... */ }
+	TEST_CASE( "C", "[gadget]" ) { /* ... */ }
+	TEST_CASE( "D", "[widget][gadget]" ) { /* ... */ }
 
 The tag expression, ```"[widget]"``` selects A, B & D. ```"[gadget]"``` selects C & D. ```"[widget][gadget]"``` selects just D and ```"[widget],[gadget]"``` selects all four test cases.
 
@@ -41,9 +34,9 @@ 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 `[.]` - 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 `[.]` (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.
 
-* `[!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`.
+* `[!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`.
 
 * `[!mayfail]` - doesn't fail the test if any given assertion fails (but still reports it). This can be useful to flag a work-in-progress, or a known issue that you don't want to immediately fix but still want to track in your tests.
 
@@ -55,17 +48,15 @@ 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:
 
-    CATCH_REGISTER_TAG_ALIAS( <alias string>, <tag expression> )
+	CATCH_REGISTER_TAG_ALIAS( <alias string>, <tag expression> )
 
 Aliases must begin with the `@` character. An example of a tag alias is:
 
-    CATCH_REGISTER_TAG_ALIAS( "[@nhf]", "[failing]~[.]" )
+	CATCH_REGISTER_TAG_ALIAS( "[@nhf]", "[failing]~[.]" )
 
 Now when `[@nhf]` is used on the command line this matches all tests that are tagged `[failing]`, but which are not also hidden.
 
@@ -92,105 +83,6 @@ When any of these macros are used the console reporter recognises them and forma
 
 Other than the additional prefixes and the formatting in the console reporter these macros behave exactly as ```TEST_CASE```s and ```SECTION```s. As such there is nothing enforcing the correct sequencing of these macros - that's up to the programmer!
 
-## Type parametrised test cases
-
-In addition to `TEST_CASE`s, Catch2 also supports test cases parametrised
-by types, in the form of `TEMPLATE_TEST_CASE` and
-`TEMPLATE_PRODUCT_TEST_CASE`.
-
-* **TEMPLATE_TEST_CASE(** _test name_ , _tags_,  _type1_, _type2_, ..., _typen_ **)**
-
-_test name_ and _tag_ are exactly the same as they are in `TEST_CASE`,
-with the difference that the tag string must be provided (however, it
-can be empty). _type1_ through _typen_ is the list of types for which
-this test case should run, and, inside the test code, the current type
-is available as the `TestType` type.
-
-Because of limitations of the C++ preprocessor, if you want to specify
-a type with multiple template parameters, you need to enclose it in
-parentheses, e.g. `std::map<int, std::string>` needs to be passed as
-`(std::map<int, std::string>)`.
-
-Example:
-```cpp
-TEMPLATE_TEST_CASE( "vectors can be sized and resized", "[vector][template]", int, std::string, (std::tuple<int,float>) ) {
-
-    std::vector<TestType> v( 5 );
-
-    REQUIRE( v.size() == 5 );
-    REQUIRE( v.capacity() >= 5 );
-
-    SECTION( "resizing bigger changes size and capacity" ) {
-        v.resize( 10 );
-
-        REQUIRE( v.size() == 10 );
-        REQUIRE( v.capacity() >= 10 );
-    }
-    SECTION( "resizing smaller changes size but not capacity" ) {
-        v.resize( 0 );
-
-        REQUIRE( v.size() == 0 );
-        REQUIRE( v.capacity() >= 5 );
-
-        SECTION( "We can use the 'swap trick' to reset the capacity" ) {
-            std::vector<TestType> empty;
-            empty.swap( v );
-
-            REQUIRE( v.capacity() == 0 );
-        }
-    }
-    SECTION( "reserving smaller does not change size or capacity" ) {
-        v.reserve( 0 );
-
-        REQUIRE( v.size() == 5 );
-        REQUIRE( v.capacity() >= 5 );
-    }
-}
-```
-
-* **TEMPLATE_PRODUCT_TEST_CASE(** _test name_ , _tags_, (_template-type1_, _template-type2_, ..., _template-typen_), (_template-arg1_, _template-arg2_, ..., _template-argm_) **)**
-
-_template-type1_ through _template-typen_ is list of template template
-types which should be combined with each of _template-arg1_ through
- _template-argm_, resulting in _n * m_ test cases. Inside the test case,
-the resulting type is available under the name of `TestType`.
-
-To specify more than 1 type as a single _template-type_ or _template-arg_,
-you must enclose the types in an additional set of parentheses, e.g.
-`((int, float), (char, double))` specifies 2 template-args, each
-consisting of 2 concrete types (`int`, `float` and `char`, `double`
-respectively). You can also omit the outer set of parentheses if you
-specify only one type as the full set of either the _template-types_,
-or the _template-args_.
-
-
-Example:
-```cpp
-template< typename T>
-struct Foo {
-    size_t size() {
-        return 0;
-    }
-};
-
-TEMPLATE_PRODUCT_TEST_CASE("A Template product test case", "[template][product]", (std::vector, Foo), (int, float)) {
-    TestType x;
-    REQUIRE(x.size() == 0);
-}
-```
-
-You can also have different arities in the _template-arg_ packs:
-```cpp
-TEMPLATE_PRODUCT_TEST_CASE("Product with differing arities", "[template][product]", std::tuple, (int, (int, double), (int, double, float))) {
-    TestType x;
-    REQUIRE(std::tuple_size<TestType>::value >= 1);
-}
-```
-
-_While there is an upper limit on the number of types you can specify
-in single `TEMPLATE_TEST_CASE` or `TEMPLATE_PRODUCT_TEST_CASE`, the limit
-is very high and should not be encountered in practice._
-
 ---
 
-[Home](Readme.md#top)
+[Home](Readme.md)

docs/test-fixtures.md

@@ -1,6 +1,3 @@
-<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++
@@ -30,60 +27,6 @@ class UniqueTestsFixture {
 
 The two test cases here will create uniquely-named derived classes of UniqueTestsFixture and thus can access the `getID()` protected method and `conn` member variables. This ensures that both the test cases are able to create a DBConnection using the same method (DRY principle) and that any ID's created are unique such that the order that tests are executed does not matter.
 
-
-Catch2 also provides `TEMPLATE_TEST_CASE_METHOD` and
-`TEMPLATE_PRODUCT_TEST_CASE_METHOD` that can be used together
-with templated fixtures and templated template fixtures to perform
-tests for multiple different types. Unlike `TEST_CASE_METHOD`,
-`TEMPLATE_TEST_CASE_METHOD` and `TEMPLATE_PRODUCT_TEST_CASE_METHOD` do
-require the tag specification to be non-empty, as it is followed by
-further macro arguments.
-
-Also note that, because of limitations of the C++ preprocessor, if you
-want to specify a type with multiple template parameters, you need to
-enclose it in parentheses, e.g. `std::map<int, std::string>` needs to be
-passed as `(std::map<int, std::string>)`.
-In the case of `TEMPLATE_PRODUCT_TEST_CASE_METHOD`, if a member of the
-type list should consist of more than single type, it needs to be enclosed
-in another pair of parentheses, e.g. `(std::map, std::pair)` and
-`((int, float), (char, double))`.
-
-Example:
-```cpp
-template< typename T >
-struct Template_Fixture {
-    Template_Fixture(): m_a(1) {}
-
-    T m_a;
-};
-
-TEMPLATE_TEST_CASE_METHOD(Template_Fixture,"A TEMPLATE_TEST_CASE_METHOD based test run that succeeds", "[class][template]", int, float, double) {
-    REQUIRE( Template_Fixture<TestType>::m_a == 1 );
-}
-
-template<typename T>
-struct Template_Template_Fixture {
-    Template_Template_Fixture() {}
-
-    T m_a;
-};
-
-template<typename T>
-struct Foo_class {
-    size_t size() {
-        return 0;
-    }
-};
-
-TEMPLATE_PRODUCT_TEST_CASE_METHOD(Template_Template_Fixture, "A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test succeeds", "[class][template]", (Foo_class, std::vector), int) {
-    REQUIRE( Template_Template_Fixture<TestType>::m_a.size() == 0 );
-}
-```
-
-_While there is an upper limit on the number of types you can specify
-in single `TEMPLATE_TEST_CASE_METHOD` or `TEMPLATE_PRODUCT_TEST_CASE_METHOD`,
-the limit is very high and should not be encountered in practice._
-
 ---
 
-[Home](Readme.md#top)
+[Home](Readme.md)

docs/tostring.md

@@ -1,14 +1,7 @@
-<a id="top"></a>
 # String conversions
 
-**Contents**<br>
-[operator << overload for std::ostream](#operator--overload-for-stdostream)<br>
-[Catch::StringMaker specialisation](#catchstringmaker-specialisation)<br>
-[Catch::is_range specialisation](#catchis_range-specialisation)<br>
-[Exceptions](#exceptions)<br>
-
 Catch needs to be able to convert types you use in assertions and logging expressions into strings (for logging and reporting purposes).
-Most built-in or std types are supported out of the box but there are two ways that you can tell Catch how to convert your own types (or other, third-party types) into strings.
+Most built-in or std types are supported out of the box but there are three ways that you can tell Catch how to convert your own types (or other, third-party types) into strings.
 
 ## operator << overload for std::ostream
 
@@ -16,56 +9,54 @@ This is the standard way of providing string conversions in C++ - and the chance
 
 ```
 std::ostream& operator << ( std::ostream& os, T const& value ) {
-    os << convertMyTypeToString( value );
-    return os;
+	os << convertMyTypeToString( value );
+	return os;
 }
 ```
 
 (where ```T``` is your type and ```convertMyTypeToString``` is where you'll write whatever code is necessary to make your type printable - it doesn't have to be in another function).
 
-You should put this function in the same namespace as your type, or the global namespace, and have it declared before including Catch's header.
+You should put this function in the same namespace as your type and it has to be declared before including Catch's header.
 
-## Catch::StringMaker specialisation
-If you don't want to provide an ```operator <<``` overload, or you want to convert your type differently for testing purposes, you can provide a specialization for `Catch::StringMaker<T>`:
+## Catch::toString overload
+
+If you don't want to provide an ```operator <<``` overload, or you want to convert your type differently for testing purposes, you can provide an overload for ```Catch::toString()``` for your type.
 
 ```
 namespace Catch {
-    template<>
-    struct StringMaker<T> {
-        static std::string convert( T const& value ) {
-            return convertMyTypeToString( value );
-        }
-    };
+	std::string toString( T const& value ) {
+		return convertMyTypeToString( value );
+	}
 }
 ```
 
-## Catch::is_range specialisation
-As a fallback, Catch attempts to detect if the type can be iterated
-(`begin(T)` and `end(T)` are valid) and if it can be, it is stringified
-as a range. For certain types this can lead to infinite recursion, so
-it can be disabled by specializing `Catch::is_range` like so:
+Again ```T``` is your type and ```convertMyTypeToString``` is where you'll write whatever code is necessary to make your type printable. Note that the function must be in the Catch namespace, which itself must be in the global namespace and must be declared _before_ Catch's header is included.
 
-```cpp
+**Please note that overloading `Catch::toString` is currently considered legacy and will not be supported in the next major version of Catch.**
+
+## Catch::StringMaker<T> specialisation
+Another way of telling Catch how to convert a type to string is specialising `Catch::StringMaker` template. This allows you to have separate way of stringifying types for Catch, than you have for writing it to a stream and also doesn't require you to declare it before including Catch's header.
+
+```
 namespace Catch {
-    template<>
-    struct is_range<T> {
-        static const bool value = false;
-    };
+	template<> struct StringMaker<T> {
+    	static std::string convert( T const& value ) {
+        	return convertMyTypeToString( value ); 
+        } 
+    }; 
 }
-
 ```
 
-
 ## Exceptions
 
 By default all exceptions deriving from `std::exception` will be translated to strings by calling the `what()` method. For exception types that do not derive from `std::exception` - or if `what()` does not return a suitable string - use `CATCH_TRANSLATE_EXCEPTION`. This defines a function that takes your exception type, by reference, and returns a string. It can appear anywhere in the code - it doesn't have to be in the same translation unit. For example:
 
 ```
 CATCH_TRANSLATE_EXCEPTION( MyType& ex ) {
-    return ex.message();
+	return ex.message();
 }
 ```
 
 ---
 
-[Home](Readme.md#top)
+[Home](Readme.md)

docs/tutorial.md

@@ -1,38 +1,19 @@
-<a id="top"></a>
-# Tutorial
+# Getting Catch
 
-**Contents**<br>
-[Getting Catch2](#getting-catch2)<br>
-[Where to put it?](#where-to-put-it)<br>
-[Writing tests](#writing-tests)<br>
-[Test cases and sections](#test-cases-and-sections)<br>
-[BDD-Style](#bdd-style)<br>
-[Scaling up](#scaling-up)<br>
-[Type parametrised test cases](#type-parametrised-test-cases)<br>
-[Next steps](#next-steps)<br>
+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.
 
-## Getting Catch2
-
-The simplest way to get Catch2 is to download the latest [single header version](https://raw.githubusercontent.com/catchorg/Catch2/master/single_include/catch2/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.
-
-Alternative ways of getting Catch2 include using your system package
-manager, or installing it using [its CMake package](cmake-integration.md#installing-catch2-from-git-repository).
-
-The full source for Catch2, including test projects, documentation, and other things, is hosted on GitHub. [http://catch-lib.net](http://catch-lib.net) will redirect you there.
+The full source for Catch, including test projects, documentation, and other things, is hosted on GitHub. [http://catch-lib.net](http://catch-lib.net) will redirect you there.
 
 
 ## Where to put it?
 
-Catch2 is header only. All you need to do is drop the file somewhere reachable from your project - either in some central location you can set your header search path to find, or directly into your project tree itself! This is a particularly good option for other Open-Source projects that want to use Catch for their test suite. See [this blog entry for more on that](https://levelofindirection.com/blog/unit-testing-in-cpp-and-objective-c-just-got-ridiculously-easier-still.html).
+Catch is header only. All you need to do is drop the file(s) somewhere reachable from your project - either in some central location you can set your header search path to find, or directly into your project tree itself! This is a particularly good option for other Open-Source projects that want to use Catch for their test suite. See [this blog entry for more on that](http://www.levelofindirection.com/journal/2011/5/27/unit-testing-in-c-and-objective-c-just-got-ridiculously-easi.html). 
 
-The rest of this tutorial will assume that the Catch2 single-include header (or the include folder) is available unqualified - but you may need to prefix it with a folder name if necessary.
+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.
 
-_If you have installed Catch2 from system package manager, or CMake
-package, you need to include the header as `#include <catch2/catch.hpp>`_
+# Writing tests
 
-## Writing tests
-
-Let's start with a really simple example ([code](../examples/010-TestCase.cpp)). Say you have written a function to calculate factorials and now you want to test it (let's leave aside TDD for now).
+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). 
 
 ```c++
 unsigned int Factorial( unsigned int number ) {
@@ -40,7 +21,7 @@ unsigned int Factorial( unsigned int number ) {
 }
 ```
 
-To keep things simple we'll put everything in a single file (<a href="#scaling-up">see later for more on how to structure your test files</a>).
+To keep things simple we'll put everything in a single file (<a href="#scaling-up">see later for more on how to structure your test files</a>)
 
 ```c++
 #define CATCH_CONFIG_MAIN  // This tells Catch to provide a main() - only do this in one cpp file
@@ -58,7 +39,7 @@ TEST_CASE( "Factorials are computed", "[factorial]" ) {
 }
 ```
 
-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").
+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").
 
 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).
@@ -101,12 +82,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 a moment to consider those before we move on.
+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#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.
+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.
 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.
 
@@ -117,37 +98,37 @@ Most test frameworks have a class-based fixture mechanism. That is, test cases m
 
 While Catch fully supports this way of working there are a few problems with the approach. In particular the way your code must be split up, and the blunt granularity of it, may cause problems. You can only have one setup/ teardown pair across a set of methods, but sometimes you want slightly different setup in each method, or you may even want several levels of setup (a concept which we will clarify later on in this tutorial). It was <a href="http://jamesnewkirk.typepad.com/posts/2007/09/why-you-should-.html">problems like these</a> that led James Newkirk, who led the team that built NUnit, to start again from scratch and <a href="http://jamesnewkirk.typepad.com/posts/2007/09/announcing-xuni.html">build xUnit</a>).
 
-Catch takes a different approach (to both NUnit and xUnit) that is a more natural fit for C++ and the C family of languages. This is best explained through an example ([code](../examples/100-Fix-Section.cpp)):
+Catch takes a different approach (to both NUnit and xUnit) that is a more natural fit for C++ and the C family of languages. This is best explained through an example:
 
 ```c++
 TEST_CASE( "vectors can be sized and resized", "[vector]" ) {
 
     std::vector<int> v( 5 );
-
+    
     REQUIRE( v.size() == 5 );
     REQUIRE( v.capacity() >= 5 );
-
+    
     SECTION( "resizing bigger changes size and capacity" ) {
         v.resize( 10 );
-
+        
         REQUIRE( v.size() == 10 );
         REQUIRE( v.capacity() >= 10 );
     }
     SECTION( "resizing smaller changes size but not capacity" ) {
         v.resize( 0 );
-
+        
         REQUIRE( v.size() == 0 );
         REQUIRE( v.capacity() >= 5 );
     }
     SECTION( "reserving bigger changes capacity but not size" ) {
         v.reserve( 10 );
-
+        
         REQUIRE( v.size() == 5 );
         REQUIRE( v.capacity() >= 10 );
     }
     SECTION( "reserving smaller does not change size or capacity" ) {
         v.reserve( 0 );
-
+        
         REQUIRE( v.size() == 5 );
         REQUIRE( v.capacity() >= 5 );
     }
@@ -159,18 +140,18 @@ This works because the ```SECTION``` macro contains an if statement that calls b
 
 So far so good - this is already an improvement on the setup/teardown approach because now we see our setup code inline and use the stack.
 
-The power of sections really shows, however, when we need to execute a sequence of checked operations. Continuing the vector example, we might want to verify that attempting to reserve a capacity smaller than the current capacity of the vector changes nothing. We can do that, naturally, like so:
+The power of sections really shows, however, when we need to execute a sequence of, checked, operations. Continuing the vector example, we might want to verify that attempting to reserve a capacity smaller than the current capacity of the vector changes nothing. We can do that, naturally, like so:
 
 ```c++
     SECTION( "reserving bigger changes capacity but not size" ) {
         v.reserve( 10 );
-
+        
         REQUIRE( v.size() == 5 );
         REQUIRE( v.capacity() >= 10 );
-
+    
         SECTION( "reserving smaller again does not change capacity" ) {
             v.reserve( 7 );
-
+            
             REQUIRE( v.capacity() >= 10 );
         }
     }
@@ -180,22 +161,22 @@ 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#top).
+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).
 
-The vector example can be adjusted to use these macros like so ([example code](../examples/120-Bdd-ScenarioGivenWhenThen.cpp)):
+The vector example can be adjusted to use these macros like so:
 
 ```c++
 SCENARIO( "vectors can be sized and resized", "[vector]" ) {
 
     GIVEN( "A vector with some items" ) {
         std::vector<int> v( 5 );
-
+        
         REQUIRE( v.size() == 5 );
         REQUIRE( v.capacity() >= 5 );
-
+        
         WHEN( "the size is increased" ) {
             v.resize( 10 );
-
+            
             THEN( "the size and capacity change" ) {
                 REQUIRE( v.size() == 10 );
                 REQUIRE( v.capacity() >= 10 );
@@ -203,7 +184,7 @@ SCENARIO( "vectors can be sized and resized", "[vector]" ) {
         }
         WHEN( "the size is reduced" ) {
             v.resize( 0 );
-
+            
             THEN( "the size changes but not capacity" ) {
                 REQUIRE( v.size() == 0 );
                 REQUIRE( v.capacity() >= 5 );
@@ -211,7 +192,7 @@ SCENARIO( "vectors can be sized and resized", "[vector]" ) {
         }
         WHEN( "more capacity is reserved" ) {
             v.reserve( 10 );
-
+            
             THEN( "the capacity changes but not the size" ) {
                 REQUIRE( v.size() == 5 );
                 REQUIRE( v.capacity() >= 10 );
@@ -219,7 +200,7 @@ SCENARIO( "vectors can be sized and resized", "[vector]" ) {
         }
         WHEN( "less capacity is reserved" ) {
             v.reserve( 0 );
-
+            
             THEN( "neither size nor capacity are changed" ) {
                 REQUIRE( v.size() == 5 );
                 REQUIRE( v.capacity() >= 5 );
@@ -243,7 +224,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#top)):
+The requirement is that the following block of code ([or equivalent](own-main.md)):
 
 ```c++
 #define CATCH_CONFIG_MAIN
@@ -252,28 +233,17 @@ 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#top) (code example [main](../examples/020-TestCase-1.cpp), [tests](../examples/020-TestCase-2.cpp)).
+In fact it is usually a good idea to put the block with the ```#define``` [in its own source file](slow-compiles.md).
 
 Do not write your tests in header files!
 
 
-## Type parametrised test cases
-
-Test cases in Catch2 can be also parametrised by type, via the
-`TEMPLATE_TEST_CASE` and `TEMPLATE_PRODUCT_TEST_CASE` macros,
-which behave in the same way the `TEST_CASE` macro, but are run for
-every type or type combination.
-
-For more details, see our documentation on [test cases and
-sections](test-cases-and-sections.md#type-parametrised-test-cases).
-
-
 ## Next steps
 
 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#top) 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) for what's available.
 
 ---
 
-[Home](Readme.md#top)
+[Home](Readme.md)

docs/why-catch.md

@@ -1,46 +1,46 @@
-<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,
-including (but not limited to),
-[Google Test](http://code.google.com/p/googletest/),
-[Boost.Test](http://www.boost.org/doc/libs/1_49_0/libs/test/doc/html/index.html),
-[CppUnit](http://sourceforge.net/apps/mediawiki/cppunit/index.php?title=Main_Page),
-[Cute](http://www.cute-test.com),
-[many, many more](http://en.wikipedia.org/wiki/List_of_unit_testing_frameworks#C.2B.2B).
+Good question. For C++ there are quite a number of established frameworks, including (but not limited to), [CppUnit](http://sourceforge.net/apps/mediawiki/cppunit/index.php?title=Main_Page), [Google Test](http://code.google.com/p/googletest/), [Boost.Test](http://www.boost.org/doc/libs/1_49_0/libs/test/doc/html/index.html), [Aeryn](https://launchpad.net/aeryn), [Cute](http://r2.ifs.hsr.ch/cute), [Fructose](http://fructose.sourceforge.net/) and [many, many more](http://en.wikipedia.org/wiki/List_of_unit_testing_frameworks#C.2B.2B). Even for Objective-C there are a few, including OCUnit - which now comes bundled with XCode.
 
 So what does Catch bring to the party that differentiates it from these? Apart from a Catchy name, of course.
 
 ## Key Features
 
-* Quick and Really easy to get started. Just download catch.hpp, `#include` it and you're away.
-* No external dependencies. As long as you can compile C++11 and have a C++ standard library available.
-* Write test cases as, self-registering, functions (or methods, if you prefer).
-* Divide test cases into sections, each of which is run in isolation (eliminates the need for fixtures).
+* Really easy to get started. Just download catch.hpp, #include it and you're away. 
+* No external dependencies. As long as you can compile C++98 and have a C++ standard library available.
+* Write test cases as, self-registering, functions or methods.
+* Divide test cases into sections, each of which is run in isolation (eliminates the need for fixtures!)
 * Use BDD-style Given-When-Then sections as well as traditional unit test cases.
 * Only one core assertion macro for comparisons. Standard C/C++ operators are used for the comparison - yet the full expression is decomposed and lhs and rhs values are logged.
-* Tests are named using free-form strings - no more couching names in legal identifiers.
 
 ## Other core features
 
+* Tests are named using free-form strings - no more couching names in legal identifiers.
 * Tests can be tagged for easily running ad-hoc groups of tests.
 * Failures can (optionally) break into the debugger on Windows and Mac.
 * Output is through modular reporter objects. Basic textual and XML reporters are included. Custom reporters can easily be added.
 * JUnit xml output is supported for integration with third-party tools, such as CI servers.
-* A default main() function is provided, but you can supply your own for complete control (e.g. integration into your own test runner GUI).
+* A default main() function is provided (in a header), but you can supply your own for complete control (e.g. integration into your own test runner GUI).
 * A command line parser is provided and can still be used if you choose to provided your own main() function.
 * Catch can test itself.
 * Alternative assertion macro(s) report failures but don't abort the test case
 * Floating point tolerance comparisons are built in using an expressive Approx() syntax.
 * Internal and friendly macros are isolated so name clashes can be managed
-* Matchers
+* Support for Matchers (early stages)
+
+## Objective-C-specific features
+
+* Automatically detects if you are using it from an Objective-C project
+* Works with and without ARC with no additional configuration
+* Implement test fixtures using Obj-C classes too (like OCUnit)
+* Additional built in matchers that work with Obj-C types (e.g. string matchers)
 
 ## Who else is using Catch?
 
-See the list of [open source projects using Catch](opensource-users.md#top).
+See the list of [open source projects using Catch](opensource-users.md).
 
-See the [tutorial](tutorial.md#top) to get more of a taste of using Catch in practice 
+See the [tutorial](tutorial.md) to get more of a taste of using CATCH in practice 
 
 ---
 
-[Home](Readme.md#top)
+[Home](Readme.md)

examples/000-CatchMain.cpp

@@ -1,15 +0,0 @@
-// 000-CatchMain.cpp
-
-// In a Catch project with multiple files, dedicate one file to compile the
-// source code of Catch itself and reuse the resulting object file for linking.
-
-// Let Catch provide main():
-#define CATCH_CONFIG_MAIN
-
-#include <catch2/catch.hpp>
-
-// That's it
-
-// Compile implementation of Catch for use with files that do contain tests:
-// - g++ -std=c++11 -Wall -I$(CATCH_SINGLE_INCLUDE) -c 000-CatchMain.cpp
-// - cl -EHsc -I%CATCH_SINGLE_INCLUDE% -c 000-CatchMain.cpp

examples/010-TestCase.cpp

@@ -1,36 +0,0 @@
-// 010-TestCase.cpp
-
-// Let Catch provide main():
-#define CATCH_CONFIG_MAIN
-
-#include <catch2/catch.hpp>
-
-int Factorial( int number ) {
-   return number <= 1 ? number : Factorial( number - 1 ) * number;  // fail
-// return number <= 1 ? 1      : Factorial( number - 1 ) * number;  // pass
-}
-
-TEST_CASE( "Factorial of 0 is 1 (fail)", "[single-file]" ) {
-    REQUIRE( Factorial(0) == 1 );
-}
-
-TEST_CASE( "Factorials of 1 and higher are computed (pass)", "[single-file]" ) {
-    REQUIRE( Factorial(1) == 1 );
-    REQUIRE( Factorial(2) == 2 );
-    REQUIRE( Factorial(3) == 6 );
-    REQUIRE( Factorial(10) == 3628800 );
-}
-
-// Compile & run:
-// - g++ -std=c++11 -Wall -I$(CATCH_SINGLE_INCLUDE) -o 010-TestCase 010-TestCase.cpp && 010-TestCase --success
-// - cl -EHsc -I%CATCH_SINGLE_INCLUDE% 010-TestCase.cpp && 010-TestCase --success
-
-// Expected compact output (all assertions):
-//
-// prompt> 010-TestCase --reporter compact --success
-// 010-TestCase.cpp:14: failed: Factorial(0) == 1 for: 0 == 1
-// 010-TestCase.cpp:18: passed: Factorial(1) == 1 for: 1 == 1
-// 010-TestCase.cpp:19: passed: Factorial(2) == 2 for: 2 == 2
-// 010-TestCase.cpp:20: passed: Factorial(3) == 6 for: 6 == 6
-// 010-TestCase.cpp:21: passed: Factorial(10) == 3628800 for: 3628800 (0x375f00) == 3628800 (0x375f00)
-// Failed 1 test case, failed 1 assertion.

examples/020-TestCase-1.cpp

@@ -1,35 +0,0 @@
-// 020-TestCase-1.cpp
-
-// In a Catch project with multiple files, dedicate one file to compile the
-// source code of Catch itself and reuse the resulting object file for linking.
-
-// Let Catch provide main():
-#define CATCH_CONFIG_MAIN
-
-#include <catch2/catch.hpp>
-
-TEST_CASE( "1: All test cases reside in other .cpp files (empty)", "[multi-file:1]" ) {
-}
-
-// ^^^
-// Normally no TEST_CASEs in this file.
-// Here just to show there are two source files via option --list-tests.
-
-// Compile & run:
-// - g++ -std=c++11 -Wall -I$(CATCH_SINGLE_INCLUDE) -c 020-TestCase-1.cpp
-// - g++ -std=c++11 -Wall -I$(CATCH_SINGLE_INCLUDE) -o 020-TestCase TestCase-1.o 020-TestCase-2.cpp && 020-TestCase --success
-//
-// - cl -EHsc -I%CATCH_SINGLE_INCLUDE% -c 020-TestCase-1.cpp
-// - cl -EHsc -I%CATCH_SINGLE_INCLUDE% -Fe020-TestCase.exe 020-TestCase-1.obj 020-TestCase-2.cpp && 020-TestCase --success
-
-// Expected test case listing:
-//
-// prompt> 020-TestCase --list-tests *
-// Matching test cases:
-//   1: All test cases reside in other .cpp files (empty)
-//       [multi-file:1]
-//   2: Factorial of 0 is computed (fail)
-//       [multi-file:2]
-//   2: Factorials of 1 and higher are computed (pass)
-//       [multi-file:2]
-// 3 matching test cases

examples/020-TestCase-2.cpp

@@ -1,33 +0,0 @@
-// 020-TestCase-2.cpp
-
-// main() provided by Catch in file 020-TestCase-1.cpp.
-
-#include <catch2/catch.hpp>
-
-int Factorial( int number ) {
-   return number <= 1 ? number : Factorial( number - 1 ) * number;  // fail
-// return number <= 1 ? 1      : Factorial( number - 1 ) * number;  // pass
-}
-
-TEST_CASE( "2: Factorial of 0 is 1 (fail)", "[multi-file:2]" ) {
-    REQUIRE( Factorial(0) == 1 );
-}
-
-TEST_CASE( "2: Factorials of 1 and higher are computed (pass)", "[multi-file:2]" ) {
-    REQUIRE( Factorial(1) == 1 );
-    REQUIRE( Factorial(2) == 2 );
-    REQUIRE( Factorial(3) == 6 );
-    REQUIRE( Factorial(10) == 3628800 );
-}
-
-// Compile: see 020-TestCase-1.cpp
-
-// Expected compact output (all assertions):
-//
-// prompt> 020-TestCase --reporter compact --success
-// 020-TestCase-2.cpp:13: failed: Factorial(0) == 1 for: 0 == 1
-// 020-TestCase-2.cpp:17: passed: Factorial(1) == 1 for: 1 == 1
-// 020-TestCase-2.cpp:18: passed: Factorial(2) == 2 for: 2 == 2
-// 020-TestCase-2.cpp:19: passed: Factorial(3) == 6 for: 6 == 6
-// 020-TestCase-2.cpp:20: passed: Factorial(10) == 3628800 for: 3628800 (0x375f00) == 3628800 (0x375f00)
-// Failed 1 test case, failed 1 assertion.

examples/030-Asn-Require-Check.cpp

@@ -1,74 +0,0 @@
-// 030-Asn-Require-Check.cpp
-
-// Catch has two natural expression assertion macro's:
-// - REQUIRE() stops at first failure.
-// - CHECK() continues after failure.
-
-// There are two variants to support decomposing negated expressions:
-// - REQUIRE_FALSE() stops at first failure.
-// - CHECK_FALSE() continues after failure.
-
-// main() provided in 000-CatchMain.cpp
-
-#include <catch2/catch.hpp>
-
-std::string one() {
-    return "1";
-}
-
-TEST_CASE( "Assert that something is true (pass)", "[require]" ) {
-    REQUIRE( one() == "1" );
-}
-
-TEST_CASE( "Assert that something is true (fail)", "[require]" ) {
-    REQUIRE( one() == "x" );
-}
-
-TEST_CASE( "Assert that something is true (stop at first failure)", "[require]" ) {
-    WARN( "REQUIRE stops at first failure:" );
-
-    REQUIRE( one() == "x" );
-    REQUIRE( one() == "1" );
-}
-
-TEST_CASE( "Assert that something is true (continue after failure)", "[check]" ) {
-    WARN( "CHECK continues after failure:" );
-
-    CHECK(   one() == "x" );
-    REQUIRE( one() == "1" );
-}
-
-TEST_CASE( "Assert that something is false (stops at first failure)", "[require-false]" ) {
-    WARN( "REQUIRE_FALSE stops at first failure:" );
-
-    REQUIRE_FALSE( one() == "1" );
-    REQUIRE_FALSE( one() != "1" );
-}
-
-TEST_CASE( "Assert that something is false (continue after failure)", "[check-false]" ) {
-    WARN( "CHECK_FALSE continues after failure:" );
-
-    CHECK_FALSE(   one() == "1" );
-    REQUIRE_FALSE( one() != "1" );
-}
-
-// Compile & run:
-// - g++ -std=c++11 -Wall -I$(CATCH_SINGLE_INCLUDE) -o 030-Asn-Require-Check 030-Asn-Require-Check.cpp 000-CatchMain.o && 030-Asn-Require-Check --success
-// - cl -EHsc -I%CATCH_SINGLE_INCLUDE% 030-Asn-Require-Check.cpp 000-CatchMain.obj && 030-Asn-Require-Check --success
-
-// Expected compact output (all assertions):
-//
-// prompt> 030-Asn-Require-Check.exe --reporter compact --success
-// 030-Asn-Require-Check.cpp:20: passed: one() == "1" for: "1" == "1"
-// 030-Asn-Require-Check.cpp:24: failed: one() == "x" for: "1" == "x"
-// 030-Asn-Require-Check.cpp:28: warning: 'REQUIRE stops at first failure:'
-// 030-Asn-Require-Check.cpp:30: failed: one() == "x" for: "1" == "x"
-// 030-Asn-Require-Check.cpp:35: warning: 'CHECK continues after failure:'
-// 030-Asn-Require-Check.cpp:37: failed: one() == "x" for: "1" == "x"
-// 030-Asn-Require-Check.cpp:38: passed: one() == "1" for: "1" == "1"
-// 030-Asn-Require-Check.cpp:42: warning: 'REQUIRE_FALSE stops at first failure:'
-// 030-Asn-Require-Check.cpp:44: failed: !(one() == "1") for: !("1" == "1")
-// 030-Asn-Require-Check.cpp:49: warning: 'CHECK_FALSE continues after failure:'
-// 030-Asn-Require-Check.cpp:51: failed: !(one() == "1") for: !("1" == "1")
-// 030-Asn-Require-Check.cpp:52: passed: !(one() != "1") for: !("1" != "1")
-// Failed 5 test cases, failed 5 assertions.

examples/100-Fix-Section.cpp

@@ -1,69 +0,0 @@
-// 100-Fix-Section.cpp
-
-// Catch has two ways to express fixtures:
-// - Sections (this file)
-// - Traditional class-based fixtures
-
-// main() provided in 000-CatchMain.cpp
-
-#include <catch2/catch.hpp>
-
-TEST_CASE( "vectors can be sized and resized", "[vector]" ) {
-
-    // For each section, vector v is anew:
-
-    std::vector<int> v( 5 );
-
-    REQUIRE( v.size() == 5 );
-    REQUIRE( v.capacity() >= 5 );
-
-    SECTION( "resizing bigger changes size and capacity" ) {
-        v.resize( 10 );
-
-        REQUIRE( v.size() == 10 );
-        REQUIRE( v.capacity() >= 10 );
-    }
-    SECTION( "resizing smaller changes size but not capacity" ) {
-        v.resize( 0 );
-
-        REQUIRE( v.size() == 0 );
-        REQUIRE( v.capacity() >= 5 );
-    }
-    SECTION( "reserving bigger changes capacity but not size" ) {
-        v.reserve( 10 );
-
-        REQUIRE( v.size() == 5 );
-        REQUIRE( v.capacity() >= 10 );
-    }
-    SECTION( "reserving smaller does not change size or capacity" ) {
-        v.reserve( 0 );
-
-        REQUIRE( v.size() == 5 );
-        REQUIRE( v.capacity() >= 5 );
-    }
-}
-
-// Compile & run:
-// - g++ -std=c++11 -Wall -I$(CATCH_SINGLE_INCLUDE) -o 100-Fix-Section 100-Fix-Section.cpp 000-CatchMain.o && 100-Fix-Section --success
-// - cl -EHsc -I%CATCH_SINGLE_INCLUDE% 100-Fix-Section.cpp 000-CatchMain.obj && 100-Fix-Section --success
-
-// Expected compact output (all assertions):
-//
-// prompt> 100-Fix-Section.exe --reporter compact --success
-// 100-Fix-Section.cpp:17: passed: v.size() == 5 for: 5 == 5
-// 100-Fix-Section.cpp:18: passed: v.capacity() >= 5 for: 5 >= 5
-// 100-Fix-Section.cpp:23: passed: v.size() == 10 for: 10 == 10
-// 100-Fix-Section.cpp:24: passed: v.capacity() >= 10 for: 10 >= 10
-// 100-Fix-Section.cpp:17: passed: v.size() == 5 for: 5 == 5
-// 100-Fix-Section.cpp:18: passed: v.capacity() >= 5 for: 5 >= 5
-// 100-Fix-Section.cpp:29: passed: v.size() == 0 for: 0 == 0
-// 100-Fix-Section.cpp:30: passed: v.capacity() >= 5 for: 5 >= 5
-// 100-Fix-Section.cpp:17: passed: v.size() == 5 for: 5 == 5
-// 100-Fix-Section.cpp:18: passed: v.capacity() >= 5 for: 5 >= 5
-// 100-Fix-Section.cpp:35: passed: v.size() == 5 for: 5 == 5
-// 100-Fix-Section.cpp:36: passed: v.capacity() >= 10 for: 10 >= 10
-// 100-Fix-Section.cpp:17: passed: v.size() == 5 for: 5 == 5
-// 100-Fix-Section.cpp:18: passed: v.capacity() >= 5 for: 5 >= 5
-// 100-Fix-Section.cpp:41: passed: v.size() == 5 for: 5 == 5
-// 100-Fix-Section.cpp:42: passed: v.capacity() >= 5 for: 5 >= 5
-// Passed 1 test case with 16 assertions.

examples/110-Fix-ClassFixture.cpp

@@ -1,63 +0,0 @@
-// 110-Fix-ClassFixture.cpp
-
-// Catch has two ways to express fixtures:
-// - Sections
-// - Traditional class-based fixtures (this file)
-
-// main() provided in 000-CatchMain.cpp
-
-#include <catch2/catch.hpp>
-
-class DBConnection
-{
-public:
-    static DBConnection createConnection( std::string const & /*dbName*/ ) {
-        return DBConnection();
-    }
-
-    bool executeSQL( std::string const & /*query*/, int const /*id*/, std::string const & arg ) {
-        if ( arg.length() == 0 ) {
-            throw std::logic_error("empty SQL query argument");
-        }
-        return true; // ok
-    }
-};
-
-class UniqueTestsFixture
-{
-protected:
-    UniqueTestsFixture()
-    : conn( DBConnection::createConnection( "myDB" ) )
-    {}
-
-    int getID() {
-        return ++uniqueID;
-    }
-
-protected:
-    DBConnection conn;
-
-private:
-    static int uniqueID;
-};
-
-int UniqueTestsFixture::uniqueID = 0;
-
-TEST_CASE_METHOD( UniqueTestsFixture, "Create Employee/No Name", "[create]" ) {
-    REQUIRE_THROWS( conn.executeSQL( "INSERT INTO employee (id, name) VALUES (?, ?)", getID(), "") );
-}
-
-TEST_CASE_METHOD( UniqueTestsFixture, "Create Employee/Normal", "[create]" ) {
-    REQUIRE( conn.executeSQL( "INSERT INTO employee (id, name) VALUES (?, ?)", getID(), "Joe Bloggs" ) );
-}
-
-// Compile & run:
-// - g++ -std=c++11 -Wall -I$(CATCH_SINGLE_INCLUDE) -o 110-Fix-ClassFixture 110-Fix-ClassFixture.cpp 000-CatchMain.o && 110-Fix-ClassFixture --success
-// - cl -EHsc -I%CATCH_SINGLE_INCLUDE% 110-Fix-ClassFixture.cpp 000-CatchMain.obj && 110-Fix-ClassFixture --success
-
-// Expected compact output (all assertions):
-//
-// prompt> 110-Fix-ClassFixture.exe --reporter compact --success
-// 110-Fix-ClassFixture.cpp:47: passed: conn.executeSQL( "INSERT INTO employee (id, name) VALUES (?, ?)", getID(), "")
-// 110-Fix-ClassFixture.cpp:51: passed: conn.executeSQL( "INSERT INTO employee (id, name) VALUES (?, ?)", getID(), "Joe Bloggs" ) for: true
-// Passed both 2 test cases with 2 assertions.

examples/120-Bdd-ScenarioGivenWhenThen.cpp

@@ -1,73 +0,0 @@
-// 120-Bdd-ScenarioGivenWhenThen.cpp
-
-// main() provided in 000-CatchMain.cpp
-
-#include <catch2/catch.hpp>
-
-SCENARIO( "vectors can be sized and resized", "[vector]" ) {
-
-    GIVEN( "A vector with some items" ) {
-        std::vector<int> v( 5 );
-
-        REQUIRE( v.size() == 5 );
-        REQUIRE( v.capacity() >= 5 );
-
-        WHEN( "the size is increased" ) {
-            v.resize( 10 );
-
-            THEN( "the size and capacity change" ) {
-                REQUIRE( v.size() == 10 );
-                REQUIRE( v.capacity() >= 10 );
-            }
-        }
-        WHEN( "the size is reduced" ) {
-            v.resize( 0 );
-
-            THEN( "the size changes but not capacity" ) {
-                REQUIRE( v.size() == 0 );
-                REQUIRE( v.capacity() >= 5 );
-            }
-        }
-        WHEN( "more capacity is reserved" ) {
-            v.reserve( 10 );
-
-            THEN( "the capacity changes but not the size" ) {
-                REQUIRE( v.size() == 5 );
-                REQUIRE( v.capacity() >= 10 );
-            }
-        }
-        WHEN( "less capacity is reserved" ) {
-            v.reserve( 0 );
-
-            THEN( "neither size nor capacity are changed" ) {
-                REQUIRE( v.size() == 5 );
-                REQUIRE( v.capacity() >= 5 );
-            }
-        }
-    }
-}
-
-// Compile & run:
-// - g++ -std=c++11 -Wall -I$(CATCH_SINGLE_INCLUDE) -o 120-Bdd-ScenarioGivenWhenThen 120-Bdd-ScenarioGivenWhenThen.cpp 000-CatchMain.o && 120-Bdd-ScenarioGivenWhenThen --success
-// - cl -EHsc -I%CATCH_SINGLE_INCLUDE% 120-Bdd-ScenarioGivenWhenThen.cpp 000-CatchMain.obj && 120-Bdd-ScenarioGivenWhenThen --success
-
-// Expected compact output (all assertions):
-//
-// prompt> 120-Bdd-ScenarioGivenWhenThen.exe --reporter compact --success
-// 120-Bdd-ScenarioGivenWhenThen.cpp:12: passed: v.size() == 5 for: 5 == 5
-// 120-Bdd-ScenarioGivenWhenThen.cpp:13: passed: v.capacity() >= 5 for: 5 >= 5
-// 120-Bdd-ScenarioGivenWhenThen.cpp:19: passed: v.size() == 10 for: 10 == 10
-// 120-Bdd-ScenarioGivenWhenThen.cpp:20: passed: v.capacity() >= 10 for: 10 >= 10
-// 120-Bdd-ScenarioGivenWhenThen.cpp:12: passed: v.size() == 5 for: 5 == 5
-// 120-Bdd-ScenarioGivenWhenThen.cpp:13: passed: v.capacity() >= 5 for: 5 >= 5
-// 120-Bdd-ScenarioGivenWhenThen.cpp:27: passed: v.size() == 0 for: 0 == 0
-// 120-Bdd-ScenarioGivenWhenThen.cpp:28: passed: v.capacity() >= 5 for: 5 >= 5
-// 120-Bdd-ScenarioGivenWhenThen.cpp:12: passed: v.size() == 5 for: 5 == 5
-// 120-Bdd-ScenarioGivenWhenThen.cpp:13: passed: v.capacity() >= 5 for: 5 >= 5
-// 120-Bdd-ScenarioGivenWhenThen.cpp:35: passed: v.size() == 5 for: 5 == 5
-// 120-Bdd-ScenarioGivenWhenThen.cpp:36: passed: v.capacity() >= 10 for: 10 >= 10
-// 120-Bdd-ScenarioGivenWhenThen.cpp:12: passed: v.size() == 5 for: 5 == 5
-// 120-Bdd-ScenarioGivenWhenThen.cpp:13: passed: v.capacity() >= 5 for: 5 >= 5
-// 120-Bdd-ScenarioGivenWhenThen.cpp:43: passed: v.size() == 5 for: 5 == 5
-// 120-Bdd-ScenarioGivenWhenThen.cpp:44: passed: v.capacity() >= 5 for: 5 >= 5
-// Passed 1 test case with 16 assertions.

examples/200-Rpt-CatchMain.cpp

@@ -1,27 +0,0 @@
-// 200-Rpt-CatchMain.cpp
-
-// In a Catch project with multiple files, dedicate one file to compile the
-// source code of Catch itself and reuse the resulting object file for linking.
-
-// Let Catch provide main():
-#define CATCH_CONFIG_MAIN
-
-#include <catch2/catch.hpp>
-
-#ifdef   CATCH_EXAMPLE_RPT_1
-#include CATCH_EXAMPLE_RPT_1
-#endif
-
-#ifdef   CATCH_EXAMPLE_RPT_2
-#include CATCH_EXAMPLE_RPT_2
-#endif
-
-#ifdef   CATCH_EXAMPLE_RPT_3
-#include CATCH_EXAMPLE_RPT_3
-#endif
-
-// That's it
-
-// Compile implementation of Catch for use with files that do contain tests:
-// - g++ -std=c++11 -Wall -I$(CATCH_ROOT) -DCATCH_EXAMPLE_RPT_1=\"include/reporters/catch_reporter_teamcity.hpp\" -o 200-Rpt-CatchMainTeamCity.o -c 200-Rpt-CatchMain.cpp
-// cl -EHsc -I%CATCH_ROOT% -DCATCH_EXAMPLE_RPT_1=\"include/reporters/catch_reporter_teamcity.hpp\" -Fo200-Rpt-CatchMainTeamCity.obj -c 200-Rpt-CatchMain.cpp

examples/207-Rpt-TeamCityReporter.cpp

@@ -1,171 +0,0 @@
-// 207-Rpt-TeamCityReporter.cpp
-
-// Catch has built-in and external reporters:
-// Built-in:
-// - compact
-// - console
-// - junit
-// - xml
-// External:
-// - automake
-// - tap
-// - teamcity (this example)
-
-// main() and reporter code provided in 200-Rpt-CatchMain.cpp
-
-#include <catch2/catch.hpp>
-
-#ifdef _MSC_VER
-# pragma warning (disable : 4702) // Disable warning: unreachable code
-#endif
-
-TEST_CASE( "TeamCity passes unconditionally succeeding assertion", "[teamcity]" ) {
-
-    SUCCEED();
-}
-
-TEST_CASE( "TeamCity reports unconditionally failing assertion", "[teamcity]" ) {
-
-    FAIL();
-}
-
-TEST_CASE( "TeamCity reports failing check", "[teamcity]" ) {
-
-    REQUIRE( 3 == 7 );
-}
-
-TEST_CASE( "TeamCity reports failing check-false", "[teamcity]" ) {
-
-    REQUIRE_FALSE( 3 == 3 );
-}
-
-TEST_CASE( "TeamCity reports failing check-that", "[teamcity]" ) {
-
-    using namespace Catch;
-
-    REQUIRE_THAT( "hello", Contains( "world" ) );
-}
-
-TEST_CASE( "TeamCity reports unexpected exception", "[teamcity]" ) {
-
-    REQUIRE( (throw std::runtime_error("surprise!"), true) );
-}
-
-TEST_CASE( "TeamCity reports undesired exception", "[teamcity]" ) {
-
-    REQUIRE_NOTHROW( (throw std::runtime_error("surprise!"), true) );
-}
-
-TEST_CASE( "TeamCity reports missing expected exception", "[teamcity]" ) {
-
-    REQUIRE_THROWS( true );
-}
-
-TEST_CASE( "TeamCity reports missing specific expected exception", "[teamcity]" ) {
-
-    REQUIRE_THROWS_AS( throw std::bad_alloc(), std::runtime_error );
-}
-
-TEST_CASE( "TeamCity reports unexpected message in expected exception", "[teamcity]" ) {
-
-    using namespace Catch;
-
-    CHECK_THROWS_WITH( throw std::runtime_error("hello"), "world" );
-    CHECK_THROWS_WITH( throw std::runtime_error("hello"), Contains("world") );
-}
-
-struct MyException: public std::runtime_error
-{
-    MyException( char const * text )
-    : std::runtime_error( text ) {}
-    
-    ~MyException() override;
-};
-
-// prevent -Wweak-vtables:
-MyException::~MyException() = default;
-
-struct MyExceptionMatcher : Catch::MatcherBase< std::runtime_error >
-{
-    std::string m_text;
-
-    MyExceptionMatcher( char const * text )
-    : m_text( text )
-    {}
-
-    ~MyExceptionMatcher() override;
-    
-    bool match( std::runtime_error const & arg ) const override
-    { 
-        return m_text == arg.what() ; 
-    }
-    
-    std::string describe() const override 
-    { 
-        return "it's me";
-    }
-};
-
-// prevent -Wweak-vtables:
-MyExceptionMatcher::~MyExceptionMatcher() = default;
-
-TEST_CASE( "TeamCity failing check-throws-matches", "[teamcity]" ) {
-
-    CHECK_THROWS_MATCHES( throw MyException("hello"), MyException, MyExceptionMatcher("world") );
-}
-
-// [!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.
-
-// No special effects for the reporter.
-
-TEST_CASE( "TeamCity throwing exception with tag [!throws]", "[teamcity][!throws]" ) {
-
-    REQUIRE_THROWS( throw std::runtime_error("unsurprisingly") );
-}
-
-// [!mayfail] - doesn't fail the test if any given assertion fails (but still reports it). This can be useful to flag a work-in-progress, or a known issue that you don't want to immediately fix but still want to track in your tests.
-
-TEST_CASE( "TeamCity failing assertion with tag [!mayfail]", "[teamcity][!mayfail] " ) {
-
-    REQUIRE( 3 == 7 );  // doesn't fail test case this time, reports: testIgnored
-    REQUIRE( 3 == 3 );
-}
-
-// [!shouldfail] - like [!mayfail] but fails the test if it passes. 
-// This can be useful if you want to be notified of accidental, or third-party, fixes.
-
-TEST_CASE( "TeamCity succeeding assertion with tag [!shouldfail]", "[teamcity][!shouldfail]" ) {
-
-    SUCCEED( "Marked [!shouldfail]" );
-}
-
-// Compile & run:
-// - g++ -std=c++11 -Wall -I$(CATCH_ROOT) -DCATCH_EXAMPLE_RPT_1=\"include/reporters/catch_reporter_teamcity.hpp\" -o 200-Rpt-CatchMainTeamCity.o -c 200-Rpt-CatchMain.cpp
-// - g++ -std=c++11 -Wall -I$(CATCH_ROOT) -o 207-Rpt-TeamCityReporter 207-Rpt-TeamCityReporter.cpp 200-Rpt-CatchMainTeamCity.o && 207-Rpt-TeamCityReporter --list-reporters
-//
-// - cl -EHsc -I%CATCH_ROOT% -DCATCH_EXAMPLE_RPT_1=\"include/reporters/catch_reporter_teamcity.hpp\" -Fo200-Rpt-CatchMainTeamCity.obj -c 200-Rpt-CatchMain.cpp
-// - cl -EHsc -I%CATCH_ROOT% 207-Rpt-TeamCityReporter.cpp 200-Rpt-CatchMainTeamCity.o && 207-Rpt-TeamCityReporter --list-reporters
-
-// Compilation output (--list-reporters):
-// Available reporters:
-//   compact:   Reports test results on a single line, suitable for IDEs
-//   console:   Reports test results as plain lines of text
-//   junit:     Reports test results in an XML format that looks like Ant's
-//                junitreport target
-//   teamcity:  Reports test results as TeamCity service messages
-//   xml:       Reports test results as an XML document
-
-// Expected output (abbreviated and broken into shorter lines):
-//
-// prompt> 207-Rpt-TeamCityReporter.exe --reporter teamcity
-// ##teamcity[testSuiteStarted name='207-Rpt-TeamCityReporter.exe']
-// ##teamcity[testStarted name='TeamCity passes unconditionally succeeding assertion']
-// ##teamcity[testFinished name='TeamCity passes unconditionally succeeding assertion' duration='1']
-// ##teamcity[testStarted name='TeamCity reports unconditionally failing assertion']
-// ##teamcity[testFailed name='TeamCity reports unconditionally failing assertion' /
-// message='.../examples/207-Rpt-TeamCityReporter.cpp:23|n/
-// ...............................................................................|n|n/
-// .../examples/207-Rpt-TeamCityReporter.cpp:25|nexplicit failure']
-// ##teamcity[testFinished name='TeamCity reports unconditionally failing assertion' duration='3']
-// ...

examples/210-Evt-EventListeners.cpp

@@ -1,422 +0,0 @@
-// 210-Evt-EventListeners.cpp
-
-// Contents:
-// 1. Printing of listener data
-// 2. My listener and registration
-// 3. Test cases
-
-// main() provided in 000-CatchMain.cpp
-
-// Let Catch provide the required interfaces:
-#define CATCH_CONFIG_EXTERNAL_INTERFACES
-
-#include <catch2/catch.hpp>
-#include <iostream>
-
-// -----------------------------------------------------------------------
-// 1. Printing of listener data:
-//
-
-std::string ws(int const level) {
-    return std::string( 2 * level, ' ' );
-}
-
-template< typename T >
-std::ostream& operator<<( std::ostream& os, std::vector<T> const& v ) {
-    os << "{ ";
-    for ( auto x : v )
-        os << x << ", ";
-    return os << "}";
-}
-
-// struct SourceLineInfo {
-//     char const* file;
-//     std::size_t line;
-// };
-
-void print( std::ostream& os, int const level, std::string const& title, Catch::SourceLineInfo const& info ) {
-    os << ws(level  ) << title << ":\n"
-       << ws(level+1) << "- file: " << info.file << "\n"
-       << ws(level+1) << "- line: " << info.line << "\n";
-}
-
-//struct MessageInfo {
-//    std::string macroName;
-//    std::string message;
-//    SourceLineInfo lineInfo;
-//    ResultWas::OfType type;
-//    unsigned int sequence;
-//};
-
-void print( std::ostream& os, int const level, Catch::MessageInfo const& info ) {
-    os << ws(level+1) << "- macroName: '" << info.macroName << "'\n"
-       << ws(level+1) << "- message '"    << info.message   << "'\n";
-    print( os,level+1  , "- lineInfo", info.lineInfo );
-    os << ws(level+1) << "- sequence "    << info.sequence  << "\n";
-}
-
-void print( std::ostream& os, int const level, std::string const& title, std::vector<Catch::MessageInfo> const& v ) {
-    os << ws(level  ) << title << ":\n";
-    for ( auto x : v )
-    {
-        os << ws(level+1) << "{\n";
-        print( os, level+2, x );
-        os << ws(level+1) << "}\n";
-    }
-//    os << ws(level+1) << "\n";
-}
-
-// struct TestRunInfo {
-//     std::string name;
-// };
-
-void print( std::ostream& os, int const level, std::string const& title, Catch::TestRunInfo const& info ) {
-    os << ws(level  ) << title << ":\n"
-       << ws(level+1) << "- name: " << info.name << "\n";
-}
-
-// struct Counts {
-//     std::size_t total() const;
-//     bool allPassed() const;
-//     bool allOk() const;
-//
-//     std::size_t passed = 0;
-//     std::size_t failed = 0;
-//     std::size_t failedButOk = 0;
-// };
-
-void print( std::ostream& os, int const level, std::string const& title, Catch::Counts const& info ) {
-    os << ws(level  ) << title << ":\n"
-       << ws(level+1) << "- total(): "     << info.total()     << "\n"
-       << ws(level+1) << "- allPassed(): " << info.allPassed() << "\n"
-       << ws(level+1) << "- allOk(): "     << info.allOk()     << "\n"
-       << ws(level+1) << "- passed: "      << info.passed      << "\n"
-       << ws(level+1) << "- failed: "      << info.failed      << "\n"
-       << ws(level+1) << "- failedButOk: " << info.failedButOk << "\n";
-}
-
-// struct Totals {
-//     Counts assertions;
-//     Counts testCases;
-// };
-
-void print( std::ostream& os, int const level, std::string const& title, Catch::Totals const& info ) {
-    os << ws(level) << title << ":\n";
-    print( os, level+1, "- assertions", info.assertions );
-    print( os, level+1, "- testCases" , info.testCases  );
-}
-
-// struct TestRunStats {
-//     TestRunInfo runInfo;
-//     Totals totals;
-//     bool aborting;
-// };
-
-void print( std::ostream& os, int const level, std::string const& title, Catch::TestRunStats const& info ) {
-    os << ws(level) << title << ":\n";
-    print( os, level+1 , "- runInfo", info.runInfo );
-    print( os, level+1 , "- totals" , info.totals  );
-    os << ws(level+1) << "- aborting: " << info.aborting << "\n";
-}
-
-// struct TestCaseInfo {
-//     enum SpecialProperties{
-//         None = 0,
-//         IsHidden = 1 << 1,
-//         ShouldFail = 1 << 2,
-//         MayFail = 1 << 3,
-//         Throws = 1 << 4,
-//         NonPortable = 1 << 5,
-//         Benchmark = 1 << 6
-//     };
-//
-//     bool isHidden() const;
-//     bool throws() const;
-//     bool okToFail() const;
-//     bool expectedToFail() const;
-//
-//     std::string tagsAsString() const;
-//
-//     std::string name;
-//     std::string className;
-//     std::string description;
-//     std::vector<std::string> tags;
-//     std::vector<std::string> lcaseTags;
-//     SourceLineInfo lineInfo;
-//     SpecialProperties properties;
-// };
-
-void print( std::ostream& os, int const level, std::string const& title, Catch::TestCaseInfo const& info ) {
-    os << ws(level  ) << title << ":\n"
-       << ws(level+1) << "- isHidden(): "       << info.isHidden() << "\n"
-       << ws(level+1) << "- throws(): "         << info.throws() << "\n"
-       << ws(level+1) << "- okToFail(): "       << info.okToFail() << "\n"
-       << ws(level+1) << "- expectedToFail(): " << info.expectedToFail() << "\n"
-       << ws(level+1) << "- tagsAsString(): '"  << info.tagsAsString() << "'\n"
-       << ws(level+1) << "- name: '"            << info.name << "'\n"
-       << ws(level+1) << "- className: '"       << info.className << "'\n"
-       << ws(level+1) << "- description: '"     << info.description << "'\n"
-       << ws(level+1) << "- tags: "             << info.tags << "\n"
-       << ws(level+1) << "- lcaseTags: "        << info.lcaseTags << "\n";
-    print( os, level+1 , "- lineInfo", info.lineInfo );
-    os << ws(level+1) << "- properties (flags): 0x" << std::hex << info.properties << std::dec << "\n";
-}
-
-// struct TestCaseStats {
-//     TestCaseInfo testInfo;
-//     Totals totals;
-//     std::string stdOut;
-//     std::string stdErr;
-//     bool aborting;
-// };
-
-void print( std::ostream& os, int const level, std::string const& title, Catch::TestCaseStats const& info ) {
-    os << ws(level  ) << title << ":\n";
-    print( os, level+1 , "- testInfo", info.testInfo );
-    print( os, level+1 , "- totals"  , info.totals   );
-    os << ws(level+1) << "- stdOut: "   << info.stdOut << "\n"
-       << ws(level+1) << "- stdErr: "   << info.stdErr << "\n"
-       << ws(level+1) << "- aborting: " << info.aborting << "\n";
-}
-
-// struct SectionInfo {
-//     std::string name;
-//     std::string description;
-//     SourceLineInfo lineInfo;
-// };
-
-void print( std::ostream& os, int const level, std::string const& title, Catch::SectionInfo const& info ) {
-    os << ws(level  ) << title << ":\n"
-       << ws(level+1) << "- name: "         << info.name << "\n";
-    print( os, level+1 , "- lineInfo", info.lineInfo );
-}
-
-// struct SectionStats {
-//     SectionInfo sectionInfo;
-//     Counts assertions;
-//     double durationInSeconds;
-//     bool missingAssertions;
-// };
-
-void print( std::ostream& os, int const level, std::string const& title, Catch::SectionStats const& info ) {
-    os << ws(level  ) << title << ":\n";
-    print( os, level+1 , "- sectionInfo", info.sectionInfo );
-    print( os, level+1 , "- assertions" , info.assertions );
-    os << ws(level+1) << "- durationInSeconds: " << info.durationInSeconds << "\n"
-       << ws(level+1) << "- missingAssertions: " << info.missingAssertions << "\n";
-}
-
-// struct AssertionInfo
-// {
-//     StringRef macroName;
-//     SourceLineInfo lineInfo;
-//     StringRef capturedExpression;
-//     ResultDisposition::Flags resultDisposition;
-// };
-
-void print( std::ostream& os, int const level, std::string const& title, Catch::AssertionInfo const& info ) {
-    os << ws(level  ) << title << ":\n"
-       << ws(level+1) << "- macroName: '"  << info.macroName << "'\n";
-    print( os, level+1 , "- lineInfo" , info.lineInfo );
-    os << ws(level+1) << "- capturedExpression: '" << info.capturedExpression << "'\n"
-       << ws(level+1) << "- resultDisposition (flags): 0x" << std::hex << info.resultDisposition  << std::dec << "\n";
-}
-
-//struct AssertionResultData
-//{
-//    std::string reconstructExpression() const;
-//
-//    std::string message;
-//    mutable std::string reconstructedExpression;
-//    LazyExpression lazyExpression;
-//    ResultWas::OfType resultType;
-//};
-
-void print( std::ostream& os, int const level, std::string const& title, Catch::AssertionResultData const& info ) {
-    os << ws(level  ) << title << ":\n"
-       << ws(level+1) << "- reconstructExpression(): '" <<   info.reconstructExpression() << "'\n"
-       << ws(level+1) << "- message: '"                 <<   info.message << "'\n"
-       << ws(level+1) << "- lazyExpression: '"          << "(info.lazyExpression)" << "'\n"
-       << ws(level+1) << "- resultType: '"              <<   info.resultType << "'\n";
-}
-
-//class AssertionResult {
-//    bool isOk() const;
-//    bool succeeded() const;
-//    ResultWas::OfType getResultType() const;
-//    bool hasExpression() const;
-//    bool hasMessage() const;
-//    std::string getExpression() const;
-//    std::string getExpressionInMacro() const;
-//    bool hasExpandedExpression() const;
-//    std::string getExpandedExpression() const;
-//    std::string getMessage() const;
-//    SourceLineInfo getSourceInfo() const;
-//    std::string getTestMacroName() const;
-//
-//    AssertionInfo m_info;
-//    AssertionResultData m_resultData;
-//};
-
-void print( std::ostream& os, int const level, std::string const& title, Catch::AssertionResult const& info ) {
-    os << ws(level  ) << title << ":\n"
-       << ws(level+1) << "- isOk(): "  << info.isOk() << "\n"
-       << ws(level+1) << "- succeeded(): "  << info.succeeded() << "\n"
-       << ws(level+1) << "- getResultType(): "  << info.getResultType() << "\n"
-       << ws(level+1) << "- hasExpression(): "  << info.hasExpression() << "\n"
-       << ws(level+1) << "- hasMessage(): "  << info.hasMessage() << "\n"
-       << ws(level+1) << "- getExpression(): '"  << info.getExpression() << "'\n"
-       << ws(level+1) << "- getExpressionInMacro(): '"  << info.getExpressionInMacro()  << "'\n"
-       << ws(level+1) << "- hasExpandedExpression(): "  << info.hasExpandedExpression() << "\n"
-       << ws(level+1) << "- getExpandedExpression(): "  << info.getExpandedExpression() << "'\n"
-       << ws(level+1) << "- getMessage(): '"  << info.getMessage() << "'\n";
-    print( os, level+1 , "- getSourceInfo(): ", info.getSourceInfo() );
-    os << ws(level+1) << "- getTestMacroName(): '"  << info.getTestMacroName() << "'\n";
-
-//    print( os, level+1 , "- *** m_info (AssertionInfo)", info.m_info );
-//    print( os, level+1 , "- *** m_resultData (AssertionResultData)", info.m_resultData );
-}
-
-// struct AssertionStats {
-//     AssertionResult assertionResult;
-//     std::vector<MessageInfo> infoMessages;
-//     Totals totals;
-// };
-
-void print( std::ostream& os, int const level, std::string const& title, Catch::AssertionStats const& info ) {
-    os << ws(level  ) << title << ":\n";
-    print( os, level+1 , "- assertionResult", info.assertionResult );
-    print( os, level+1 , "- infoMessages", info.infoMessages );
-    print( os, level+1 , "- totals", info.totals );
-}
-
-// -----------------------------------------------------------------------
-// 2. My listener and registration:
-//
-
-char const * dashed_line =
-    "--------------------------------------------------------------------------";
-
-struct MyListener : Catch::TestEventListenerBase {
-
-    using TestEventListenerBase::TestEventListenerBase; // inherit constructor
-    
-    // Get rid of Wweak-tables
-    ~MyListener();
-
-    // The whole test run starting
-    void testRunStarting( Catch::TestRunInfo const& testRunInfo ) override {
-        std::cout
-            << std::boolalpha
-            << "\nEvent: testRunStarting:\n";
-        print( std::cout, 1, "- testRunInfo", testRunInfo );
-    }
-
-    // The whole test run ending
-    void testRunEnded( Catch::TestRunStats const& testRunStats ) override {
-        std::cout
-            << dashed_line
-            << "\nEvent: testRunEnded:\n";
-        print( std::cout, 1, "- testRunStats", testRunStats );
-    }
-
-    // A test is being skipped (because it is "hidden")
-    void skipTest( Catch::TestCaseInfo const& testInfo ) override {
-        std::cout
-            << dashed_line
-            << "\nEvent: skipTest:\n";
-        print( std::cout, 1, "- testInfo", testInfo );
-    }
-
-    // Test cases starting
-    void testCaseStarting( Catch::TestCaseInfo const& testInfo ) override {
-        std::cout
-            << dashed_line
-            << "\nEvent: testCaseStarting:\n";
-        print( std::cout, 1, "- testInfo", testInfo );
-    }
-
-    // Test cases ending
-    void testCaseEnded( Catch::TestCaseStats const& testCaseStats ) override {
-        std::cout << "\nEvent: testCaseEnded:\n";
-        print( std::cout, 1, "testCaseStats", testCaseStats );
-    }
-
-    // Sections starting
-    void sectionStarting( Catch::SectionInfo const& sectionInfo ) override {
-        std::cout << "\nEvent: sectionStarting:\n";
-        print( std::cout, 1, "- sectionInfo", sectionInfo );
-    }
-
-    // Sections ending
-    void sectionEnded( Catch::SectionStats const& sectionStats ) override {
-        std::cout << "\nEvent: sectionEnded:\n";
-        print( std::cout, 1, "- sectionStats", sectionStats );
-    }
-
-    // Assertions before/ after
-    void assertionStarting( Catch::AssertionInfo const& assertionInfo ) override {
-        std::cout << "\nEvent: assertionStarting:\n";
-        print( std::cout, 1, "- assertionInfo", assertionInfo );
-    }
-
-    bool assertionEnded( Catch::AssertionStats const& assertionStats ) override {
-        std::cout << "\nEvent: assertionEnded:\n";
-        print( std::cout, 1, "- assertionStats", assertionStats );
-        return true;
-    }
-};
-
-CATCH_REGISTER_LISTENER( MyListener )
-
-// Get rid of Wweak-tables
-MyListener::~MyListener() {}
-
-
-// -----------------------------------------------------------------------
-// 3. Test cases:
-//
-
-TEST_CASE( "1: Hidden testcase", "[.hidden]" ) {
-}
-
-TEST_CASE( "2: Testcase with sections", "[tag-A][tag-B]" ) {
-
-    int i = 42;
-
-    REQUIRE( i == 42 );
-
-    SECTION("Section 1") {
-        INFO("Section 1");
-        i = 7;
-        SECTION("Section 1.1") {
-            INFO("Section 1.1");
-            REQUIRE( i == 42 );
-        }
-    }
-
-    SECTION("Section 2") {
-        INFO("Section 2");
-        REQUIRE( i == 42 );
-    }
-    WARN("At end of test case");
-}
-
-struct Fixture {
-    int fortytwo() const {
-        return 42;
-    }
-};
-
-TEST_CASE_METHOD( Fixture, "3: Testcase with class-based fixture", "[tag-C][tag-D]" ) {
-    REQUIRE( fortytwo() == 42 );
-}
-
-// Compile & run:
-// - g++ -std=c++11 -Wall -I$(CATCH_SINGLE_INCLUDE) -o 210-Evt-EventListeners 210-Evt-EventListeners.cpp 000-CatchMain.o && 210-Evt-EventListeners --success
-// - cl -EHsc -I%CATCH_SINGLE_INCLUDE% 210-Evt-EventListeners.cpp 000-CatchMain.obj && 210-Evt-EventListeners --success
-
-// Expected compact output (all assertions):
-//
-// prompt> 210-Evt-EventListeners --reporter compact --success
-// result omitted for brevity.

examples/231-Cfg-OutputStreams.cpp

@@ -1,49 +0,0 @@
-// 231-Cfg-OutputStreams.cpp
-// Show how to replace the streams with a simple custom made streambuf.
-
-// Note that this reimplementation _does not_ follow `std::cerr`
-// semantic, because it buffers the output. For most uses however,
-// there is no important difference between having `std::cerr` buffered
-// or unbuffered.
-
-#define CATCH_CONFIG_NOSTDOUT
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-
-class out_buff : public std::stringbuf {
-    std::FILE* m_stream;
-public:
-    out_buff(std::FILE* stream) :m_stream(stream) {}
-    ~out_buff() { pubsync(); }
-    int sync() {
-        int ret = 0;
-        for (unsigned char c : str()) {
-            if (putc(c, m_stream) == EOF) {
-                ret = -1;
-                break;
-            }
-        }
-        // Reset the buffer to avoid printing it multiple times
-        str("");
-        return ret;
-    }
-};
-
-namespace Catch {
-    std::ostream& cout() {
-        static std::ostream ret(new out_buff(stdout));
-        return ret;
-    }
-    std::ostream& clog() {
-        static std::ostream ret(new out_buff(stderr));
-        return ret;
-    }
-    std::ostream& cerr() {
-        return clog();
-    }
-}
-
-
-TEST_CASE("This binary uses putc to write out output", "[compilation-only]") {
-    SUCCEED("Nothing to test.");
-}

examples/300-Gen-OwnGenerator.cpp

@@ -1,59 +0,0 @@
-// 300-Gen-OwnGenerator.cpp
-// Shows how to define a custom generator.
-
-// Specifically we will implement a random number generator for integers
-// It will have infinite capacity and settable lower/upper bound
-
-#include <catch2/catch.hpp>
-
-#include <random>
-
-// This class shows how to implement a simple generator for Catch tests
-class RandomIntGenerator : public Catch::Generators::IGenerator<int> {
-    std::minstd_rand m_rand;
-    std::uniform_int_distribution<> m_dist;
-    int current_number;
-public:
-
-    RandomIntGenerator(int low, int high):
-        m_rand(std::random_device{}()),
-        m_dist(low, high)
-    {
-        static_cast<void>(next());
-    }
-
-    int const& get() const override;
-    bool next() override {
-        current_number = m_dist(m_rand);
-        return true;
-    }
-};
-
-// Avoids -Wweak-vtables
-int const& RandomIntGenerator::get() const {
-    return current_number;
-}
-
-// This helper function provides a nicer UX when instantiating the generator
-// Notice that it returns an instance of GeneratorWrapper<int>, which
-// is a value-wrapper around std::unique_ptr<IGenerator<int>>.
-Catch::Generators::GeneratorWrapper<int> random(int low, int high) {
-    return Catch::Generators::GeneratorWrapper<int>(std::unique_ptr<Catch::Generators::IGenerator<int>>(new RandomIntGenerator(low, high)));
-}
-
-// The two sections in this test case are equivalent, but the first one
-// is much more readable/nicer to use
-TEST_CASE("Generating random ints", "[example][generator]") {
-    SECTION("Nice UX") {
-        auto i = GENERATE(take(100, random(-100, 100)));
-        REQUIRE(i >= -100);
-        REQUIRE(i <= 100);
-    }
-    SECTION("Creating the random generator directly") {
-        auto i = GENERATE(take(100, GeneratorWrapper<int>(std::unique_ptr<IGenerator<int>>(new RandomIntGenerator(-100, 100)))));
-        REQUIRE(i >= -100);
-        REQUIRE(i <= 100);
-    }
-}
-
-// Compiling and running this file will result in 400 successful assertions

examples/301-Gen-MapTypeConversion.cpp

@@ -1,54 +0,0 @@
-// 301-Gen-MapTypeConversion.cpp
-// Shows how to use map to modify generator's return type.
-
-// TODO
-
-#include <catch2/catch.hpp>
-
-#include <string>
-#include <sstream>
-
-// Returns a line from a stream. You could have it e.g. read lines from
-// a file, but to avoid problems with paths in examples, we will use
-// a fixed stringstream.
-class LineGenerator : public Catch::Generators::IGenerator<std::string> {
-    std::string m_line;
-    std::stringstream m_stream;
-public:
-    LineGenerator() {
-        m_stream.str("1\n2\n3\n4\n");
-        if (!next()) {
-            throw Catch::GeneratorException("Couldn't read a single line");
-        }
-    }
-
-    std::string const& get() const override {
-        return m_line;
-    }
-    
-    bool next() override {
-        return !!std::getline(m_stream, m_line);
-    }
-};
-
-// This helper function provides a nicer UX when instantiating the generator
-// Notice that it returns an instance of GeneratorWrapper<std::string>, which
-// is a value-wrapper around std::unique_ptr<IGenerator<std::string>>.
-Catch::Generators::GeneratorWrapper<std::string> lines(std::string /* ignored for example */) {
-    return Catch::Generators::GeneratorWrapper<std::string>(
-        std::unique_ptr<Catch::Generators::IGenerator<std::string>>(
-            new LineGenerator()
-        )
-    );
-}
-
-
-
-TEST_CASE("filter can convert types inside the generator expression", "[example][generator]") {
-    auto num = GENERATE(map<int>([](std::string const& line) { return std::stoi(line); },
-                                 lines("fake-file")));
-                                 
-    REQUIRE(num > 0);
-}
-
-// Compiling and running this file will result in 4 successful assertions

examples/310-Gen-VariablesInGenerators.cpp

@@ -1,33 +0,0 @@
-// 310-Gen-VariablesInGenerator.cpp
-// Shows how to use variables when creating generators.
-
-// Note that using variables inside generators is dangerous and should
-// be done only if you know what you are doing, because the generators
-// _WILL_ outlive the variables -- thus they should be either captured
-// by value directly, or copied by the generators during construction.
-
-#include <catch2/catch.hpp>
-
-TEST_CASE("Generate random doubles across different ranges",
-          "[generator][example][advanced]") {
-    // Workaround for old libstdc++
-    using record = std::tuple<double, double>;
-    // Set up 3 ranges to generate numbers from
-    auto r = GENERATE(table<double, double>({
-        record{3, 4},
-        record{-4, -3},
-        record{10, 1000}
-    }));
-
-    // This will not compile (intentionally), because it accesses a variable
-    // auto number = GENERATE(take(50, random(std::get<0>(r), std::get<1>(r))));
-
-   // GENERATE_COPY copies all variables mentioned inside the expression
-   // thus this will work.
-    auto number = GENERATE_COPY(take(50, random(std::get<0>(r), std::get<1>(r))));
-
-    REQUIRE(std::abs(number) > 0);
-}
-
-// Compiling and running this file will result in 150 successful assertions
-

examples/311-Gen-CustomCapture.cpp

@@ -1,41 +0,0 @@
-// 311-Gen-CustomCapture.cpp
-// Shows how to provide custom capture list to the generator expression
-
-// Note that using variables inside generators is dangerous and should
-// be done only if you know what you are doing, because the generators
-// _WILL_ outlive the variables. Also, even if you know what you are
-// doing, you should probably use GENERATE_COPY or GENERATE_REF macros
-// instead. However, if your use case requires having a
-// per-variable custom capture list, this example shows how to achieve
-// that.
-
-#include <catch2/catch.hpp>
-
-TEST_CASE("Generate random doubles across different ranges",
-          "[generator][example][advanced]") {
-    // Workaround for old libstdc++
-    using record = std::tuple<double, double>;
-    // Set up 3 ranges to generate numbers from
-    auto r1 = GENERATE(table<double, double>({
-        record{3, 4},
-        record{-4, -3},
-        record{10, 1000}
-    }));
-
-    auto r2(r1);
-    
-    // This will take r1 by reference and r2 by value.
-    // Note that there are no advantages for doing so in this example,
-    // it is done only for expository purposes.
-    auto number = Catch::Generators::generate( CATCH_INTERNAL_LINEINFO,
-        [&r1, r2]{
-            using namespace Catch::Generators;
-            return makeGenerators(take(50, random(std::get<0>(r1), std::get<1>(r2))));
-        }
-    );
-
-    REQUIRE(std::abs(number) > 0);
-}
-
-// Compiling and running this file will result in 150 successful assertions
-

examples/CMakeLists.txt

@@ -1,157 +0,0 @@
-#
-# Build examples.
-#
-# Requires CATCH_BUILD_EXAMPLES to be defined 'true', see ../CMakeLists.txt.
-#
-
-cmake_minimum_required( VERSION 3.0 )
-
-project( CatchExamples CXX )
-
-message( STATUS "Examples included" )
-
-# define folders used:
-
-set( EXAMPLES_DIR ${CATCH_DIR}/examples )
-set( HEADER_DIR   ${CATCH_DIR}/single_include )
-set( REPORTER_HEADER_DIR ${CATCH_DIR}/include/reporters )
-
-# single-file sources:
-
-set( SOURCES_SINGLE_FILE
-    010-TestCase.cpp
-    231-Cfg-OutputStreams.cpp
-)
-
-# multiple-file modules:
-
-set( SOURCES_020
-    020-TestCase-1.cpp
-    020-TestCase-2.cpp
-)
-
-# main for idiomatic test sources:
-
-set( SOURCES_IDIOMATIC_MAIN
-    000-CatchMain.cpp
-)
-
-# sources to combine with 000-CatchMain.cpp:
-
-set( SOURCES_IDIOMATIC_TESTS
-    030-Asn-Require-Check.cpp
-    100-Fix-Section.cpp
-    110-Fix-ClassFixture.cpp
-    120-Bdd-ScenarioGivenWhenThen.cpp
-    210-Evt-EventListeners.cpp
-    300-Gen-OwnGenerator.cpp
-    301-Gen-MapTypeConversion.cpp
-    310-Gen-VariablesInGenerators.cpp
-    311-Gen-CustomCapture.cpp
-)
-
-# main-s for reporter-specific test sources:
-
-set( SOURCES_REPORTERS_MAIN
-    200-Rpt-CatchMain.cpp
-)
-
-string( REPLACE ".cpp" "" BASENAMES_REPORTERS_MAIN 200-Rpt-CatchMain.cpp )
-
-set( NAMES_REPORTERS TeamCity )
-
-foreach( reporter ${NAMES_REPORTERS} )
-    list( APPEND SOURCES_SPECIFIC_REPORTERS_MAIN ${BASENAMES_REPORTERS_MAIN}${reporter}.cpp )
-endforeach()
-
-# sources to combine with 200-Rpt-CatchMain{Reporter}.cpp:
-
-set( SOURCES_REPORTERS_TESTS
-    207-Rpt-TeamCityReporter.cpp
-)
-
-# check if all sources are listed, warn if not:
-
-set( SOURCES_ALL
-    ${SOURCES_020}
-    ${SOURCES_SINGLE_FILE}
-    ${SOURCES_IDIOMATIC_MAIN}
-    ${SOURCES_IDIOMATIC_TESTS}
-    ${SOURCES_REPORTERS_MAIN}
-    ${SOURCES_REPORTERS_TESTS}
-)
-
-foreach( name ${SOURCES_ALL} )
-    list( APPEND SOURCES_ALL_PATH ${EXAMPLES_DIR}/${name} )
-endforeach()
-
-CheckFileList( SOURCES_ALL_PATH ${EXAMPLES_DIR} )
-
-# create target names:
-
-string( REPLACE ".cpp" "" BASENAMES_SINGLE_FILE     "${SOURCES_SINGLE_FILE}" )
-string( REPLACE ".cpp" "" BASENAMES_IDIOMATIC_TESTS "${SOURCES_IDIOMATIC_TESTS}" )
-string( REPLACE ".cpp" "" BASENAMES_REPORTERS_TESTS "${SOURCES_REPORTERS_TESTS}" )
-string( REPLACE ".cpp" "" BASENAMES_REPORTERS_MAIN  "${SOURCES_REPORTERS_MAIN}" )
-
-set( TARGETS_SINGLE_FILE     ${BASENAMES_SINGLE_FILE} )
-set( TARGETS_IDIOMATIC_TESTS ${BASENAMES_IDIOMATIC_TESTS} )
-set( TARGETS_REPORTERS_TESTS ${BASENAMES_REPORTERS_TESTS} )
-set( TARGETS_REPORTERS_MAIN  ${BASENAMES_REPORTERS_MAIN} )
-
-set( TARGETS_ALL
-    ${TARGETS_SINGLE_FILE}
-    020-TestCase
-    ${TARGETS_IDIOMATIC_TESTS} CatchMain
-    ${TARGETS_REPORTERS_TESTS} CatchMainTeamCity
-)
-
-# define program targets:
-
-add_library( CatchMain         OBJECT ${EXAMPLES_DIR}/${SOURCES_IDIOMATIC_MAIN} ${HEADER_DIR}/catch2/catch.hpp )
-#add_library( CatchMainAutomake OBJECT ${EXAMPLES_DIR}/200-Rpt-CatchMain.cpp ${HEADER_DIR}/catch2/catch.hpp )
-#add_library( CatchMainTap      OBJECT ${EXAMPLES_DIR}/200-Rpt-CatchMain.cpp ${HEADER_DIR}/catch2/catch.hpp )
-add_library( CatchMainTeamCity OBJECT ${EXAMPLES_DIR}/200-Rpt-CatchMain.cpp ${HEADER_DIR}/catch2/catch.hpp )
-
-#target_compile_definitions( CatchMainAutomake PRIVATE CATCH_EXAMPLE_RPT_1=\"include/reporters/catch_reporter_automake.hpp\" )
-#target_compile_definitions( CatchMainTap      PRIVATE CATCH_EXAMPLE_RPT_1=\"include/reporters/catch_reporter_tap.hpp\" )
-target_compile_definitions( CatchMainTeamCity PRIVATE CATCH_EXAMPLE_RPT_1=\"include/reporters/catch_reporter_teamcity.hpp\" )
-
-foreach( name ${TARGETS_SINGLE_FILE} )
-    add_executable( ${name} ${EXAMPLES_DIR}/${name}.cpp ${HEADER_DIR}/catch2/catch.hpp )
-endforeach()
-
-foreach( name ${TARGETS_IDIOMATIC_TESTS} )
-    add_executable( ${name} ${EXAMPLES_DIR}/${name}.cpp $<TARGET_OBJECTS:CatchMain> ${HEADER_DIR}/catch2/catch.hpp )
-endforeach()
-
-add_executable( 020-TestCase ${EXAMPLES_DIR}/020-TestCase-1.cpp ${EXAMPLES_DIR}/020-TestCase-2.cpp ${HEADER_DIR}/catch2/catch.hpp )
-
-#add_executable( 207-Rpt-AutomakeReporter ${EXAMPLES_DIR}/207-Rpt-AutomakeReporter.cpp $<TARGET_OBJECTS:CatchMainAutomake> ${HEADER_DIR}/catch2/catch.hpp )
-#add_executable( 207-Rpt-TapReporter      ${EXAMPLES_DIR}/207-Rpt-TapReporter.cpp      $<TARGET_OBJECTS:CatchMainTap>      ${HEADER_DIR}/catch2/catch.hpp )
-add_executable( 207-Rpt-TeamCityReporter ${EXAMPLES_DIR}/207-Rpt-TeamCityReporter.cpp $<TARGET_OBJECTS:CatchMainTeamCity> ${HEADER_DIR}/catch2/catch.hpp )
-
-#foreach( name ${TARGETS_REPORTERS_TESTS} )
-#    add_executable( ${name} ${EXAMPLES_DIR}/${name}.cpp $<TARGET_OBJECTS:CatchMain> ${HEADER_DIR}/catch2/catch.hpp )
-#endforeach()
-
-foreach( name ${TARGETS_ALL} )
-    target_include_directories( ${name} PRIVATE ${HEADER_DIR} ${CATCH_DIR} )
-
-    set_property(TARGET ${name} PROPERTY CXX_STANDARD 11)
-    set_property(TARGET ${name} PROPERTY CXX_EXTENSIONS OFF)
-
-    # Add desired warnings
-    if ( CMAKE_CXX_COMPILER_ID MATCHES "Clang|AppleClang|GNU" )
-        target_compile_options( ${name}  PRIVATE -Wall -Wextra -Wunreachable-code )
-    endif()
-    # Clang specific warning go here
-    if ( CMAKE_CXX_COMPILER_ID MATCHES "Clang" )
-        # Actually keep these
-        target_compile_options( ${name}  PRIVATE -Wweak-vtables -Wexit-time-destructors -Wglobal-constructors -Wmissing-noreturn )
-    endif()
-    if ( CMAKE_CXX_COMPILER_ID MATCHES "MSVC" )
-        target_compile_options( ${name}  PRIVATE /W4 /w44265 /WX )
-    endif()
-endforeach()
-

include/catch.hpp

@@ -9,10 +9,6 @@
 #ifndef TWOBLUECUBES_CATCH_HPP_INCLUDED
 #define TWOBLUECUBES_CATCH_HPP_INCLUDED
 
-#define CATCH_VERSION_MAJOR 2
-#define CATCH_VERSION_MINOR 7
-#define CATCH_VERSION_PATCH 2
-
 #ifdef __clang__
 #    pragma clang system_header
 #elif defined __GNUC__
@@ -23,24 +19,8 @@
 
 #if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)
 #  define CATCH_IMPL
-#  define CATCH_CONFIG_ALL_PARTS
 #endif
 
-// In the impl file, we want to have access to all parts of the headers
-// Can also be used to sanely support PCHs
-#if defined(CATCH_CONFIG_ALL_PARTS)
-#  define CATCH_CONFIG_EXTERNAL_INTERFACES
-#  if defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#    undef CATCH_CONFIG_DISABLE_MATCHERS
-#  endif
-#  if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
-#    define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
-#  endif
-#endif
-
-#if !defined(CATCH_CONFIG_IMPL_ONLY)
-#include "internal/catch_platform.h"
-
 #ifdef CATCH_IMPL
 #  ifndef CLARA_CONFIG_MAIN
 #    define CLARA_CONFIG_MAIN_NOT_DEFINED
@@ -48,23 +28,18 @@
 #  endif
 #endif
 
-#include "internal/catch_user_interfaces.h"
-#include "internal/catch_tag_alias_autoregistrar.h"
-#include "internal/catch_test_registry.h"
+#include "internal/catch_notimplemented_exception.h"
+#include "internal/catch_context.h"
+#include "internal/catch_test_registry.hpp"
 #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.h"
-#include "internal/catch_compiler_capabilities.h"
-#include "internal/catch_string_manip.h"
-
-#ifndef CATCH_CONFIG_DISABLE_MATCHERS
-#include "internal/catch_capture_matchers.h"
-#endif
 #include "internal/catch_generators.hpp"
-#include "internal/catch_generators_generic.hpp"
-#include "internal/catch_generators_specific.hpp"
+#include "internal/catch_interfaces_exception.h"
+#include "internal/catch_approx.hpp"
+#include "internal/catch_matchers_string.h"
+#include "internal/catch_matchers_vector.h"
+#include "internal/catch_compiler_capabilities.h"
+#include "internal/catch_interfaces_tag_alias_registry.h"
 
 // These files are included here so the single_include script doesn't put them
 // in the conditionally compiled sections
@@ -75,13 +50,30 @@
 #include "internal/catch_objc.hpp"
 #endif
 
-#ifdef CATCH_CONFIG_EXTERNAL_INTERFACES
-#include "internal/catch_external_interfaces.h"
+#ifdef CATCH_IMPL
+
+// !TBD: Move the leak detector code into a separate header
+#ifdef CATCH_CONFIG_WINDOWS_CRTDBG
+#include <crtdbg.h>
+class LeakDetector {
+public:
+    LeakDetector() {
+        int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
+        flag |= _CRTDBG_LEAK_CHECK_DF;
+        flag |= _CRTDBG_ALLOC_MEM_DF;
+        _CrtSetDbgFlag(flag);
+        _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
+        _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
+        // Change this to leaking allocation's number to break there
+        _CrtSetBreakAlloc(-1);
+    }
+};
+#else
+class LeakDetector {};
 #endif
 
-#endif // ! CATCH_CONFIG_IMPL_ONLY
+LeakDetector leakDetector;
 
-#ifdef CATCH_IMPL
 #include "internal/catch_impl.hpp"
 #endif
 
@@ -89,350 +81,184 @@
 #include "internal/catch_default_main.hpp"
 #endif
 
-#if !defined(CATCH_CONFIG_IMPL_ONLY)
 
 #ifdef CLARA_CONFIG_MAIN_NOT_DEFINED
 #  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
 
-#define CATCH_REQUIRE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define CATCH_REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+#if defined(CATCH_CONFIG_FAST_COMPILE)
+#define CATCH_REQUIRE( expr ) INTERNAL_CATCH_TEST_NO_TRY( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, expr )
+#define CATCH_REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST_NO_TRY( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, expr )
+#else
+#define CATCH_REQUIRE( expr ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, expr )
+#define CATCH_REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, expr  )
+#endif
 
-#define CATCH_REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+#define CATCH_REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, "", expr )
 #define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
-#define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
-#endif// CATCH_CONFIG_DISABLE_MATCHERS
-#define CATCH_REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+#define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
+#define CATCH_REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( "CATCH_REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, expr )
 
-#define CATCH_CHECK( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-#define CATCH_CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CATCH_CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+#define CATCH_CHECK( expr ) INTERNAL_CATCH_TEST( "CATCH_CHECK", Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CATCH_CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( "CATCH_CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, expr )
+#define CATCH_CHECKED_IF( expr ) INTERNAL_CATCH_IF( "CATCH_CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CATCH_CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CATCH_CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, expr )
 
-#define CATCH_CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CATCH_CHECK_THROWS( expr )  INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, "", expr )
 #define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define CATCH_CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#define CATCH_CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( "CATCH_CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, expr )
 
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
 #define CATCH_CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
 
+#if defined(CATCH_CONFIG_FAST_COMPILE)
+#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT_NO_TRY( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+#else
 #define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#endif
+
 
 #define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
 #define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( "CATCH_WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
-#define CATCH_CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CATCH_CAPTURE",__VA_ARGS__ )
+#define CATCH_SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
+#define CATCH_CAPTURE( msg ) INTERNAL_CATCH_INFO( "CATCH_CAPTURE", #msg " := " << Catch::toString(msg) )
+#define CATCH_SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( "CATCH_CAPTURE", #msg " := " << Catch::toString(msg) )
 
-#define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
-#define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
-#define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
-#define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
-#define CATCH_DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
-#define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-
-#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+    #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
+    #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
+    #define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+    #define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
+    #define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
+    #define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
+    #define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+    #define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
 #else
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+    #define CATCH_TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description )
+    #define CATCH_TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description )
+    #define CATCH_METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description )
+    #define CATCH_REGISTER_TEST_CASE( function, name, description ) INTERNAL_CATCH_REGISTER_TESTCASE( function, name, description )
+    #define CATCH_SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description )
+    #define CATCH_FAIL( msg ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, msg )
+    #define CATCH_FAIL_CHECK( msg ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, msg )
+    #define CATCH_SUCCEED( msg ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, msg )
 #endif
+#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" )
 
+#define CATCH_REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType )
+#define CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType )
 
-#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
-#define CATCH_STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__ ,      #__VA_ARGS__ );     CATCH_SUCCEED( #__VA_ARGS__ )
-#define CATCH_STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); CATCH_SUCCEED( #__VA_ARGS__ )
-#else
-#define CATCH_STATIC_REQUIRE( ... )       CATCH_REQUIRE( __VA_ARGS__ )
-#define CATCH_STATIC_REQUIRE_FALSE( ... ) CATCH_REQUIRE_FALSE( __VA_ARGS__ )
-#endif
-
+#define CATCH_GENERATE( expr) INTERNAL_CATCH_GENERATE( expr )
 
 // "BDD-style" convenience wrappers
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
 #define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ )
 #define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
-#define CATCH_GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
-#define CATCH_AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
-#define CATCH_WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
-#define CATCH_AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
-#define CATCH_THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
-#define CATCH_AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
+#else
+#define CATCH_SCENARIO( name, tags ) CATCH_TEST_CASE( "Scenario: " name, tags )
+#define CATCH_SCENARIO_METHOD( className, name, tags ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " name, tags )
+#endif
+#define CATCH_GIVEN( desc )    CATCH_SECTION( std::string( "Given: ") + desc, "" )
+#define CATCH_WHEN( desc )     CATCH_SECTION( std::string( " When: ") + desc, "" )
+#define CATCH_AND_WHEN( desc ) CATCH_SECTION( std::string( "  And: ") + desc, "" )
+#define CATCH_THEN( desc )     CATCH_SECTION( std::string( " Then: ") + desc, "" )
+#define CATCH_AND_THEN( desc ) CATCH_SECTION( std::string( "  And: ") + desc, "" )
 
 // If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
 #else
 
-#define REQUIRE( ... ) INTERNAL_CATCH_TEST( "REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__  )
-#define REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+#if defined(CATCH_CONFIG_FAST_COMPILE)
+#define REQUIRE( expr ) INTERNAL_CATCH_TEST_NO_TRY( "REQUIRE", Catch::ResultDisposition::Normal, expr )
+#define REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST_NO_TRY( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, expr )
 
-#define REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+#else
+#define REQUIRE( expr ) INTERNAL_CATCH_TEST( "REQUIRE", Catch::ResultDisposition::Normal, expr  )
+#define REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, expr )
+#endif
+
+#define REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS", Catch::ResultDisposition::Normal, "", expr )
 #define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
-#define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+#define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
+#define REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( "REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, expr )
 
-#define CHECK( ... ) INTERNAL_CATCH_TEST( "CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-#define CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+#define CHECK( expr ) INTERNAL_CATCH_TEST( "CHECK", Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( "CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, expr )
+#define CHECKED_IF( expr ) INTERNAL_CATCH_IF( "CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( "CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( "CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, expr )
 
-#define CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CHECK_THROWS( expr )  INTERNAL_CATCH_THROWS( "CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, "", expr )
 #define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#define CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( "CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, expr )
 
-
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
 #define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
 
+#if defined(CATCH_CONFIG_FAST_COMPILE)
+#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT_NO_TRY( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+#else
 #define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#endif
+
 
 #define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
-#define UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "UNSCOPED_INFO", msg )
 #define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
-#define CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CAPTURE",__VA_ARGS__ )
+#define SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
+#define CAPTURE( msg ) INTERNAL_CATCH_INFO( "CAPTURE", #msg " := " << Catch::toString(msg) )
+#define SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( "CAPTURE", #msg " := " << Catch::toString(msg) )
 
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
 #define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
 #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
 #define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
 #define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
 #define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
-#define DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
 #define FAIL( ... ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
 #define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
 #define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
 #else
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#define TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description )
+    #define TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description )
+    #define METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description )
+    #define REGISTER_TEST_CASE( method, name, description ) INTERNAL_CATCH_REGISTER_TESTCASE( method, name, description )
+    #define SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description )
+    #define FAIL( msg ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, msg )
+    #define FAIL_CHECK( msg ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, msg )
+    #define SUCCEED( msg ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, msg )
 #endif
+#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" )
 
+#define REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType )
+#define REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType )
 
-#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
-#define STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__,  #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )
-#define STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" )
-#else
-#define STATIC_REQUIRE( ... )       REQUIRE( __VA_ARGS__ )
-#define STATIC_REQUIRE_FALSE( ... ) REQUIRE_FALSE( __VA_ARGS__ )
-#endif
+#define GENERATE( expr) INTERNAL_CATCH_GENERATE( expr )
 
 #endif
 
 #define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
 
 // "BDD-style" convenience wrappers
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
 #define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
 #define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
-
-#define GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
-#define AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
-#define WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
-#define AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
-#define THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
-#define AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
+#else
+#define SCENARIO( name, tags ) TEST_CASE( "Scenario: " name, tags )
+#define SCENARIO_METHOD( className, name, tags ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " name, tags )
+#endif
+#define GIVEN( desc )    SECTION( std::string("   Given: ") + desc, "" )
+#define WHEN( desc )     SECTION( std::string("    When: ") + desc, "" )
+#define AND_WHEN( desc ) SECTION( std::string("And when: ") + desc, "" )
+#define THEN( desc )     SECTION( std::string("    Then: ") + desc, "" )
+#define AND_THEN( desc ) SECTION( std::string("     And: ") + desc, "" )
 
 using Catch::Detail::Approx;
 
-#else // CATCH_CONFIG_DISABLE
-
-//////
-// 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_DYNAMIC_SECTION( ... )
-#define CATCH_FAIL( ... ) (void)(0)
-#define CATCH_FAIL_CHECK( ... ) (void)(0)
-#define CATCH_SUCCEED( ... ) (void)(0)
-
-#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), className )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#else
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) ) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), className ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#endif
-
-// "BDD-style" convenience wrappers
-#define CATCH_SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
-#define CATCH_GIVEN( desc )
-#define CATCH_AND_GIVEN( desc )
-#define CATCH_WHEN( desc )
-#define CATCH_AND_WHEN( desc )
-#define CATCH_THEN( desc )
-#define CATCH_AND_THEN( desc )
-
-#define CATCH_STATIC_REQUIRE( ... )       (void)(0)
-#define CATCH_STATIC_REQUIRE_FALSE( ... ) (void)(0)
-
-// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
-#else
-
-#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 DYNAMIC_SECTION( ... )
-#define FAIL( ... ) (void)(0)
-#define FAIL_CHECK( ... ) (void)(0)
-#define SUCCEED( ... ) (void)(0)
-#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) )
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), className )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#else
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) ) )
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), className ) )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#endif
-
-#define STATIC_REQUIRE( ... )       (void)(0)
-#define STATIC_REQUIRE_FALSE( ... ) (void)(0)
-
-#endif
-
-#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
-
-// "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 AND_GIVEN( desc )
-#define WHEN( desc )
-#define AND_WHEN( desc )
-#define THEN( desc )
-#define AND_THEN( desc )
-
-using Catch::Detail::Approx;
-
-
-#endif
-
-#endif // ! CATCH_CONFIG_IMPL_ONLY
-
 #include "internal/catch_reenable_warnings.h"
 
 #endif // TWOBLUECUBES_CATCH_HPP_INCLUDED

include/catch_session.hpp

@@ -0,0 +1,272 @@
+/*
+ *  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_list.hpp"
+#include "internal/catch_run_context.hpp"
+#include "internal/catch_test_spec.hpp"
+#include "internal/catch_version.h"
+#include "internal/catch_text.h"
+
+#include <fstream>
+#include <stdlib.h>
+#include <limits>
+
+namespace Catch {
+
+    Ptr<IStreamingReporter> createReporter( std::string const& reporterName, Ptr<Config> const& config ) {
+        Ptr<IStreamingReporter> reporter = getRegistryHub().getReporterRegistry().create( reporterName, config.get() );
+        if( !reporter ) {
+            std::ostringstream oss;
+            oss << "No reporter registered with name: '" << reporterName << "'";
+            throw std::domain_error( oss.str() );
+        }
+        return reporter;
+    }
+
+#if !defined(CATCH_CONFIG_DEFAULT_REPORTER)
+#define CATCH_CONFIG_DEFAULT_REPORTER "console"
+#endif
+
+    Ptr<IStreamingReporter> makeReporter( Ptr<Config> const& config ) {
+        std::vector<std::string> reporters = config->getReporterNames();
+        if( reporters.empty() )
+            reporters.push_back( CATCH_CONFIG_DEFAULT_REPORTER );
+
+        Ptr<IStreamingReporter> reporter;
+        for( std::vector<std::string>::const_iterator it = reporters.begin(), itEnd = reporters.end();
+                it != itEnd;
+                ++it )
+            reporter = addReporter( reporter, createReporter( *it, config ) );
+        return reporter;
+    }
+    Ptr<IStreamingReporter> addListeners( Ptr<IConfig const> const& config, Ptr<IStreamingReporter> reporters ) {
+        IReporterRegistry::Listeners listeners = getRegistryHub().getReporterRegistry().getListeners();
+        for( IReporterRegistry::Listeners::const_iterator it = listeners.begin(), itEnd = listeners.end();
+                it != itEnd;
+                ++it )
+            reporters = addReporter(reporters, (*it)->create( ReporterConfig( config ) ) );
+        return reporters;
+    }
+
+
+    Totals runTests( Ptr<Config> const& config ) {
+
+        Ptr<IConfig const> iconfig = config.get();
+
+        Ptr<IStreamingReporter> reporter = makeReporter( config );
+        reporter = addListeners( iconfig, reporter );
+
+        RunContext context( iconfig, reporter );
+
+        Totals totals;
+
+        context.testGroupStarting( config->name(), 1, 1 );
+
+        TestSpec testSpec = config->testSpec();
+        if( !testSpec.hasFilters() )
+            testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "~[.]" ).testSpec(); // All not hidden tests
+
+        std::vector<TestCase> const& allTestCases = getAllTestCasesSorted( *iconfig );
+        for( std::vector<TestCase>::const_iterator it = allTestCases.begin(), itEnd = allTestCases.end();
+                it != itEnd;
+                ++it ) {
+            if( !context.aborting() && matchTest( *it, testSpec, *iconfig ) )
+                totals += context.runTest( *it );
+            else
+                reporter->skipTest( *it );
+        }
+
+        context.testGroupEnded( iconfig->name(), totals, 1, 1 );
+        return totals;
+    }
+
+    void applyFilenamesAsTags( IConfig const& config ) {
+        std::vector<TestCase> const& tests = getAllTestCasesSorted( config );
+        for(std::size_t i = 0; i < tests.size(); ++i ) {
+            TestCase& test = const_cast<TestCase&>( tests[i] );
+            std::set<std::string> tags = test.tags;
+
+            std::string filename = test.lineInfo.file;
+            std::string::size_type lastSlash = filename.find_last_of( "\\/" );
+            if( lastSlash != std::string::npos )
+                filename = filename.substr( lastSlash+1 );
+
+            std::string::size_type lastDot = filename.find_last_of( '.' );
+            if( lastDot != std::string::npos )
+                filename = filename.substr( 0, lastDot );
+
+            tags.insert( '#' + filename );
+            setTags( test, tags );
+        }
+    }
+
+    class Session : NonCopyable {
+        static bool alreadyInstantiated;
+
+    public:
+
+        struct OnUnusedOptions { enum DoWhat { Ignore, Fail }; };
+
+        Session()
+        : m_cli( makeCommandLineParser() ) {
+            if( alreadyInstantiated ) {
+                std::string msg = "Only one instance of Catch::Session can ever be used";
+                Catch::cerr() << msg << std::endl;
+                throw std::logic_error( msg );
+            }
+            alreadyInstantiated = true;
+        }
+        ~Session() {
+            Catch::cleanUp();
+        }
+
+        void showHelp( std::string const& processName ) {
+            Catch::cout() << "\nCatch v" << libraryVersion() << "\n";
+
+            m_cli.usage( Catch::cout(), processName );
+            Catch::cout() << "For more detail usage please see the project docs\n" << std::endl;
+        }
+        void libIdentify() {
+            Catch::cout()
+                    << std::left << std::setw(16) << "description: " << "A Catch test executable\n"
+                    << std::left << std::setw(16) << "category: " << "testframework\n"
+                    << std::left << std::setw(16) << "framework: " << "Catch Test\n"
+                    << std::left << std::setw(16) << "version: " << libraryVersion() << std::endl;
+        }
+
+        int applyCommandLine( int argc, char const* const* const argv, OnUnusedOptions::DoWhat unusedOptionBehaviour = OnUnusedOptions::Fail ) {
+            try {
+                m_cli.setThrowOnUnrecognisedTokens( unusedOptionBehaviour == OnUnusedOptions::Fail );
+                m_unusedTokens = m_cli.parseInto( Clara::argsToVector( argc, argv ), m_configData );
+                if( m_configData.showHelp )
+                    showHelp( m_configData.processName );
+                if( m_configData.libIdentify )
+                    libIdentify();
+                m_config.reset();
+            }
+            catch( std::exception& ex ) {
+                {
+                    Colour colourGuard( Colour::Red );
+                    Catch::cerr()
+                        << "\nError(s) in input:\n"
+                        << Text( ex.what(), TextAttributes().setIndent(2) )
+                        << "\n\n";
+                }
+                m_cli.usage( Catch::cout(), m_configData.processName );
+                return (std::numeric_limits<int>::max)();
+            }
+            return 0;
+        }
+
+        void useConfigData( ConfigData const& _configData ) {
+            m_configData = _configData;
+            m_config.reset();
+        }
+
+        int run( int argc, char const* const* const argv ) {
+
+            int returnCode = applyCommandLine( argc, argv );
+            if( returnCode == 0 )
+                returnCode = run();
+            return returnCode;
+        }
+
+    #if defined(WIN32) && defined(UNICODE)
+        int run( int argc, wchar_t const* const* const argv ) {
+
+            char **utf8Argv = new char *[ argc ];
+
+            for ( int i = 0; i < argc; ++i ) {
+                int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, NULL, 0, NULL, NULL );
+
+                utf8Argv[ i ] = new char[ bufSize ];
+
+                WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, NULL, NULL );
+            }
+
+            int returnCode = applyCommandLine( argc, utf8Argv );
+            if( returnCode == 0 )
+                returnCode = run();
+
+            for ( int i = 0; i < argc; ++i )
+                delete [] utf8Argv[ i ];
+
+            delete [] utf8Argv;
+
+            return returnCode;
+        }
+    #endif
+
+        int run() {
+            if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
+                Catch::cout() << "...waiting for enter/ return before starting" << std::endl;
+                static_cast<void>(std::getchar());
+            }
+            int exitCode = runInternal();
+            if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeExit ) != 0 ) {
+                Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode << std::endl;
+                static_cast<void>(std::getchar());
+            }
+            return exitCode;
+        }
+
+        Clara::CommandLine<ConfigData> const& cli() const {
+            return m_cli;
+        }
+        std::vector<Clara::Parser::Token> const& unusedTokens() const {
+            return m_unusedTokens;
+        }
+        ConfigData& configData() {
+            return m_configData;
+        }
+        Config& config() {
+            if( !m_config )
+                m_config = new Config( m_configData );
+            return *m_config;
+        }
+    private:
+
+        int runInternal() {
+            if( m_configData.showHelp || m_configData.libIdentify )
+                return 0;
+
+            try
+            {
+                config(); // Force config to be constructed
+
+                seedRng( *m_config );
+
+                if( m_configData.filenamesAsTags )
+                    applyFilenamesAsTags( *m_config );
+
+                // Handle list request
+                if( Option<std::size_t> listed = list( config() ) )
+                    return static_cast<int>( *listed );
+
+                return static_cast<int>( runTests( m_config ).assertions.failed );
+            }
+            catch( std::exception& ex ) {
+                Catch::cerr() << ex.what() << std::endl;
+                return (std::numeric_limits<int>::max)();
+            }
+        }
+
+        Clara::CommandLine<ConfigData> m_cli;
+        std::vector<Clara::Parser::Token> m_unusedTokens;
+        ConfigData m_configData;
+        Ptr<Config> m_config;
+    };
+
+    bool Session::alreadyInstantiated = false;
+
+} // end namespace Catch
+
+#endif // TWOBLUECUBES_CATCH_RUNNER_HPP_INCLUDED

include/external/tbc_text_format.h

@@ -0,0 +1,168 @@
+/*
+ *  Created by Phil on 18/4/2013.
+ *  Copyright 2013 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)
+ */
+// Only use header guard if we are not using an outer namespace
+#ifndef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+# ifdef TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED
+#  ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
+#   define TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
+#  endif
+# else
+#  define TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED
+# endif
+#endif
+#ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
+#include <string>
+#include <vector>
+#include <sstream>
+
+// Use optional outer namespace
+#ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+namespace CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE {
+#endif
+
+namespace Tbc {
+
+#ifdef TBC_TEXT_FORMAT_CONSOLE_WIDTH
+    const unsigned int consoleWidth = TBC_TEXT_FORMAT_CONSOLE_WIDTH;
+#else
+    const unsigned int consoleWidth = 80;
+#endif
+
+    struct TextAttributes {
+        TextAttributes()
+        :   initialIndent( std::string::npos ),
+            indent( 0 ),
+            width( consoleWidth-1 )
+        {}
+
+        TextAttributes& setInitialIndent( std::size_t _value )  { initialIndent = _value; return *this; }
+        TextAttributes& setIndent( std::size_t _value )         { indent = _value; return *this; }
+        TextAttributes& setWidth( std::size_t _value )          { width = _value; return *this; }
+
+        std::size_t initialIndent;  // indent of first line, or npos
+        std::size_t indent;         // indent of subsequent lines, or all if initialIndent is npos
+        std::size_t width;          // maximum width of text, including indent. Longer text will wrap
+    };
+
+    class Text {
+    public:
+        Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() )
+        : attr( _attr )
+        {
+            const std::string wrappableBeforeChars = "[({<\t";
+            const std::string wrappableAfterChars = "])}>-,./|\\";
+            const std::string wrappableInsteadOfChars = " \n\r";
+            std::string indent = _attr.initialIndent != std::string::npos
+                ? std::string( _attr.initialIndent, ' ' )
+                : std::string( _attr.indent, ' ' );
+
+            typedef std::string::const_iterator iterator;
+            iterator it = _str.begin();
+            const iterator strEnd = _str.end();
+
+            while( it != strEnd ) {
+
+                if( lines.size() >= 1000 ) {
+                    lines.push_back( "... message truncated due to excessive size" );
+                    return;
+                }
+
+
+                std::string suffix;
+                std::size_t width = (std::min)( static_cast<size_t>( strEnd-it ), _attr.width-static_cast<size_t>( indent.size() ) );
+                iterator itEnd = it+width;
+                iterator itNext = _str.end();
+
+                iterator itNewLine = std::find( it, itEnd, '\n' );
+                if( itNewLine != itEnd )
+                    itEnd = itNewLine;
+
+                if( itEnd != strEnd  ) {
+                    bool foundWrapPoint = false;
+                    iterator findIt = itEnd;
+                    do {
+                        if( wrappableAfterChars.find( *findIt ) != std::string::npos && findIt != itEnd ) {
+                            itEnd = findIt+1;
+                            itNext = findIt+1;
+                            foundWrapPoint = true;
+                        }
+                        else if( findIt > it && wrappableBeforeChars.find( *findIt ) != std::string::npos ) {
+                            itEnd = findIt;
+                            itNext = findIt;
+                            foundWrapPoint = true;
+                        }
+                        else if( wrappableInsteadOfChars.find( *findIt ) != std::string::npos ) {
+                            itNext = findIt+1;
+                            itEnd = findIt;
+                            foundWrapPoint = true;
+                        }
+                        if( findIt == it )
+                            break;
+                        else
+                            --findIt;
+                    }
+                    while( !foundWrapPoint );
+
+                    if( !foundWrapPoint ) {
+                        // No good wrap char, so we'll break mid word and add a hyphen
+                        --itEnd;
+                        itNext = itEnd;
+                        suffix = "-";
+                    }
+                    else {
+                        while( itEnd > it && wrappableInsteadOfChars.find( *(itEnd-1) ) != std::string::npos )
+                            --itEnd;
+                    }
+                }
+                lines.push_back( indent + std::string( it, itEnd ) + suffix );
+
+                if( indent.size() != _attr.indent )
+                    indent = std::string( _attr.indent, ' ' );
+                it = itNext;
+            }
+        }
+
+
+
+        typedef std::vector<std::string>::const_iterator const_iterator;
+
+        const_iterator begin() const { return lines.begin(); }
+        const_iterator end() const { return lines.end(); }
+        std::string const& last() const { return lines.back(); }
+        std::size_t size() const { return lines.size(); }
+        std::string const& operator[]( std::size_t _index ) const { return lines[_index]; }
+        std::string toString() const {
+            std::ostringstream oss;
+            oss << *this;
+            return oss.str();
+        }
+
+        inline friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) {
+            for( Text::const_iterator it = _text.begin(), itEnd = _text.end();
+                it != itEnd; ++it ) {
+                if( it != _text.begin() )
+                    _stream << "\n";
+                _stream << *it;
+            }
+            return _stream;
+        }
+
+
+    private:
+        std::string str;
+        TextAttributes attr;
+        std::vector<std::string> lines;
+    };
+
+} // end namespace Tbc
+
+#ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+} // end outer namespace
+#endif
+
+#endif // TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED

include/internal/catch_approx.cpp

@@ -1,87 +0,0 @@
-/*
- *  Created by Martin on 19/07/2017.
- *  Copyright 2017 Two Blue Cubes Ltd. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-
-#include "catch_approx.h"
-#include "catch_enforce.h"
-
-#include <cmath>
-#include <limits>
-
-namespace {
-
-// Performs equivalent check of std::fabs(lhs - rhs) <= margin
-// But without the subtraction to allow for INFINITY in comparison
-bool marginComparison(double lhs, double rhs, double margin) {
-    return (lhs + margin >= rhs) && (rhs + margin >= lhs);
-}
-
-}
-
-namespace Catch {
-namespace Detail {
-
-    Approx::Approx ( double value )
-    :   m_epsilon( std::numeric_limits<float>::epsilon()*100 ),
-        m_margin( 0.0 ),
-        m_scale( 0.0 ),
-        m_value( value )
-    {}
-
-    Approx Approx::custom() {
-        return Approx( 0 );
-    }
-
-    Approx Approx::operator-() const {
-        auto temp(*this);
-        temp.m_value = -temp.m_value;
-        return temp;
-    }
-
-
-    std::string Approx::toString() const {
-        ReusableStringStream rss;
-        rss << "Approx( " << ::Catch::Detail::stringify( m_value ) << " )";
-        return rss.str();
-    }
-
-    bool Approx::equalityComparisonImpl(const double other) const {
-        // First try with fixed margin, then compute margin based on epsilon, scale and Approx's value
-        // Thanks to Richard Harris for his help refining the scaled margin value
-        return marginComparison(m_value, other, m_margin) || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(m_value)));
-    }
-
-    void Approx::setMargin(double newMargin) {
-        CATCH_ENFORCE(newMargin >= 0,
-            "Invalid Approx::margin: " << newMargin << '.'
-            << " Approx::Margin has to be non-negative.");
-        m_margin = newMargin;
-    }
-
-    void Approx::setEpsilon(double newEpsilon) {
-        CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0,
-            "Invalid Approx::epsilon: " << newEpsilon << '.'
-            << " Approx::epsilon has to be in [0, 1]");
-        m_epsilon = newEpsilon;
-    }
-
-} // end namespace Detail
-
-namespace literals {
-    Detail::Approx operator "" _a(long double val) {
-        return Detail::Approx(val);
-    }
-    Detail::Approx operator "" _a(unsigned long long val) {
-        return Detail::Approx(val);
-    }
-} // end namespace literals
-
-std::string StringMaker<Catch::Detail::Approx>::convert(Catch::Detail::Approx const& value) {
-    return value.toString();
-}
-
-} // end namespace Catch

include/internal/catch_approx.h

@@ -1,132 +0,0 @@
-/*
- *  Created by Phil on 28/04/2011.
- *  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_APPROX_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_APPROX_HPP_INCLUDED
-
-#include "catch_tostring.h"
-
-#include <type_traits>
-
-namespace Catch {
-namespace Detail {
-
-    class Approx {
-    private:
-        bool equalityComparisonImpl(double other) const;
-        // Validates the new margin (margin >= 0)
-        // out-of-line to avoid including stdexcept in the header
-        void setMargin(double margin);
-        // Validates the new epsilon (0 < epsilon < 1)
-        // out-of-line to avoid including stdexcept in the header
-        void setEpsilon(double epsilon);
-
-    public:
-        explicit Approx ( double value );
-
-        static Approx custom();
-
-        Approx operator-() const;
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx operator()( T const& value ) {
-            Approx approx( static_cast<double>(value) );
-            approx.m_epsilon = m_epsilon;
-            approx.m_margin = m_margin;
-            approx.m_scale = m_scale;
-            return approx;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        explicit Approx( T const& value ): Approx(static_cast<double>(value))
-        {}
-
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator == ( const T& lhs, Approx const& rhs ) {
-            auto lhs_v = static_cast<double>(lhs);
-            return rhs.equalityComparisonImpl(lhs_v);
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator == ( Approx const& lhs, const T& rhs ) {
-            return operator==( rhs, lhs );
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator != ( T const& lhs, Approx const& rhs ) {
-            return !operator==( lhs, rhs );
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator != ( Approx const& lhs, T const& rhs ) {
-            return !operator==( rhs, lhs );
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator <= ( T const& lhs, Approx const& rhs ) {
-            return static_cast<double>(lhs) < rhs.m_value || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator <= ( Approx const& lhs, T const& rhs ) {
-            return lhs.m_value < static_cast<double>(rhs) || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator >= ( T const& lhs, Approx const& rhs ) {
-            return static_cast<double>(lhs) > rhs.m_value || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator >= ( Approx const& lhs, T const& rhs ) {
-            return lhs.m_value > static_cast<double>(rhs) || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx& epsilon( T const& newEpsilon ) {
-            double epsilonAsDouble = static_cast<double>(newEpsilon);
-            setEpsilon(epsilonAsDouble);
-            return *this;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx& margin( T const& newMargin ) {
-            double marginAsDouble = static_cast<double>(newMargin);
-            setMargin(marginAsDouble);
-            return *this;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx& scale( T const& newScale ) {
-            m_scale = static_cast<double>(newScale);
-            return *this;
-        }
-
-        std::string toString() const;
-
-    private:
-        double m_epsilon;
-        double m_margin;
-        double m_scale;
-        double m_value;
-    };
-} // end namespace Detail
-
-namespace literals {
-    Detail::Approx operator "" _a(long double val);
-    Detail::Approx operator "" _a(unsigned long long val);
-} // end namespace literals
-
-template<>
-struct StringMaker<Catch::Detail::Approx> {
-    static std::string convert(Catch::Detail::Approx const& value);
-};
-
-} // end namespace Catch
-
-#endif // TWOBLUECUBES_CATCH_APPROX_HPP_INCLUDED

include/internal/catch_approx.hpp

@@ -0,0 +1,202 @@
+/*
+ *  Created by Phil on 28/04/2011.
+ *  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_APPROX_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_APPROX_HPP_INCLUDED
+
+#include "catch_tostring.h"
+
+#include <cmath>
+#include <limits>
+
+#if defined(CATCH_CONFIG_CPP11_TYPE_TRAITS)
+#include <type_traits>
+#endif
+
+namespace Catch {
+namespace Detail {
+
+    class Approx {
+    public:
+        explicit Approx ( double value )
+        :   m_epsilon( std::numeric_limits<float>::epsilon()*100 ),
+            m_margin( 0.0 ),
+            m_scale( 1.0 ),
+            m_value( value )
+        {}
+
+        static Approx custom() {
+            return Approx( 0 );
+        }
+
+#if defined(CATCH_CONFIG_CPP11_TYPE_TRAITS)
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx operator()( T value ) {
+            Approx approx( static_cast<double>(value) );
+            approx.epsilon( m_epsilon );
+            approx.margin( m_margin );
+            approx.scale( m_scale );
+            return approx;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        explicit Approx( T value ): Approx(static_cast<double>(value))
+        {}
+
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator == ( const T& lhs, Approx const& rhs ) {
+            // Thanks to Richard Harris for his help refining this formula
+            auto lhs_v = double(lhs);
+            bool relativeOK = std::fabs(lhs_v - rhs.m_value) < rhs.m_epsilon * (rhs.m_scale + (std::max)(std::fabs(lhs_v), std::fabs(rhs.m_value)));
+            if (relativeOK) {
+                return true;
+            }
+
+            return std::fabs(lhs_v - rhs.m_value) <= rhs.m_margin;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator == ( Approx const& lhs, const T& rhs ) {
+            return operator==( rhs, lhs );
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator != ( T lhs, Approx const& rhs ) {
+            return !operator==( lhs, rhs );
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator != ( Approx const& lhs, T rhs ) {
+            return !operator==( rhs, lhs );
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator <= ( T lhs, Approx const& rhs ) {
+            return double(lhs) < rhs.m_value || lhs == rhs;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator <= ( Approx const& lhs, T rhs ) {
+            return lhs.m_value < double(rhs) || lhs == rhs;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator >= ( T lhs, Approx const& rhs ) {
+            return double(lhs) > rhs.m_value || lhs == rhs;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator >= ( Approx const& lhs, T rhs ) {
+            return lhs.m_value > double(rhs) || lhs == rhs;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx& epsilon( T newEpsilon ) {
+            m_epsilon = double(newEpsilon);
+            return *this;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx& margin( T newMargin ) {
+            m_margin = double(newMargin);
+            return *this;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx& scale( T newScale ) {
+            m_scale = double(newScale);
+            return *this;
+        }
+
+#else
+
+        Approx operator()( double value ) {
+            Approx approx( value );
+            approx.epsilon( m_epsilon );
+            approx.margin( m_margin );
+            approx.scale( m_scale );
+            return approx;
+        }
+
+
+        friend bool operator == ( double lhs, Approx const& rhs ) {
+            // Thanks to Richard Harris for his help refining this formula
+            bool relativeOK = std::fabs( lhs - rhs.m_value ) < rhs.m_epsilon * (rhs.m_scale + (std::max)( std::fabs(lhs), std::fabs(rhs.m_value) ) );
+            if (relativeOK) {
+                return true;
+            }
+            return std::fabs(lhs - rhs.m_value) <= rhs.m_margin;
+        }
+
+        friend bool operator == ( Approx const& lhs, double rhs ) {
+            return operator==( rhs, lhs );
+        }
+
+        friend bool operator != ( double lhs, Approx const& rhs ) {
+            return !operator==( lhs, rhs );
+        }
+
+        friend bool operator != ( Approx const& lhs, double rhs ) {
+            return !operator==( rhs, lhs );
+        }
+
+        friend bool operator <= ( double lhs, Approx const& rhs ) {
+            return lhs < rhs.m_value || lhs == rhs;
+        }
+
+        friend bool operator <= ( Approx const& lhs, double rhs ) {
+            return lhs.m_value < rhs || lhs == rhs;
+        }
+
+        friend bool operator >= ( double lhs, Approx const& rhs ) {
+            return lhs > rhs.m_value || lhs == rhs;
+        }
+
+        friend bool operator >= ( Approx const& lhs, double rhs ) {
+            return lhs.m_value > rhs || lhs == rhs;
+        }
+
+        Approx& epsilon( double newEpsilon ) {
+            m_epsilon = newEpsilon;
+            return *this;
+        }
+
+        Approx& margin( double newMargin ) {
+            m_margin = newMargin;
+            return *this;
+        }
+
+        Approx& scale( double newScale ) {
+            m_scale = newScale;
+            return *this;
+        }
+#endif
+
+        std::string toString() const {
+            std::ostringstream oss;
+            oss << "Approx( " << Catch::toString( m_value ) << " )";
+            return oss.str();
+        }
+
+    private:
+        double m_epsilon;
+        double m_margin;
+        double m_scale;
+        double m_value;
+    };
+}
+
+template<>
+inline std::string toString<Detail::Approx>( Detail::Approx const& value ) {
+    return value.toString();
+}
+
+} // end namespace Catch
+
+#endif // TWOBLUECUBES_CATCH_APPROX_HPP_INCLUDED

include/internal/catch_assertionhandler.cpp

@@ -1,121 +0,0 @@
-/*
- *  Created by Phil on 8/8/2017.
- *  Copyright 2017 Two Blue Cubes Ltd. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-
-#include "catch_assertionhandler.h"
-#include "catch_assertionresult.h"
-#include "catch_interfaces_runner.h"
-#include "catch_interfaces_config.h"
-#include "catch_context.h"
-#include "catch_debugger.h"
-#include "catch_interfaces_registry_hub.h"
-#include "catch_capture_matchers.h"
-#include "catch_run_context.h"
-
-namespace Catch {
-
-    namespace {
-        auto operator <<( std::ostream& os, ITransientExpression const& expr ) -> std::ostream& {
-            expr.streamReconstructedExpression( os );
-            return os;
-        }
-    }
-
-    LazyExpression::LazyExpression( bool isNegated )
-    :   m_isNegated( isNegated )
-    {}
-
-    LazyExpression::LazyExpression( LazyExpression const& other ) : m_isNegated( other.m_isNegated ) {}
-
-    LazyExpression::operator bool() const {
-        return m_transientExpression != nullptr;
-    }
-
-    auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream& {
-        if( lazyExpr.m_isNegated )
-            os << "!";
-
-        if( lazyExpr ) {
-            if( lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression() )
-                os << "(" << *lazyExpr.m_transientExpression << ")";
-            else
-                os << *lazyExpr.m_transientExpression;
-        }
-        else {
-            os << "{** error - unchecked empty expression requested **}";
-        }
-        return os;
-    }
-
-    AssertionHandler::AssertionHandler
-        (   StringRef const& macroName,
-            SourceLineInfo const& lineInfo,
-            StringRef capturedExpression,
-            ResultDisposition::Flags resultDisposition )
-    :   m_assertionInfo{ macroName, lineInfo, capturedExpression, resultDisposition },
-        m_resultCapture( getResultCapture() )
-    {}
-
-    void AssertionHandler::handleExpr( ITransientExpression const& expr ) {
-        m_resultCapture.handleExpr( m_assertionInfo, expr, m_reaction );
-    }
-    void AssertionHandler::handleMessage(ResultWas::OfType resultType, StringRef const& message) {
-        m_resultCapture.handleMessage( m_assertionInfo, resultType, message, m_reaction );
-    }
-
-    auto AssertionHandler::allowThrows() const -> bool {
-        return getCurrentContext().getConfig()->allowThrows();
-    }
-
-    void AssertionHandler::complete() {
-        setCompleted();
-        if( m_reaction.shouldDebugBreak ) {
-
-            // If you find your debugger stopping you here then go one level up on the
-            // call-stack for the code that caused it (typically a failed assertion)
-
-            // (To go back to the test and change execution, jump over the throw, next)
-            CATCH_BREAK_INTO_DEBUGGER();
-        }
-        if (m_reaction.shouldThrow) {
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-            throw Catch::TestFailureException();
-#else
-            CATCH_ERROR( "Test failure requires aborting test!" );
-#endif
-        }
-    }
-    void AssertionHandler::setCompleted() {
-        m_completed = true;
-    }
-
-    void AssertionHandler::handleUnexpectedInflightException() {
-        m_resultCapture.handleUnexpectedInflightException( m_assertionInfo, Catch::translateActiveException(), m_reaction );
-    }
-
-    void AssertionHandler::handleExceptionThrownAsExpected() {
-        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
-    }
-    void AssertionHandler::handleExceptionNotThrownAsExpected() {
-        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
-    }
-
-    void AssertionHandler::handleUnexpectedExceptionNotThrown() {
-        m_resultCapture.handleUnexpectedExceptionNotThrown( m_assertionInfo, m_reaction );
-    }
-
-    void AssertionHandler::handleThrowingCallSkipped() {
-        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
-    }
-
-    // This is the overload that takes a string and infers the Equals matcher from it
-    // The more general overload, that takes any string matcher, is in catch_capture_matchers.cpp
-    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString  ) {
-        handleExceptionMatchExpr( handler, Matchers::Equals( str ), matcherString );
-    }
-
-} // namespace Catch

include/internal/catch_assertionhandler.h

@@ -1,88 +0,0 @@
-/*
- *  Created by Phil on 8/8/2017.
- *  Copyright 2017 Two Blue Cubes Ltd. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef TWOBLUECUBES_CATCH_ASSERTIONHANDLER_H_INCLUDED
-#define TWOBLUECUBES_CATCH_ASSERTIONHANDLER_H_INCLUDED
-
-#include "catch_assertioninfo.h"
-#include "catch_decomposer.h"
-#include "catch_interfaces_capture.h"
-
-namespace Catch {
-
-    struct TestFailureException{};
-    struct AssertionResultData;
-    struct IResultCapture;
-    class RunContext;
-
-    class LazyExpression {
-        friend class AssertionHandler;
-        friend struct AssertionStats;
-        friend class RunContext;
-
-        ITransientExpression const* m_transientExpression = nullptr;
-        bool m_isNegated;
-    public:
-        LazyExpression( bool isNegated );
-        LazyExpression( LazyExpression const& other );
-        LazyExpression& operator = ( LazyExpression const& ) = delete;
-
-        explicit operator bool() const;
-
-        friend auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream&;
-    };
-
-    struct AssertionReaction {
-        bool shouldDebugBreak = false;
-        bool shouldThrow = false;
-    };
-
-    class AssertionHandler {
-        AssertionInfo m_assertionInfo;
-        AssertionReaction m_reaction;
-        bool m_completed = false;
-        IResultCapture& m_resultCapture;
-
-    public:
-        AssertionHandler
-            (   StringRef const& macroName,
-                SourceLineInfo const& lineInfo,
-                StringRef capturedExpression,
-                ResultDisposition::Flags resultDisposition );
-        ~AssertionHandler() {
-            if ( !m_completed ) {
-                m_resultCapture.handleIncomplete( m_assertionInfo );
-            }
-        }
-
-
-        template<typename T>
-        void handleExpr( ExprLhs<T> const& expr ) {
-            handleExpr( expr.makeUnaryExpr() );
-        }
-        void handleExpr( ITransientExpression const& expr );
-
-        void handleMessage(ResultWas::OfType resultType, StringRef const& message);
-
-        void handleExceptionThrownAsExpected();
-        void handleUnexpectedExceptionNotThrown();
-        void handleExceptionNotThrownAsExpected();
-        void handleThrowingCallSkipped();
-        void handleUnexpectedInflightException();
-
-        void complete();
-        void setCompleted();
-
-        // query
-        auto allowThrows() const -> bool;
-    };
-
-    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString );
-
-} // namespace Catch
-
-#endif // TWOBLUECUBES_CATCH_ASSERTIONHANDLER_H_INCLUDED

include/internal/catch_assertioninfo.h

@@ -1,31 +0,0 @@
-/*
- *  Created by Phil on 8/8/2017.
- *  Copyright 2017 Two Blue Cubes Ltd. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef TWOBLUECUBES_CATCH_ASSERTIONINFO_H_INCLUDED
-#define TWOBLUECUBES_CATCH_ASSERTIONINFO_H_INCLUDED
-
-#include "catch_result_type.h"
-#include "catch_common.h"
-#include "catch_stringref.h"
-
-namespace Catch {
-
-    struct AssertionInfo
-    {
-        StringRef macroName;
-        SourceLineInfo lineInfo;
-        StringRef capturedExpression;
-        ResultDisposition::Flags resultDisposition;
-
-        // We want to delete this constructor but a compiler bug in 4.8 means
-        // the struct is then treated as non-aggregate
-        //AssertionInfo() = delete;
-    };
-
-} // end namespace Catch
-
-#endif // TWOBLUECUBES_CATCH_ASSERTIONINFO_H_INCLUDED

include/internal/catch_assertionresult.cpp

@@ -1,98 +0,0 @@
-/*
- *  Created by Phil on 8/8/12
- *  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_assertionresult.h"
-
-namespace Catch {
-    AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const & _lazyExpression):
-        lazyExpression(_lazyExpression),
-        resultType(_resultType) {}
-
-    std::string AssertionResultData::reconstructExpression() const {
-
-        if( reconstructedExpression.empty() ) {
-            if( lazyExpression ) {
-                ReusableStringStream rss;
-                rss << lazyExpression;
-                reconstructedExpression = rss.str();
-            }
-        }
-        return reconstructedExpression;
-    }
-
-    AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
-    :   m_info( info ),
-        m_resultData( data )
-    {}
-
-    // Result was a success
-    bool AssertionResult::succeeded() const {
-        return Catch::isOk( m_resultData.resultType );
-    }
-
-    // Result was a success, or failure is suppressed
-    bool AssertionResult::isOk() const {
-        return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
-    }
-
-    ResultWas::OfType AssertionResult::getResultType() const {
-        return m_resultData.resultType;
-    }
-
-    bool AssertionResult::hasExpression() const {
-        return m_info.capturedExpression[0] != 0;
-    }
-
-    bool AssertionResult::hasMessage() const {
-        return !m_resultData.message.empty();
-    }
-
-    std::string AssertionResult::getExpression() const {
-        if( isFalseTest( m_info.resultDisposition ) )
-            return "!(" + m_info.capturedExpression + ")";
-        else
-            return m_info.capturedExpression;
-    }
-
-    std::string AssertionResult::getExpressionInMacro() const {
-        std::string expr;
-        if( m_info.macroName[0] == 0 )
-            expr = m_info.capturedExpression;
-        else {
-            expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
-            expr += m_info.macroName;
-            expr += "( ";
-            expr += m_info.capturedExpression;
-            expr += " )";
-        }
-        return expr;
-    }
-
-    bool AssertionResult::hasExpandedExpression() const {
-        return hasExpression() && getExpandedExpression() != getExpression();
-    }
-
-    std::string AssertionResult::getExpandedExpression() const {
-        std::string expr = m_resultData.reconstructExpression();
-        return expr.empty()
-                ? getExpression()
-                : expr;
-    }
-
-    std::string AssertionResult::getMessage() const {
-        return m_resultData.message;
-    }
-    SourceLineInfo AssertionResult::getSourceInfo() const {
-        return m_info.lineInfo;
-    }
-
-    StringRef AssertionResult::getTestMacroName() const {
-        return m_info.macroName;
-    }
-
-} // end namespace Catch

include/internal/catch_assertionresult.h

@@ -9,32 +9,100 @@
 #define TWOBLUECUBES_CATCH_ASSERTIONRESULT_H_INCLUDED
 
 #include <string>
-#include "catch_assertioninfo.h"
 #include "catch_result_type.h"
-#include "catch_common.h"
-#include "catch_stringref.h"
-#include "catch_assertionhandler.h"
 
 namespace Catch {
 
+    struct STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison;
+
+    struct DecomposedExpression
+    {
+        virtual ~DecomposedExpression() {}
+        virtual bool isBinaryExpression() const {
+            return false;
+        }
+        virtual void reconstructExpression( std::string& dest ) const = 0;
+
+        // Only simple binary comparisons can be decomposed.
+        // If more complex check is required then wrap sub-expressions in parentheses.
+        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator + ( T const& );
+        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator - ( T const& );
+        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator * ( T const& );
+        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator / ( T const& );
+        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator % ( T const& );
+        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator && ( T const& );
+        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator || ( T const& );
+
+    private:
+        DecomposedExpression& operator = (DecomposedExpression const&);
+    };
+
+    struct AssertionInfo
+    {
+        AssertionInfo();
+        AssertionInfo(  char const * _macroName,
+                        SourceLineInfo const& _lineInfo,
+                        char const * _capturedExpression,
+                        ResultDisposition::Flags _resultDisposition,
+                        char const * _secondArg = "");
+
+        char const * macroName;
+        SourceLineInfo lineInfo;
+        char const * capturedExpression;
+        ResultDisposition::Flags resultDisposition;
+        char const * secondArg;
+    };
+
     struct AssertionResultData
     {
-        AssertionResultData() = delete;
+        AssertionResultData() : decomposedExpression( CATCH_NULL )
+                              , resultType( ResultWas::Unknown )
+                              , negated( false )
+                              , parenthesized( false ) {}
 
-        AssertionResultData( ResultWas::OfType _resultType, LazyExpression const& _lazyExpression );
+        void negate( bool parenthesize ) {
+            negated = !negated;
+            parenthesized = parenthesize;
+            if( resultType == ResultWas::Ok )
+                resultType = ResultWas::ExpressionFailed;
+            else if( resultType == ResultWas::ExpressionFailed )
+                resultType = ResultWas::Ok;
+        }
 
-        std::string message;
+        std::string const& reconstructExpression() const {
+            if( decomposedExpression != CATCH_NULL ) {
+                decomposedExpression->reconstructExpression( reconstructedExpression );
+                if( parenthesized ) {
+                    reconstructedExpression.insert( 0, 1, '(' );
+                    reconstructedExpression.append( 1, ')' );
+                }
+                if( negated ) {
+                    reconstructedExpression.insert( 0, 1, '!' );
+                }
+                decomposedExpression = CATCH_NULL;
+            }
+            return reconstructedExpression;
+        }
+
+        mutable DecomposedExpression const* decomposedExpression;
         mutable std::string reconstructedExpression;
-        LazyExpression lazyExpression;
+        std::string message;
         ResultWas::OfType resultType;
-
-        std::string reconstructExpression() const;
+        bool negated;
+        bool parenthesized;
     };
 
     class AssertionResult {
     public:
-        AssertionResult() = delete;
+        AssertionResult();
         AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
+        ~AssertionResult();
+#  ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
+         AssertionResult( AssertionResult const& )              = default;
+         AssertionResult( AssertionResult && )                  = default;
+         AssertionResult& operator = ( AssertionResult const& ) = default;
+         AssertionResult& operator = ( AssertionResult && )     = default;
+#  endif
 
         bool isOk() const;
         bool succeeded() const;
@@ -47,9 +115,11 @@ namespace Catch {
         std::string getExpandedExpression() const;
         std::string getMessage() const;
         SourceLineInfo getSourceInfo() const;
-        StringRef getTestMacroName() const;
+        std::string getTestMacroName() const;
+        void discardDecomposedExpression() const;
+        void expandDecomposedExpression() const;
 
-    //protected:
+    protected:
         AssertionInfo m_info;
         AssertionResultData m_resultData;
     };

include/internal/catch_assertionresult.hpp

@@ -0,0 +1,109 @@
+/*
+ *  Created by Phil on 8/8/12
+ *  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_ASSERTIONRESULT_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_HPP_INCLUDED
+
+#include "catch_assertionresult.h"
+
+namespace Catch {
+
+
+    AssertionInfo::AssertionInfo():macroName(""), capturedExpression(""), resultDisposition(ResultDisposition::Normal), secondArg(""){}
+
+    AssertionInfo::AssertionInfo(   char const * _macroName,
+                                    SourceLineInfo const& _lineInfo,
+                                    char const * _capturedExpression,
+                                    ResultDisposition::Flags _resultDisposition,
+                                    char const * _secondArg)
+    :   macroName( _macroName ),
+        lineInfo( _lineInfo ),
+        capturedExpression( _capturedExpression ),
+        resultDisposition( _resultDisposition ),
+        secondArg( _secondArg )
+    {}
+
+    AssertionResult::AssertionResult() {}
+
+    AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
+    :   m_info( info ),
+        m_resultData( data )
+    {}
+
+    AssertionResult::~AssertionResult() {}
+
+    // Result was a success
+    bool AssertionResult::succeeded() const {
+        return Catch::isOk( m_resultData.resultType );
+    }
+
+    // Result was a success, or failure is suppressed
+    bool AssertionResult::isOk() const {
+        return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
+    }
+
+    ResultWas::OfType AssertionResult::getResultType() const {
+        return m_resultData.resultType;
+    }
+
+    bool AssertionResult::hasExpression() const {
+        return m_info.capturedExpression[0] != 0;
+    }
+
+    bool AssertionResult::hasMessage() const {
+        return !m_resultData.message.empty();
+    }
+
+    std::string capturedExpressionWithSecondArgument( char const * capturedExpression, char const * secondArg ) {
+        return (secondArg[0] == 0 || secondArg[0] == '"' && secondArg[1] == '"')
+            ? capturedExpression
+            : std::string(capturedExpression) + ", " + secondArg;
+    }
+
+    std::string AssertionResult::getExpression() const {
+        if( isFalseTest( m_info.resultDisposition ) )
+            return "!(" + capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg) + ")";
+        else
+            return capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg);
+    }
+    std::string AssertionResult::getExpressionInMacro() const {
+        if( m_info.macroName[0] == 0 )
+            return capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg);
+        else
+            return std::string(m_info.macroName) + "( " + capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg) + " )";
+    }
+
+    bool AssertionResult::hasExpandedExpression() const {
+        return hasExpression() && getExpandedExpression() != getExpression();
+    }
+
+    std::string AssertionResult::getExpandedExpression() const {
+        return m_resultData.reconstructExpression();
+    }
+
+    std::string AssertionResult::getMessage() const {
+        return m_resultData.message;
+    }
+    SourceLineInfo AssertionResult::getSourceInfo() const {
+        return m_info.lineInfo;
+    }
+
+    std::string AssertionResult::getTestMacroName() const {
+        return m_info.macroName;
+    }
+
+    void AssertionResult::discardDecomposedExpression() const {
+        m_resultData.decomposedExpression = CATCH_NULL;
+    }
+
+    void AssertionResult::expandDecomposedExpression() const {
+        m_resultData.reconstructExpression();
+    }
+
+} // end namespace Catch
+
+#endif // TWOBLUECUBES_CATCH_ASSERTIONRESULT_HPP_INCLUDED

include/internal/catch_benchmark.cpp

@@ -1,36 +0,0 @@
-/*
- *  Created by Phil on 04/07/2017.
- *  Copyright 2017 Two Blue Cubes Ltd. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-
-#include "catch_benchmark.h"
-#include "catch_capture.hpp"
-#include "catch_interfaces_reporter.h"
-#include "catch_context.h"
-
-namespace Catch {
-
-    auto BenchmarkLooper::getResolution() -> uint64_t {
-        return getEstimatedClockResolution() * getCurrentContext().getConfig()->benchmarkResolutionMultiple();
-    }
-
-    void BenchmarkLooper::reportStart() {
-        getResultCapture().benchmarkStarting( { m_name } );
-    }
-    auto BenchmarkLooper::needsMoreIterations() -> bool {
-        auto elapsed = m_timer.getElapsedNanoseconds();
-
-        // Exponentially increasing iterations until we're confident in our timer resolution
-        if( elapsed < m_resolution ) {
-            m_iterationsToRun *= 10;
-            return true;
-        }
-
-        getResultCapture().benchmarkEnded( { { m_name }, m_count, elapsed } );
-        return false;
-    }
-
-} // end namespace Catch

include/internal/catch_benchmark.h

@@ -1,57 +0,0 @@
-/*
- *  Created by Phil on 04/07/2017.
- *  Copyright 2017 Two Blue Cubes Ltd. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef TWOBLUECUBES_CATCH_BENCHMARK_H_INCLUDED
-#define TWOBLUECUBES_CATCH_BENCHMARK_H_INCLUDED
-
-#include "catch_stringref.h"
-#include "catch_timer.h"
-
-#include <cstdint>
-#include <string>
-
-namespace Catch {
-
-    class BenchmarkLooper {
-
-        std::string m_name;
-        std::size_t m_count = 0;
-        std::size_t m_iterationsToRun = 1;
-        uint64_t m_resolution;
-        Timer m_timer;
-
-        static auto getResolution() -> uint64_t;
-    public:
-        // Keep most of this inline as it's on the code path that is being timed
-        BenchmarkLooper( StringRef name )
-        :   m_name( name ),
-            m_resolution( getResolution() )
-        {
-            reportStart();
-            m_timer.start();
-        }
-
-        explicit operator bool() {
-            if( m_count < m_iterationsToRun )
-                return true;
-            return needsMoreIterations();
-        }
-
-        void increment() {
-            ++m_count;
-        }
-
-        void reportStart();
-        auto needsMoreIterations() -> bool;
-    };
-
-} // end namespace Catch
-
-#define BENCHMARK( name ) \
-    for( Catch::BenchmarkLooper looper( name ); looper; looper.increment() )
-
-#endif // TWOBLUECUBES_CATCH_BENCHMARK_H_INCLUDED

include/internal/catch_capture.hpp

@@ -8,150 +8,179 @@
 #ifndef TWOBLUECUBES_CATCH_CAPTURE_HPP_INCLUDED
 #define TWOBLUECUBES_CATCH_CAPTURE_HPP_INCLUDED
 
-#include "catch_assertionhandler.h"
-#include "catch_interfaces_capture.h"
+#include "catch_result_builder.h"
 #include "catch_message.h"
-#include "catch_stringref.h"
+#include "catch_interfaces_capture.h"
+#include "catch_debugger.h"
+#include "catch_common.h"
+#include "catch_tostring.h"
+#include "catch_interfaces_runner.h"
+#include "catch_compiler_capabilities.h"
 
-#if !defined(CATCH_CONFIG_DISABLE)
 
 #if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION)
-  #define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__
+# define CATCH_INTERNAL_STRINGIFY(expr) #expr
 #else
-  #define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"
+# define CATCH_INTERNAL_STRINGIFY(expr) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"
 #endif
 
-#if defined(CATCH_CONFIG_FAST_COMPILE) || defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+#if defined(CATCH_CONFIG_FAST_COMPILE)
+///////////////////////////////////////////////////////////////////////////////
+// We can speedup compilation significantly by breaking into debugger lower in
+// the callstack, because then we don't have to expand CATCH_BREAK_INTO_DEBUGGER
+// macro in each assertion
+#define INTERNAL_CATCH_REACT( resultBuilder ) \
+    resultBuilder.react();
 
 ///////////////////////////////////////////////////////////////////////////////
 // Another way to speed-up compilation is to omit local try-catch for REQUIRE*
 // macros.
-#define INTERNAL_CATCH_TRY
-#define INTERNAL_CATCH_CATCH( capturer )
+// This can potentially cause false negative, if the test code catches
+// the exception before it propagates back up to the runner.
+#define INTERNAL_CATCH_TEST_NO_TRY( macroName, resultDisposition, expr ) \
+    do { \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr), resultDisposition ); \
+        __catchResult.setExceptionGuard(); \
+        CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+        ( __catchResult <= expr ).endExpression(); \
+        CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
+        __catchResult.unsetExceptionGuard(); \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::isTrue( false && static_cast<bool>( !!(expr) ) ) ) // expr here is never evaluated at runtime but it forces the compiler to give it a look
+// The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&.
 
-#else // CATCH_CONFIG_FAST_COMPILE
-
-#define INTERNAL_CATCH_TRY try
-#define INTERNAL_CATCH_CATCH( handler ) catch(...) { handler.handleUnexpectedInflightException(); }
+#define INTERNAL_CHECK_THAT_NO_TRY( macroName, matcher, resultDisposition, arg ) \
+    do { \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+        __catchResult.setExceptionGuard(); \
+        __catchResult.captureMatch( arg, matcher, CATCH_INTERNAL_STRINGIFY(matcher) ); \
+        __catchResult.unsetExceptionGuard(); \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::alwaysFalse() )
 
+#else
+///////////////////////////////////////////////////////////////////////////////
+// In the event of a failure works out if the debugger needs to be invoked
+// and/or an exception thrown and takes appropriate action.
+// This needs to be done as a macro so the debugger will stop in the user
+// source code rather than in Catch library code
+#define INTERNAL_CATCH_REACT( resultBuilder ) \
+    if( resultBuilder.shouldDebugBreak() ) CATCH_BREAK_INTO_DEBUGGER(); \
+    resultBuilder.react();
 #endif
 
-#define INTERNAL_CATCH_REACT( handler ) handler.complete();
 
 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_TEST( macroName, resultDisposition, ... ) \
+#define INTERNAL_CATCH_TEST( macroName, resultDisposition, expr ) \
     do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
-        INTERNAL_CATCH_TRY { \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr), resultDisposition ); \
+        try { \
             CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
-            catchAssertionHandler.handleExpr( Catch::Decomposer() <= __VA_ARGS__ ); \
+            ( __catchResult <= expr ).endExpression(); \
             CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
-        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( (void)0, (false) && static_cast<bool>( !!(__VA_ARGS__) ) ) // the expression here is never evaluated at runtime but it forces the compiler to give it a look
+        } \
+        catch( ... ) { \
+            __catchResult.useActiveException( resultDisposition ); \
+        } \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::isTrue( false && static_cast<bool>( !!(expr) ) ) ) // expr here is never evaluated at runtime but it forces the compiler to give it a look
     // The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&.
 
 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_IF( macroName, resultDisposition, ... ) \
-    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
+#define INTERNAL_CATCH_IF( macroName, resultDisposition, expr ) \
+    INTERNAL_CATCH_TEST( macroName, resultDisposition, expr ); \
     if( Catch::getResultCapture().lastAssertionPassed() )
 
 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_ELSE( macroName, resultDisposition, ... ) \
-    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
+#define INTERNAL_CATCH_ELSE( macroName, resultDisposition, expr ) \
+    INTERNAL_CATCH_TEST( macroName, resultDisposition, expr ); \
     if( !Catch::getResultCapture().lastAssertionPassed() )
 
 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, ... ) \
+#define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, expr ) \
     do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr), resultDisposition ); \
         try { \
-            static_cast<void>(__VA_ARGS__); \
-            catchAssertionHandler.handleExceptionNotThrownAsExpected(); \
+            static_cast<void>(expr); \
+            __catchResult.captureResult( Catch::ResultWas::Ok ); \
         } \
         catch( ... ) { \
-            catchAssertionHandler.handleUnexpectedInflightException(); \
+            __catchResult.useActiveException( resultDisposition ); \
         } \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::alwaysFalse() )
 
 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_THROWS( macroName, resultDisposition, ... ) \
+#define INTERNAL_CATCH_THROWS( macroName, resultDisposition, matcher, expr ) \
     do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition); \
-        if( catchAssertionHandler.allowThrows() ) \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr), resultDisposition, CATCH_INTERNAL_STRINGIFY(matcher) ); \
+        if( __catchResult.allowThrows() ) \
             try { \
-                static_cast<void>(__VA_ARGS__); \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+                static_cast<void>(expr); \
+                __catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \
             } \
             catch( ... ) { \
-                catchAssertionHandler.handleExceptionThrownAsExpected(); \
+                __catchResult.captureExpectedException( matcher ); \
             } \
         else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
+            __catchResult.captureResult( Catch::ResultWas::Ok ); \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::alwaysFalse() )
 
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \
     do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
-        if( catchAssertionHandler.allowThrows() ) \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
+        if( __catchResult.allowThrows() ) \
             try { \
                 static_cast<void>(expr); \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+                __catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \
             } \
-            catch( exceptionType const& ) { \
-                catchAssertionHandler.handleExceptionThrownAsExpected(); \
+            catch( exceptionType ) { \
+                __catchResult.captureResult( Catch::ResultWas::Ok ); \
             } \
             catch( ... ) { \
-                catchAssertionHandler.handleUnexpectedInflightException(); \
+                __catchResult.useActiveException( resultDisposition ); \
             } \
         else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
+            __catchResult.captureResult( Catch::ResultWas::Ok ); \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::alwaysFalse() )
 
 
 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::StringRef(), resultDisposition ); \
-        catchAssertionHandler.handleMessage( messageType, ( Catch::MessageStream() << __VA_ARGS__ + ::Catch::StreamEndStop() ).m_stream.str() ); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_CAPTURE( varName, macroName, ... ) \
-    auto varName = Catch::Capturer( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info, #__VA_ARGS__ ); \
-    varName.captureValues( 0, __VA_ARGS__ )
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+    #define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \
+        do { \
+            Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \
+            __catchResult << __VA_ARGS__ + ::Catch::StreamEndStop(); \
+            __catchResult.captureResult( messageType ); \
+            INTERNAL_CATCH_REACT( __catchResult ) \
+        } while( Catch::alwaysFalse() )
+#else
+    #define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, log ) \
+        do { \
+            Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \
+            __catchResult << log + ::Catch::StreamEndStop(); \
+            __catchResult.captureResult( messageType ); \
+            INTERNAL_CATCH_REACT( __catchResult ) \
+        } while( Catch::alwaysFalse() )
+#endif
 
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_INFO( macroName, log ) \
-    Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log );
+    Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage ) = Catch::MessageBuilder( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log;
 
 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_UNSCOPED_INFO( macroName, log ) \
-    Catch::getResultCapture().emplaceUnscopedMessage( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
-
-///////////////////////////////////////////////////////////////////////////////
-// Although this is matcher-based, it can be used with just a string
-#define INTERNAL_CATCH_THROWS_STR_MATCHES( macroName, resultDisposition, matcher, ... ) \
+#define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
     do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
-        if( catchAssertionHandler.allowThrows() ) \
-            try { \
-                static_cast<void>(__VA_ARGS__); \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
-            } \
-            catch( ... ) { \
-                Catch::handleExceptionMatchExpr( catchAssertionHandler, matcher, #matcher##_catch_sr ); \
-            } \
-        else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-#endif // CATCH_CONFIG_DISABLE
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+        try { \
+            __catchResult.captureMatch( arg, matcher, CATCH_INTERNAL_STRINGIFY(matcher) ); \
+        } catch( ... ) { \
+            __catchResult.useActiveException( resultDisposition | Catch::ResultDisposition::ContinueOnFailure ); \
+        } \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::alwaysFalse() )
 
 #endif // TWOBLUECUBES_CATCH_CAPTURE_HPP_INCLUDED

include/internal/catch_capture_matchers.cpp

@@ -1,24 +0,0 @@
-/*
- *  Created by Phil on 9/8/2017.
- *  Copyright 2017 Two Blue Cubes Ltd. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#include "catch_capture_matchers.h"
-#include "catch_interfaces_registry_hub.h"
-
-namespace Catch {
-
-    using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
-
-    // This is the general overload that takes a any string matcher
-    // There is another overload, in catch_assertionhandler.h/.cpp, that only takes a string and infers
-    // the Equals matcher (so the header does not mention matchers)
-    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString  ) {
-        std::string exceptionMessage = Catch::translateActiveException();
-        MatchExpr<std::string, StringMatcher const&> expr( exceptionMessage, matcher, matcherString );
-        handler.handleExpr( expr );
-    }
-
-} // namespace Catch

include/internal/catch_capture_matchers.h

@@ -1,87 +0,0 @@
-/*
- *  Created by Phil on 9/8/2017
- *  Copyright 2017 Two Blue Cubes Ltd. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef TWOBLUECUBES_CATCH_CAPTURE_MATCHERS_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_CAPTURE_MATCHERS_HPP_INCLUDED
-
-#include "catch_capture.hpp"
-#include "catch_matchers.h"
-#include "catch_matchers_floating.h"
-#include "catch_matchers_generic.hpp"
-#include "catch_matchers_string.h"
-#include "catch_matchers_vector.h"
-#include "catch_stringref.h"
-
-namespace Catch {
-
-    template<typename ArgT, typename MatcherT>
-    class MatchExpr : public ITransientExpression {
-        ArgT const& m_arg;
-        MatcherT m_matcher;
-        StringRef m_matcherString;
-    public:
-        MatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString )
-        :   ITransientExpression{ true, matcher.match( arg ) },
-            m_arg( arg ),
-            m_matcher( matcher ),
-            m_matcherString( matcherString )
-        {}
-
-        void streamReconstructedExpression( std::ostream &os ) const override {
-            auto matcherAsString = m_matcher.toString();
-            os << Catch::Detail::stringify( m_arg ) << ' ';
-            if( matcherAsString == Detail::unprintableString )
-                os << m_matcherString;
-            else
-                os << matcherAsString;
-        }
-    };
-
-    using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
-
-    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString  );
-
-    template<typename ArgT, typename MatcherT>
-    auto makeMatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString  ) -> MatchExpr<ArgT, MatcherT> {
-        return MatchExpr<ArgT, MatcherT>( arg, matcher, matcherString );
-    }
-
-} // namespace Catch
-
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
-        INTERNAL_CATCH_TRY { \
-            catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher, #matcher##_catch_sr ) ); \
-        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_THROWS_MATCHES( macroName, exceptionType, resultDisposition, matcher, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(exceptionType) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
-        if( catchAssertionHandler.allowThrows() ) \
-            try { \
-                static_cast<void>(__VA_ARGS__ ); \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
-            } \
-            catch( exceptionType const& ex ) { \
-                catchAssertionHandler.handleExpr( Catch::makeMatchExpr( ex, matcher, #matcher##_catch_sr ) ); \
-            } \
-            catch( ... ) { \
-                catchAssertionHandler.handleUnexpectedInflightException(); \
-            } \
-        else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-#endif // TWOBLUECUBES_CATCH_CAPTURE_MATCHERS_HPP_INCLUDED

include/internal/catch_clara.h

@@ -11,27 +11,21 @@
 
 // Use Catch's value for console width (store Clara's off to the side, if present)
 #ifdef CLARA_CONFIG_CONSOLE_WIDTH
-#define CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
-#undef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
+#define CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH CLARA_CONFIG_CONSOLE_WIDTH
+#undef CLARA_CONFIG_CONSOLE_WIDTH
 #endif
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH-1
+#define CLARA_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH
 
-#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"
+// Declare Clara inside the Catch namespace
+#define STITCH_CLARA_OPEN_NAMESPACE namespace Catch {
+#include "../external/clara.h"
+#undef STITCH_CLARA_OPEN_NAMESPACE
 
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
 
 // Restore Clara's value for console width, if present
 #ifdef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#define CLARA_CONFIG_CONSOLE_WIDTH CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
 #undef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
 #endif
 

include/internal/catch_commandline.cpp

@@ -1,209 +0,0 @@
-/*
- *  Created by Phil on 02/11/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)
- */
-
-#include "catch_commandline.h"
-
-#include "catch_string_manip.h"
-
-#include "catch_interfaces_registry_hub.h"
-#include "catch_interfaces_reporter.h"
-
-#include <fstream>
-#include <ctime>
-
-namespace Catch {
-
-    clara::Parser makeCommandLineParser( ConfigData& config ) {
-
-        using namespace clara;
-
-        auto const setWarning = [&]( std::string const& warning ) {
-                auto warningSet = [&]() {
-                    if( warning == "NoAssertions" )
-                        return WarnAbout::NoAssertions;
-
-                    if ( warning == "NoTests" )
-                        return WarnAbout::NoTests;
-
-                    return WarnAbout::Nothing;
-                }();
-
-                if (warningSet == WarnAbout::Nothing)
-                    return ParserResult::runtimeError( "Unrecognised warning: '" + warning + "'" );
-                config.warnings = static_cast<WarnAbout::What>( config.warnings | warningSet );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const loadTestNamesFromFile = [&]( std::string const& filename ) {
-                std::ifstream f( filename.c_str() );
-                if( !f.is_open() )
-                    return ParserResult::runtimeError( "Unable to load input file: '" + filename + "'" );
-
-                std::string line;
-                while( std::getline( f, line ) ) {
-                    line = trim(line);
-                    if( !line.empty() && !startsWith( line, '#' ) ) {
-                        if( !startsWith( line, '"' ) )
-                            line = '"' + line + '"';
-                        config.testsOrTags.push_back( line + ',' );
-                    }
-                }
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setTestOrder = [&]( std::string const& order ) {
-                if( startsWith( "declared", order ) )
-                    config.runOrder = RunTests::InDeclarationOrder;
-                else if( startsWith( "lexical", order ) )
-                    config.runOrder = RunTests::InLexicographicalOrder;
-                else if( startsWith( "random", order ) )
-                    config.runOrder = RunTests::InRandomOrder;
-                else
-                    return clara::ParserResult::runtimeError( "Unrecognised ordering: '" + order + "'" );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setRngSeed = [&]( std::string const& seed ) {
-                if( seed != "time" )
-                    return clara::detail::convertInto( seed, config.rngSeed );
-                config.rngSeed = static_cast<unsigned int>( std::time(nullptr) );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setColourUsage = [&]( std::string const& useColour ) {
-                    auto mode = toLower( useColour );
-
-                    if( mode == "yes" )
-                        config.useColour = UseColour::Yes;
-                    else if( mode == "no" )
-                        config.useColour = UseColour::No;
-                    else if( mode == "auto" )
-                        config.useColour = UseColour::Auto;
-                    else
-                        return ParserResult::runtimeError( "colour mode must be one of: auto, yes or no. '" + useColour + "' not recognised" );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setWaitForKeypress = [&]( std::string const& keypress ) {
-                auto keypressLc = toLower( keypress );
-                if( keypressLc == "start" )
-                    config.waitForKeypress = WaitForKeypress::BeforeStart;
-                else if( keypressLc == "exit" )
-                    config.waitForKeypress = WaitForKeypress::BeforeExit;
-                else if( keypressLc == "both" )
-                    config.waitForKeypress = WaitForKeypress::BeforeStartAndExit;
-                else
-                    return ParserResult::runtimeError( "keypress argument must be one of: start, exit or both. '" + keypress + "' not recognised" );
-            return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setVerbosity = [&]( std::string const& verbosity ) {
-            auto lcVerbosity = toLower( verbosity );
-            if( lcVerbosity == "quiet" )
-                config.verbosity = Verbosity::Quiet;
-            else if( lcVerbosity == "normal" )
-                config.verbosity = Verbosity::Normal;
-            else if( lcVerbosity == "high" )
-                config.verbosity = Verbosity::High;
-            else
-                return ParserResult::runtimeError( "Unrecognised verbosity, '" + verbosity + "'" );
-            return ParserResult::ok( ParseResultType::Matched );
-        };
-        auto const setReporter = [&]( std::string const& reporter ) {
-            IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
-
-            auto lcReporter = toLower( reporter );
-            auto result = factories.find( lcReporter );
-
-            if( factories.end() != result )
-                config.reporterName = lcReporter;
-            else
-                return ParserResult::runtimeError( "Unrecognized reporter, '" + reporter + "'. Check available with --list-reporters" );
-            return ParserResult::ok( ParseResultType::Matched );
-        };
-
-        auto cli
-            = ExeName( config.processName )
-            | Help( config.showHelp )
-            | Opt( config.listTests )
-                ["-l"]["--list-tests"]
-                ( "list all/matching test cases" )
-            | Opt( config.listTags )
-                ["-t"]["--list-tags"]
-                ( "list all/matching tags" )
-            | Opt( config.showSuccessfulTests )
-                ["-s"]["--success"]
-                ( "include successful tests in output" )
-            | Opt( config.shouldDebugBreak )
-                ["-b"]["--break"]
-                ( "break into debugger on failure" )
-            | Opt( config.noThrow )
-                ["-e"]["--nothrow"]
-                ( "skip exception tests" )
-            | Opt( config.showInvisibles )
-                ["-i"]["--invisibles"]
-                ( "show invisibles (tabs, newlines)" )
-            | Opt( config.outputFilename, "filename" )
-                ["-o"]["--out"]
-                ( "output filename" )
-            | Opt( setReporter, "name" )
-                ["-r"]["--reporter"]
-                ( "reporter to use (defaults to console)" )
-            | Opt( config.name, "name" )
-                ["-n"]["--name"]
-                ( "suite name" )
-            | Opt( [&]( bool ){ config.abortAfter = 1; } )
-                ["-a"]["--abort"]
-                ( "abort at first failure" )
-            | Opt( [&]( int x ){ config.abortAfter = x; }, "no. failures" )
-                ["-x"]["--abortx"]
-                ( "abort after x failures" )
-            | Opt( setWarning, "warning name" )
-                ["-w"]["--warn"]
-                ( "enable warnings" )
-            | Opt( [&]( bool flag ) { config.showDurations = flag ? ShowDurations::Always : ShowDurations::Never; }, "yes|no" )
-                ["-d"]["--durations"]
-                ( "show test durations" )
-            | Opt( loadTestNamesFromFile, "filename" )
-                ["-f"]["--input-file"]
-                ( "load test names to run from a file" )
-            | Opt( config.filenamesAsTags )
-                ["-#"]["--filenames-as-tags"]
-                ( "adds a tag for the filename" )
-            | Opt( config.sectionsToRun, "section name" )
-                ["-c"]["--section"]
-                ( "specify section to run" )
-            | Opt( setVerbosity, "quiet|normal|high" )
-                ["-v"]["--verbosity"]
-                ( "set output verbosity" )
-            | Opt( config.listTestNamesOnly )
-                ["--list-test-names-only"]
-                ( "list all/matching test cases names only" )
-            | Opt( config.listReporters )
-                ["--list-reporters"]
-                ( "list all reporters" )
-            | Opt( setTestOrder, "decl|lex|rand" )
-                ["--order"]
-                ( "test case order (defaults to decl)" )
-            | Opt( setRngSeed, "'time'|number" )
-                ["--rng-seed"]
-                ( "set a specific seed for random numbers" )
-            | Opt( setColourUsage, "yes|no" )
-                ["--use-colour"]
-                ( "should output be colourised" )
-            | Opt( config.libIdentify )
-                ["--libidentify"]
-                ( "report name and version according to libidentify standard" )
-            | Opt( setWaitForKeypress, "start|exit|both" )
-                ["--wait-for-keypress"]
-                ( "waits for a keypress before exiting" )
-            | Opt( config.benchmarkResolutionMultiple, "multiplier" )
-                ["--benchmark-resolution-multiple"]
-                ( "multiple of clock resolution to run benchmarks" )
-
-            | Arg( config.testsOrTags, "test name|pattern|tags" )
-                ( "which test or tests to use" );
-
-        return cli;
-    }
-
-} // end namespace Catch

include/internal/catch_commandline.h

@@ -1,20 +0,0 @@
-/*
- *  Created by Phil on 02/11/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_COMMANDLINE_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_COMMANDLINE_HPP_INCLUDED
-
-#include "catch_config.hpp"
-#include "catch_clara.h"
-
-namespace Catch {
-
-    clara::Parser makeCommandLineParser( ConfigData& config );
-
-} // end namespace Catch
-
-#endif // TWOBLUECUBES_CATCH_COMMANDLINE_HPP_INCLUDED