Fix priority

.conan/test_package/CMakeLists.txt

@@ -8,4 +8,4 @@ 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 14)
+set_target_properties(${PROJECT_NAME} PROPERTIES CXX_STANDARD 11)

.travis.yml

@@ -1,6 +1,4 @@
 language: cpp
-dist: xenial
-
 
 branches:
   except:
@@ -8,34 +6,42 @@ branches:
 
 common_sources: &all_sources
   - ubuntu-toolchain-r-test
-  - llvm-toolchain-xenial
-  - llvm-toolchain-xenial-3.8
-  - llvm-toolchain-xenial-3.9
-  - llvm-toolchain-xenial-4.0
-  - llvm-toolchain-xenial-5.0
-  - llvm-toolchain-xenial-6.0
-  - llvm-toolchain-xenial-7
-  - llvm-toolchain-xenial-8
-
+  - llvm-toolchain-trusty
+  - llvm-toolchain-trusty-3.9
+  - llvm-toolchain-trusty-4.0
+  - llvm-toolchain-trusty-5.0
+  - llvm-toolchain-trusty-6.0
 
 matrix:
   include:
-    # Clang builds
+
+    # 1/ Linux Clang Builds
     - os: linux
       compiler: clang
       addons:
-          apt:
-              sources: *all_sources
-              packages: ['clang-3.8']
-      env: COMPILER='clang++-3.8' CPP14=1
+        apt:
+          sources: *all_sources
+          packages: ['clang-3.5']
+      env: COMPILER='clang++-3.5'
 
     - os: linux
       compiler: clang
       addons:
         apt:
           sources: *all_sources
-          packages: ['clang-3.8', 'lcov']
-      env: COMPILER='clang++-3.8' CPP14=1 EXAMPLES=1 COVERAGE=1 EXTRAS=1
+          packages: ['clang-3.6']
+      env: COMPILER='clang++-3.6'
+
+    # Clang 3.7 is intentionally skipped as we cannot get it easily on
+    # TravisCI container
+
+    - os: linux
+      compiler: clang
+      addons:
+        apt:
+          sources: *all_sources
+          packages: ['lcov', 'clang-3.8']
+      env: COMPILER='clang++-3.8'
 
     - os: linux
       compiler: clang
@@ -43,7 +49,7 @@ matrix:
           apt:
               sources: *all_sources
               packages: ['clang-3.9']
-      env: COMPILER='clang++-3.9' CPP14=1
+      env: COMPILER='clang++-3.9'
 
     - os: linux
       compiler: clang
@@ -51,7 +57,7 @@ matrix:
           apt:
               sources: *all_sources
               packages: ['clang-4.0']
-      env: COMPILER='clang++-4.0' CPP14=1
+      env: COMPILER='clang++-4.0'
 
     - os: linux
       compiler: clang
@@ -59,7 +65,7 @@ matrix:
           apt:
               sources: *all_sources
               packages: ['clang-5.0']
-      env: COMPILER='clang++-5.0' CPP14=1
+      env: COMPILER='clang++-5.0'
 
     - os: linux
       compiler: clang
@@ -67,8 +73,187 @@ matrix:
           apt:
               sources: *all_sources
               packages: ['clang-6.0']
+      env: COMPILER='clang++-6.0'
+
+    # 2/ Linux GCC Builds
+    - os: linux
+      compiler: gcc
+      addons:
+        apt:
+         sources: *all_sources
+         packages: ['g++-4.8']
+      env: COMPILER='g++-4.8'
+
+    - os: linux
+      compiler: gcc
+      addons:
+        apt:
+          sources: *all_sources
+          packages: ['g++-4.9']
+      env: COMPILER='g++-4.9'
+
+    - os: linux
+      compiler: gcc
+      addons:
+        apt:
+          sources: *all_sources
+          packages: ['g++-5']
+      env: COMPILER='g++-5'
+
+    - os: linux
+      compiler: gcc
+      addons: &gcc6
+        apt:
+          sources: *all_sources
+          packages: ['g++-6']
+      env: COMPILER='g++-6'
+
+    - os: linux
+      compiler: gcc
+      addons: &gcc7
+        apt:
+          sources: *all_sources
+          packages: ['g++-7']
+      env: COMPILER='g++-7'
+
+    - os: linux
+      compiler: gcc
+      addons: &gcc8
+        apt:
+          sources: *all_sources
+          packages: ['g++-8']
+      env: COMPILER='g++-8'
+
+    # 3b/ Linux C++14 Clang builds
+    # Note that we need newer libstdc++ for C++14 support
+    - 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
+
+    - 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
 
+
+    # 4a/ Linux C++14 GCC builds
+    - os: linux
+      compiler: gcc
+      addons: *gcc6
+      env: COMPILER='g++-6' CPP14=1
+
+    - os: linux
+      compiler: gcc
+      addons: *gcc7
+      env: COMPILER='g++-7' 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++'
+
+    - os: osx
+      osx_image: xcode8
+      compiler: clang
+      env: COMPILER='clang++'
+
+    - os: osx
+      osx_image: xcode9
+      compiler: clang
+      env: COMPILER='clang++'
+
+    - os: osx
+      osx_image: xcode9.1
+      compiler: clang
+      env: COMPILER='clang++'
+
+    - os: osx
+      osx_image: xcode9.1
+      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
+
+    - os: osx
+      osx_image: xcode9.1
+      compiler: clang
+      env: COMPILER='clang++' CPP14=1 EXAMPLES=1 COVERAGE=1 EXTRAS=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
       compiler: clang
       addons:
@@ -82,98 +267,39 @@ matrix:
       addons:
           apt:
               sources: *all_sources
-              packages: ['clang-7']
-      env: COMPILER='clang++-7' CPP14=1
+              packages: ['clang-6.0', 'libstdc++-8-dev']
+      env: COMPILER='clang++-6.0' CPP17=1 EXAMPLES=1 COVERAGE=1 EXTRAS=1
 
-    - os: linux
-      compiler: clang
-      addons:
-          apt:
-              sources: *all_sources
-              packages: ['clang-8']
-      env: COMPILER='clang++-8' CPP14=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
 
-    - os: linux
-      compiler: clang
-      addons:
-          apt:
-              sources: *all_sources
-              packages: ['clang-8', 'libstdc++-8-dev']
-      env: COMPILER='clang++-8' CPP17=1 EXAMPLES=1 COVERAGE=1 EXTRAS=1
-
-
-    # GCC builds
-    - os: linux
-      compiler: gcc
-      addons:
-        apt:
-          sources: *all_sources
-          packages: ['g++-5']
-      env: COMPILER='g++-5' CPP14=1
-
-    - os: linux
-      compiler: gcc
-      addons:
-        apt:
-          sources: *all_sources
-          packages: ['g++-6']
-      env: COMPILER='g++-6' CPP14=1
-
-    - os: linux
-      compiler: gcc
-      addons:
-        apt:
-          sources: *all_sources
-          packages: ['g++-7', 'lcov']
-      env: COMPILER='g++-7' CPP14=1 EXAMPLES=1 COVERAGE=1 EXTRAS=1
-
-    - os: linux
-      compiler: gcc
-      addons:
-        apt:
-          sources: *all_sources
-          packages: ['g++-8']
-      env: COMPILER='g++-8' CPP17=1
-
-    # OSX Clang Builds
-    - os: osx
-      osx_image: xcode9.4
-      compiler: clang
-      env: COMPILER='clang++' CPP14=1
-
-    - os: osx
-      osx_image: xcode10.3
-      compiler: clang
-      env: COMPILER='clang++' CPP14=1
-
-    - os: osx
-      osx_image: xcode11.2
-      compiler: clang
-      env: COMPILER='clang++' CPP14=1
-
-    - os: osx
-      osx_image: xcode11.2
-      compiler: clang
-      env: COMPILER='clang++' CPP14=1 EXAMPLES=1 COVERAGE=1 EXTRAS=1
-
-
-
-#    # Special builds, e.g. conan
-#    - language: python
-#      python:
-#        - "3.7"
-#      install:
-#        - pip install conan-package-tools
-#      env:
-#        - CONAN_GCC_VERSIONS=8
-#        - CONAN_DOCKER_IMAGE=conanio/gcc8
-#        - CPP14=1
-#      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"
+      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;
+    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
 
   - |
     if [[ ${CPP17} -eq 1 ]]; then
@@ -181,7 +307,7 @@ before_script:
     elif [[ ${CPP14} -eq 1 ]]; then
       export CPP_STANDARD=14
     else
-      travis_terminate 4;
+      export CPP_STANDARD=11
     fi
 
     # Use Debug builds for running Valgrind and building examples

CMakeLists.txt

@@ -6,27 +6,12 @@ if(NOT DEFINED PROJECT_NAME)
   set(NOT_SUBPROJECT ON)
 endif()
 
-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_INSTALL_DOCS "Install documentation alongside library" ON)
-option(CATCH_INSTALL_EXTRAS "Install extras alongside library" ON)
+project(Catch2 LANGUAGES CXX VERSION 2.9.1)
 
-
-set(CATCH_CMAKE_CONFIG_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/Catch2")
-
-
-# Catch2's build breaks if done in-tree. You probably should not build
-# things in tree anyway, but we can allow projects that include Catch2
-# as a subproject to build in-tree as long as it is not in our tree.
-if (CMAKE_BINARY_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
+if (CMAKE_BINARY_DIR STREQUAL CMAKE_SOURCE_DIR)
     message(FATAL_ERROR "Building in-source is not supported! Create a build dir and remove ${CMAKE_SOURCE_DIR}/CMakeCache.txt")
 endif()
 
-
-project(Catch2 LANGUAGES CXX VERSION 2.10.2)
-
 # Provide path for scripts
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/CMake")
 
@@ -34,23 +19,34 @@ include(GNUInstallDirs)
 include(CMakePackageConfigHelpers)
 include(CTest)
 
-# Basic paths
+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)
+
+
+set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+
+# define some folders
 set(CATCH_DIR ${CMAKE_CURRENT_SOURCE_DIR})
-set(SOURCES_DIR ${CATCH_DIR}/src/catch2)
-set(SELF_TEST_DIR ${CATCH_DIR}/tests/SelfTest)
-set(BENCHMARK_DIR ${CATCH_DIR}/tests/Benchmark)
-set(EXAMPLES_DIR ${CATCH_DIR}/examples)
+set(SELF_TEST_DIR ${CATCH_DIR}/projects/SelfTest)
+set(BENCHMARK_DIR ${CATCH_DIR}/projects/Benchmark)
+set(HEADER_DIR ${CATCH_DIR}/include)
 
-# We need to bring-in the variables defined there to this scope
-add_subdirectory(src)
+if(USE_WMAIN)
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /ENTRY:wmainCRTStartup")
+endif()
 
-# Build tests only if requested
 if (BUILD_TESTING AND CATCH_BUILD_TESTING AND NOT_SUBPROJECT)
-    find_package(PythonInterp)
-    if (NOT PYTHONINTERP_FOUND)
+    find_package(Python COMPONENTS Interpreter)
+    if (NOT Python_Interpreter_FOUND)
         message(FATAL_ERROR "Python not found, but required for tests")
     endif()
-    add_subdirectory(tests)
+    add_subdirectory(projects)
 endif()
 
 if(CATCH_BUILD_EXAMPLES)
@@ -58,25 +54,52 @@ if(CATCH_BUILD_EXAMPLES)
 endif()
 
 if(CATCH_BUILD_EXTRA_TESTS)
-    add_subdirectory(tests/ExtraTests)
+    add_subdirectory(projects/ExtraTests)
 endif()
 
-#option(CATCH_USE_VALGRIND "Perform SelfTests with Valgrind" OFF)
-#option(CATCH_ENABLE_WERROR "Enable all warnings as errors" ON)
-#
-#set_property(GLOBAL PROPERTY USE_FOLDERS ON)
-#
-#if(USE_WMAIN)
-#    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /ENTRY:wmainCRTStartup")
-#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
@@ -85,8 +108,26 @@ if (NOT_SUBPROJECT)
           ${CATCH_CMAKE_CONFIG_DESTINATION}
     )
 
-    ## TODO: Catch2 main target?
-    ## Install some cpp file as well?
+
+    # 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
@@ -107,6 +148,13 @@ if (NOT_SUBPROJECT)
     )
     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"
@@ -129,9 +177,9 @@ if (NOT_SUBPROJECT)
     # Install CMake scripts
     install(
       FILES
-        "extras/ParseAndAddCatchTests.cmake"
-        "extras/Catch.cmake"
-        "extras/CatchAddTests.cmake"
+        "contrib/ParseAndAddCatchTests.cmake"
+        "contrib/Catch.cmake"
+        "contrib/CatchAddTests.cmake"
       DESTINATION
         ${CATCH_CMAKE_CONFIG_DESTINATION}
     )
@@ -139,8 +187,8 @@ if (NOT_SUBPROJECT)
     # Install debugger helpers
     install(
       FILES
-        "extras/gdbinit"
-        "extras/lldbinit"
+        "contrib/gdbinit"
+        "contrib/lldbinit"
       DESTINATION
         ${CMAKE_INSTALL_DATAROOTDIR}/Catch2
     )

README.md

@@ -1,15 +1,15 @@
 <a id="top"></a>
-![catch logo](data/artwork/catch2-logo-small.png)
+![catch logo](artwork/catch2-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/LzYWgcPrcy9yQmed)
+[![Try online](https://img.shields.io/badge/try-online-blue.svg)](https://wandbox.org/permlink/5icuqPwk9miJLAL1)
 [![Join the chat in Discord: https://discord.gg/4CWS9zD](https://img.shields.io/badge/Discord-Chat!-brightgreen.svg)](https://discord.gg/4CWS9zD)
 
 
-<a href="https://github.com/catchorg/Catch2/releases/download/v2.10.2/catch.hpp">The latest version of the single header can be downloaded directly using this link</a>
+<a href="https://github.com/catchorg/Catch2/releases/download/v2.9.1/catch.hpp">The latest version of the single header can be downloaded directly using this link</a>
 
 ## Catch2 is released!
 

appveyor.yml

@@ -1,32 +1,88 @@
-version: "{build}-{branch}"
+# version string format -- This will be overwritten later anyway
+version: "{build}"
 
-# If we ever get a backlog larger than clone_depth, builds will fail
-# spuriously. I do not think we will ever get 20 deep commits deep though.
-clone_depth: 20
-
-# We want to build everything, except for branches that are explicitly
-# for messing around with travis.
 branches:
   except:
     - /dev-travis.+/
 
+os:
+  - Visual Studio 2017
+  - Visual Studio 2015
 
-# We need a more up to date pip because Python 2.7 is EOL soon
-init:
-  - set PATH=C:\Python35\Scripts;%PATH%
+environment:
+    matrix:
+        - additional_flags: "/permissive- /std:c++latest"
+          wmain: 0
+
+        - additional_flags: ""
+          wmain: 0
+
+        - 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"
+
+        - os: Visual Studio 2015
+          additional_flags: "/D_UNICODE /DUNICODE"
+
+        # 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" ) { pip --disable-pip-version-check install codecov }
-  - ps: if (($env:CONFIGURATION) -eq "Debug" -And ($env:coverage) -eq "1" ) { .\tools\misc\installOpenCppCoverage.ps1 }
+  - 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 }
 
+# Win32 and x64 are CMake-compatible solution platform names.
+# This allows us to pass %PLATFORM% to CMake -A.
+platform:
+  - Win32
+  - x64
 
+# build Configurations, i.e. Debug, Release, etc.
+configuration:
+  - Debug
+  - Release
+
+#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: .\tools\misc\appveyorBuildConfigurationScript.bat
+  - cmd: .\misc\appveyorBuildConfigurationScript.bat
 
 
 # build with MSBuild
@@ -37,95 +93,4 @@ build:
 
 test_script:
   - set CTEST_OUTPUT_ON_FAILURE=1
-  - cmd: .\tools\misc\appveyorTestRunScript.bat
-
-
-# Sadly we cannot use the standard "dimensions" based approach towards
-# specifying the different builds, as there is no way to add one-offs
-# builds afterwards. This means that we will painfully specify each
-# build explicitly.
-environment:
-  matrix:
-    - FLAVOR: VS 2019 x64 Debug
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
-      platform: x64
-      configuration: Debug
-    
-    - FLAVOR: VS 2019 x64 Release
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
-      platform: x64
-      configuration: Release
-
-    - FLAVOR: VS 2019 x64 Debug Coverage
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
-      coverage: 1
-      platform: x64
-      configuration: Debug
-
-    - FLAVOR: VS 2019 x64 Debug Examples
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
-      examples: 1
-      platform: x64
-      configuration: Debug
-
-    - FLAVOR: VS 2019 x64 Debug WMain
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
-      wmain: 1
-      additional_flags: "/D_UNICODE /DUNICODE"
-      platform: x64
-      configuration: Debug
-
-    - FLAVOR: VS 2019 Win32 Debug
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
-      platform: Win32
-      configuration: Debug
-
-    - FLAVOR: VS 2019 x64 Debug Latest Strict
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
-      additional_flags: "/permissive- /std:c++latest"
-      platform: x64
-      configuration: Debug
-
-    - FLAVOR: VS 2017 x64 Debug
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      platform: x64
-      configuration: Debug
-    
-    - FLAVOR: VS 2017 x64 Release
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      platform: x64
-      configuration: Release
-
-    - FLAVOR: VS 2017 x64 Release Coverage
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      coverage: 1
-      platform: x64
-      configuration: Debug
-
-    - FLAVOR: VS 2017 Win32 Debug
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      platform: Win32
-      configuration: Debug
-
-# This build causes error after 30 minutes, because the VS2017 image
-# tries to launch just-in-time debugger on call to std::terminate, which
-# is an expected part of the tests in this build.
-# We can reenable it, if we handle disabling that test in CMake.
-#    - FLAVOR: VS 2017 Win32 Debug Examples
-#      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-#      examples: 1
-#      platform: Win32
-#      configuration: Debug
-
-    - FLAVOR: VS 2017 Win32 Debug WMain
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      wmain: 1
-      additional_flags: "/D_UNICODE /DUNICODE"
-      platform: Win32
-      configuration: Debug
-
-    - FLAVOR: VS 2017 x64 Debug Latest Strict
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      additional_flags: "/permissive- /std:c++latest"
-      platform: x64
-      configuration: Debug
+  - cmd: .\misc\appveyorTestRunScript.bat

codecov.yml

@@ -10,6 +10,10 @@ coverage:
       default:
         target: 80%
   ignore:
+    - "projects/SelfTest"
+    - "**/catch_reporter_tap.hpp"
+    - "**/catch_reporter_automake.hpp"
+    - "**/catch_reporter_teamcity.hpp"
     - "**/external/clara.hpp"
 
 

contrib/CatchAddTests.cmake

@@ -51,11 +51,8 @@ string(REPLACE "\n" ";" output "${output}")
 # Parse output
 foreach(line ${output})
   set(test ${line})
-  # Escape characters in test case names that would be parsed by Catch2
-  set(test_name ${test})
-  foreach(char , [ ])
-    string(REPLACE ${char} "\\${char}" test_name ${test_name})
-  endforeach(char)
+  # 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}"

docs/assertions.md

@@ -136,7 +136,7 @@ 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 the [documentation for Matchers](matchers.md#top)).
+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._

docs/benchmarks.md

@@ -1,8 +1,6 @@
 <a id="top"></a>
 # Authoring benchmarks
 
-> [Introduced](https://github.com/catchorg/Catch2/issues/1616) in Catch 2.9.0.
-
 _Note that benchmarking support is disabled by default and to enable it,
 you need to define `CATCH_CONFIG_ENABLE_BENCHMARKING`. For more details,
 see the [compile-time configuration documentation](configuration.md#top)._

docs/ci-and-misc.md

@@ -12,7 +12,7 @@ Build Systems may refer to low-level tools, like CMake, or larger systems that r
 
 ## 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, Automake and SonarQube reporters).
+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.
 
@@ -65,10 +65,6 @@ 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.
 
-### SonarQube Reporter
-```-r sonarqube```
-[SonarQube Generic Test Data](https://docs.sonarqube.org/latest/analysis/generic-test/) XML format for tests metrics.
-
 ## Low-level tools
 
 ### Precompiled headers (PCHs)

docs/command-line.md

@@ -99,7 +99,6 @@ exclude:notThis         Matches all tests except, 'notThis'
 ~*private*              Matches all tests except those that contain 'private'
 a* ~ab* abc             Matches all tests that start with 'a', except those that
                         start with 'ab', except 'abc', which is included
--# [#somefile]          Matches all tests from the file 'somefile.cpp'
 </pre>
 
 Names within square brackets are interpreted as tags.
@@ -278,8 +277,6 @@ either before running any tests, after running all tests - or both, depending on
 ## Specify the number of benchmark samples to collect
 <pre>--benchmark-samples &lt;# of samples&gt;</pre>
 
-> [Introduced](https://github.com/catchorg/Catch2/issues/1616) in Catch 2.9.0.
-
 When running benchmarks a number of "samples" is collected. This is the base data for later statistical analysis.
 Per sample a clock resolution dependent number of iterations of the user code is run, which is independent of the number of samples. Defaults to 100.
 
@@ -287,8 +284,6 @@ Per sample a clock resolution dependent number of iterations of the user code is
 ## Specify the number of resamples for bootstrapping
 <pre>--benchmark-resamples &lt;# of resamples&gt;</pre>
 
-> [Introduced](https://github.com/catchorg/Catch2/issues/1616) in Catch 2.9.0.
-
 After the measurements are performed, statistical [bootstrapping] is performed
 on the samples. The number of resamples for that bootstrapping is configurable
 but defaults to 100000. Due to the bootstrapping it is possible to give
@@ -302,8 +297,6 @@ defaults to 95%).
 ## Specify the confidence-interval for bootstrapping
 <pre>--benchmark-confidence-interval &lt;confidence-interval&gt;</pre>
 
-> [Introduced](https://github.com/catchorg/Catch2/issues/1616) in Catch 2.9.0.
-
 The confidence-interval is used for statistical bootstrapping on the samples to
 calculate the upper and lower bounds of mean and standard deviation.
 Must be between 0 and 1 and defaults to 0.95.
@@ -312,8 +305,6 @@ Must be between 0 and 1 and defaults to 0.95.
 ## Disable statistical analysis of collected benchmark samples
 <pre>--benchmark-no-analysis</pre>
 
-> [Introduced](https://github.com/catchorg/Catch2/issues/1616) in Catch 2.9.0.
-
 When this flag is specified no bootstrapping or any other statistical analysis is performed.
 Instead the user code is only measured and the plain mean from the samples is reported.
 

docs/commercial-users.md

@@ -17,4 +17,3 @@ fact then please let us know - either directly, via a PR or
  - NASA
  - [Inscopix Inc.](https://www.inscopix.com/)
  - [Makimo](https://makimo.pl/)
- - [UX3D] (https://ux3d.io)

docs/configuration.md

@@ -127,12 +127,8 @@ Catch's selection, by defining either `CATCH_CONFIG_CPP11_TO_STRING` or
 ## C++17 toggles
 
     CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS  // Use std::uncaught_exceptions instead of std::uncaught_exception
-    CATCH_CONFIG_CPP17_STRING_VIEW          // Override std::string_view support detection(Catch provides a StringMaker specialization by default)
-    CATCH_CONFIG_CPP17_VARIANT              // Override std::variant support detection (checked by CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER)
-    CATCH_CONFIG_CPP17_OPTIONAL             // Override std::optional support detection (checked by CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER)
-    CATCH_CONFIG_CPP17_BYTE                 // Override std::byte support detection (Catch provides a StringMaker specialization by default)
-
-> `CATCH_CONFIG_CPP17_STRING_VIEW` was [introduced](https://github.com/catchorg/Catch2/issues/1376) in Catch 2.4.1.
+    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
@@ -155,10 +151,6 @@ by using `_NO_` in the macro, e.g. `CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS`.
     CATCH_CONFIG_EXPERIMENTAL_REDIRECT      // Enables the new (experimental) way of capturing stdout/stderr
     CATCH_CONFIG_ENABLE_BENCHMARKING        // Enables the integrated benchmarking features (has a significant effect on compilation speed)
     CATCH_CONFIG_USE_ASYNC                  // Force parallel statistical processing of samples during benchmarking
-    CATCH_CONFIG_ANDROID_LOGWRITE           // Use android's logging system for debug output
-    CATCH_CONFIG_GLOBAL_NEXTAFTER           // Use nextafter{,f,l} instead of std::nextafter
-
-> [`CATCH_CONFIG_ANDROID_LOGWRITE`](https://github.com/catchorg/Catch2/issues/1743) and [`CATCH_CONFIG_GLOBAL_NEXTAFTER`](https://github.com/catchorg/Catch2/pull/1739) were introduced in Catch 2.10.0
 
 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.
 
@@ -217,14 +209,9 @@ By default, Catch does not stringify some types from the standard library. This
     CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER // Provide StringMaker specialization for std::optional (on C++17)
     CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS     // Defines all of the above
 
-> `CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER` was [introduced](https://github.com/catchorg/Catch2/issues/1380) in Catch 2.4.1.
-
-> `CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER` was [introduced](https://github.com/catchorg/Catch2/issues/1510) in Catch 2.6.0.
 
 ## Disabling exceptions
 
-> Introduced in Catch 2.4.0.
-
 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

docs/contributing.md

@@ -5,7 +5,6 @@
 [Branches](#branches)<br>
 [Directory structure](#directory-structure)<br>
 [Testing your changes](#testing-your-changes)<br>
-[Documenting your code](#documenting-your-code)<br>
 [Code constructs to watch out for](#code-constructs-to-watch-out-for)<br>
 
 So you want to contribute something to Catch? That's great! Whether it's a bug fix, a new feature, support for
@@ -35,7 +34,7 @@ While these files are not essential to compilation they help to keep the impleme
 At time of writing this set is not complete but has reasonable coverage.
 If you add additional headers please try to remember to add a surrogate cpp for it.
 
-The other directories are `tools/scripts` which contains a set of python scripts to help in testing Catch as well as
+The other directories are `scripts` which contains a set of python scripts to help in testing Catch as well as
 generating the single include, and `docs`, which contains the documentation as a set of markdown files.
 
 __When submitting a pull request please do not include changes to the single include, or to the version number file
@@ -70,10 +69,6 @@ locally takes just a few minutes.
 $ cd debug-build
 $ ctest -j 2 --output-on-failure
 ```
-__Note:__ When running your tests with multi-configuration generators like
-Visual Studio, you might get errors "Test not available without configuration."
-You then have to pick one configuration (e.g. ` -C Debug`) in the `ctest` call.
-
 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.
@@ -86,59 +81,6 @@ before you do so, you need to check that the introduced changes are indeed
 intentional.
 
 
-## Documenting your code
-
-If you have added new feature to Catch2, it needs documentation, so that
-other people can use it as well. This section collects some technical
-information that you will need for updating Catch2's documentation, and
-possibly some generic advise as well.
-
-First, the technicalities:
-
-* We introduced version tags to the documentation, which show users in
-which version a specific feature was introduced. This means that newly
-written documentation should be tagged with a placeholder, that will
-be replaced with the actual version upon release. There are 2 styles
-of placeholders used through the documentation, you should pick one that
-fits your text better (if in doubt, take a look at the existing version
-tags for other features).
-  * `> [Introduced](link-to-issue-or-PR) in Catch X.Y.Z` - this
-  placeholder is usually used after a section heading
-  * `> X (Y and Z) was [introduced](link-to-issue-or-PR) in Catch X.Y.Z`
-  - this placeholder is used when you need to tag a subpart of something,
-  e.g. list
-* Crosslinks to different pages should target the `top` anchor, like this
-`[link to contributing](contributing.md#top)`.
-* If you have introduced a new document, there is a simple template you
-should use. It provides you with the top anchor mentioned above, and also
-with a backlink to the top of the documentation:
-```markdown
-<a id="top"></a>
-# Cool feature
-
-Text that explains how to use the cool feature.
-
-
----
-
-[Home](Readme.md#top)
-```
-* For pages with more than 4 subheadings, we provide a table of contents
-(ToC) at the top of the page. Because GitHub markdown does not support
-automatic generation of ToC, it has to be handled semi-manually. Thus,
-if you've added a new subheading to some page, you should add it to the
-ToC. This can be done either manually, or by running the
-`updateDocumentToC.py` script in the `scripts/` folder.
-
-
-Now, for the generic tips:
-  * Usage examples are good
-  * Don't be afraid to introduce new pages
-  * Try to be reasonably consistent with the surrounding documentation
-
-
-
-
 ## Code constructs to watch out for
 
 This section is a (sadly incomplete) listing of various constructs that

docs/deprecations.md

@@ -9,8 +9,58 @@ 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
@@ -19,12 +69,25 @@ 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/generators.md

@@ -1,8 +1,6 @@
 <a id="top"></a>
 # Data Generators
 
-> Introduced in Catch 2.6.0.
-
 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
@@ -36,8 +34,8 @@ Catch2's provided generator functionality consists of three parts,
 * `GENERATE` macro,  that serves to integrate generator expression with
 a test case,
 * 2 fundamental generators
-  * `SingleValueGenerator<T>` -- contains only single element
-  * `FixedValuesGenerator<T>` -- contains multiple elements
+  * `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"
@@ -46,22 +44,16 @@ a test case,
   * `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
-* 4 specific purpose generators
+* 3 specific purpose generators
   * `RandomIntegerGenerator<Integral>` -- generates random Integrals from range
   * `RandomFloatGenerator<Float>` -- generates random Floats from range
-  * `RangeGenerator<T>` -- generates all values inside an arithmetic range
-  * `IteratorGenerator<T>` -- copies and returns values from an iterator range
-
-> `ChunkGenerator<T>`, `RandomIntegerGenerator<Integral>`, `RandomFloatGenerator<Float>` and `RangeGenerator<T>` were introduced in Catch 2.7.0.
-
-> `IteratorGenerator<T>` was introduced in Catch 2.10.0.
+  * `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 `SingleValueGenerator<T>`
-* `values(std::initializer_list<T>)` for `FixedValuesGenerator<T>`
-* `table<Ts...>(std::initializer_list<std::tuple<Ts...>>)` for `FixedValuesGenerator<std::tuple<Ts...>>`
+* `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>`
@@ -69,16 +61,9 @@ type, making their usage much nicer. These are
 * `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(Arithemtic start, Arithmetic end)` for `RangeGenerator<Arithmetic>` with a step size of `1`
-* `range(Arithmetic start, Arithmetic end, Arithmetic step)` for `RangeGenerator<Arithmetic>` with a custom step size
-* `from_range(InputIterator from, InputIterator to)` for `IteratorGenerator<T>`
-* `from_range(Container const&)` for `IteratorGenerator<T>`
+* `range(start, end)` for `RangeGenerator<T>` with a step size of `1`
+* `range(start, end, step)` for `RangeGenerator<T>` with a custom step size
 
-> `chunk()`, `random()` and both `range()` functions were introduced in Catch 2.7.0.
-
-> `from_range` has been introduced in Catch 2.10.0
-
-> `range()` for floating point numbers has been introduced in Catch X.Y.Z
 
 And can be used as shown in the example below to create a generator
 that returns 100 odd random number:
@@ -99,7 +84,7 @@ 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 `SingleValueGenerator<int>` and then placed them all in
+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
@@ -111,8 +96,6 @@ 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`.**
 
-> `GENERATE_COPY` and `GENERATE_REF` were introduced in Catch 2.7.1.
-
 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`:

docs/limitations.md

@@ -45,15 +45,6 @@ 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.
 
 
-### MinGW/CygWin compilation (linking) is extremely slow
-
-Compiling Catch2 with MinGW can be exceedingly slow, especially during
-the linking step. As far as we can tell, this is caused by deficiencies
-in its default linker. If you can tell MinGW to instead use lld, via
-`-fuse-ld=lld`, the link time should drop down to reasonable length
-again.
-
-
 ## Features
 This section outlines some missing features, what is their status and their possible workarounds.
 

docs/list-of-examples.md

@@ -10,6 +10,8 @@
 - 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)

docs/logging.md

@@ -30,8 +30,6 @@ When the last `CHECK` fails in the "Bar" test case, then only one message will b
 
 ## Logging without local scope
 
-> [Introduced](https://github.com/catchorg/Catch2/issues/1522) in Catch 2.7.0.
-
 `UNSCOPED_INFO` is similar to `INFO` with two key differences:
 
 - Lifetime of an unscoped message is not tied to its own scope.
@@ -106,8 +104,6 @@ This semicolon will be removed with next major version. It is highly advised to
 
 **UNSCOPED_INFO(** _message expression_ **)**
 
-> [Introduced](https://github.com/catchorg/Catch2/issues/1522) in Catch 2.7.0.
-
 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.
 
 **WARN(** _message expression_ **)**

docs/matchers.md

@@ -12,57 +12,31 @@ The first argument is the thing (object or value) under test. The second part is
 which consists of either a single matcher or one or more matchers combined using `&&`, `||` or `!` operators.
 
 For example, to assert that a string ends with a certain substring:
-
+ 
  ```c++
 using Catch::Matchers::EndsWith; // or Catch::EndsWith
 std::string str = getStringFromSomewhere();
-REQUIRE_THAT( str, EndsWith( "as a service" ) );
-```
+REQUIRE_THAT( str, EndsWith( "as a service" ) ); 
+ ```
 
 The matcher objects can take multiple arguments, allowing more fine tuning.
 The built-in string matchers, for example, take a second argument specifying whether the comparison is
 case sensitive or not:
 
 ```c++
-REQUIRE_THAT( str, EndsWith( "as a service", Catch::CaseSensitive::No ) );
+REQUIRE_THAT( str, EndsWith( "as a service", Catch::CaseSensitive::No ) ); 
  ```
 
 And matchers can be combined:
 
 ```c++
-REQUIRE_THAT( str,
-    EndsWith( "as a service" ) ||
-    (StartsWith( "Big data" ) && !Contains( "web scale" ) ) );
+REQUIRE_THAT( str, 
+    EndsWith( "as a service" ) || 
+    (StartsWith( "Big data" ) && !Contains( "web scale" ) ) ); 
 ```
 
-_The combining operators do not take ownership of the matcher objects.
-This means that if you store the combined object, you have to ensure that
-the matcher objects outlive its last use. What this means is that code
-like this leads to a use-after-free and (hopefully) a crash:_
-
-```cpp
-TEST_CASE("Bugs, bugs, bugs", "[Bug]"){
-    std::string str = "Bugs as a service";
-
-    auto match_expression = Catch::EndsWith( "as a service" ) ||
-        (Catch::StartsWith( "Big data" ) && !Catch::Contains( "web scale" ) );
-    REQUIRE_THAT(str, match_expression);
-}
-```
-
-
 ## Built in matchers
-Catch2 provides some matchers by default. They can be found in the
-`Catch::Matchers::foo` namespace and are imported into the `Catch`
-namespace as well.
-
-There are two parts to each of the built-in matchers, the matcher
-type itself and a helper function that provides template argument
-deduction when creating templated matchers. As an example, the matcher
-for checking that two instances of `std::vector` are identical is
-`EqualsMatcher<T>`, but the user is expected to use the `Equals`
-helper function instead.
-
+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.
@@ -71,42 +45,13 @@ Each of the provided `std::string` matchers also takes an optional second argume
 
 
 ### Vector matchers
-Catch2 currently provides 5 built-in matchers that work on `std::vector`.
-These are
-
- * `Contains` which checks whether a specified vector is present in the result
- * `VectorContains` which checks whether a specified element is present in the result
- * `Equals` which checks whether the result is exactly equal (order matters) to a specific vector
- * `UnorderedEquals` which checks whether the result is equal to a specific vector under a permutation
- * `Approx` which checks whether the result is "approx-equal" (order matters, but comparison is done via `Approx`) to a specific vector
-> Approx matcher was [introduced](https://github.com/catchorg/Catch2/issues/1499) in Catch 2.7.2.
-
+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
-Catch2 provides 3 matchers for working with floating point numbers. These
-are `WithinAbsMatcher`, `WithinUlpsMatcher` and `WithinRelMatcher`.
+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.
 
-The `WithinAbsMatcher` matcher accepts floating point numbers that are
-within a certain distance of target. It should be constructed with the
-`WithinAbs(double target, double margin)` helper.
+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.
 
-The `WithinUlpsMatcher` matcher accepts floating point numbers that are
-within a certain number of [ULPs](https://en.wikipedia.org/wiki/Unit_in_the_last_place)
-of the target. Because ULP comparisons need to be done differently for
-`float`s and for `double`s, there are two overloads of the helpers for
-this matcher, `WithinULP(float target, int64_t ULPs)`, and
-`WithinULP(double target, int64_t ULPs)`.
-
-The `WithinRelMatcher` matcher accepts floating point numbers that are
-_approximately equal_ with the target number with some specific tolerance.
-In other words, it checks that `|lhs - rhs| <= epsilon * max(|lhs|, |rhs|)`,
-with special casing for `INFINITY` and `NaN`. There are _4_ overloads of
-the helpers for this matcher, `WithinRel(double target, double margin)`,
-`WithinRel(float target, float margin)`, `WithinRel(double target)`, and
-`WithinRel(float target)`. The latter two provide a default epsilon of
-machine epsilon * 100.
-
-> `WithinRel` matcher was introduced in Catch 2.10.0
 
 ### Generic matchers
 Catch also aims to provide a set of generic matchers. Currently this set
@@ -127,29 +72,13 @@ The second argument is an optional description of the predicate, and is
 used only during reporting of the result.
 
 
-### Exception matchers
-Catch2 also provides an exception matcher that can be used to verify
-that an exception's message exactly matches desired string. The matcher
-is `ExceptionMessageMatcher`, and we also provide a helper function
-`Message`.
-
-The matched exception must publicly derive from `std::exception` and
-the message matching is done _exactly_, including case.
-
-> `ExceptionMessageMatcher` was introduced in Catch 2.10.0
-
-Example use:
-```cpp
-REQUIRE_THROWS_MATCHES(throwsDerivedException(),  DerivedException,  Message("DerivedException::what"));
-```
-
 ## Custom matchers
 It's easy to provide your own matchers to extend Catch or just to work with your own types.
 
-You need to provide two things:
+You need to provide two things: 
 1. A matcher class, derived from `Catch::MatcherBase<T>` - where `T` is the type being tested.
 The constructor takes and stores any arguments needed (e.g. something to compare against) and you must
-override two methods: `match()` and `describe()`.
+override two methods: `match()` and `describe()`. 
 2. A simple builder function. This is what is actually called from the test code and allows overloading.
 
 Here's an example for asserting that an integer falls within a given range
@@ -194,7 +123,7 @@ TEST_CASE("Integers are within a range")
 ```
 
 Running this test gives the following in the console:
-
+ 
 ```
 /**/TestFile.cpp:123: FAILED:
   CHECK_THAT( 100, IsBetween( 1, 10 ) )

docs/opensource-users.md

@@ -23,9 +23,6 @@ C++11 implementation of Approval Tests, for quick, convenient testing of legacy
 ### [Azmq](https://github.com/zeromq/azmq)
 Boost Asio style bindings for ZeroMQ.
 
-### [Cataclysm: Dark Days Ahead](https://github.com/CleverRaven/Cataclysm-DDA)
-Post-apocalyptic survival RPG.
-
 ### [ChakraCore](https://github.com/Microsoft/ChakraCore)
 The core part of the Chakra JavaScript engine that powers Microsoft Edge.
 
@@ -53,6 +50,9 @@ 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++.
 
+### [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. 
 
@@ -112,9 +112,6 @@ SpECTRE is a code for multi-scale, multi-physics problems in astrophysics and gr
 ### [Standardese](https://github.com/foonathan/standardese)
 Standardese aims to be a nextgen Doxygen.
 
-### [PopHead](https://github.com/SPC-Some-Polish-Coders/PopHead)
-A 2D, Zombie, RPG game which is being made on our own engine.
-
 ---
 
 [Home](Readme.md#top)

docs/other-macros.md

@@ -59,8 +59,6 @@ TEST_CASE( "SUCCEED showcase" ) {
 
 * `STATIC_REQUIRE`
 
-> [Introduced](https://github.com/catchorg/Catch2/issues/1362) in Catch 2.4.2.
-
 `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
@@ -134,8 +132,6 @@ ANON_TEST_CASE() {
 
 * `DYNAMIC_SECTION`
 
-> Introduced in Catch 2.3.0.
-
 `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.

docs/release-notes.md

@@ -2,10 +2,6 @@
 
 # Release notes
 **Contents**<br>
-[2.10.2](#2102)<br>
-[2.10.1](#2101)<br>
-[2.10.0](#2100)<br>
-[2.9.2](#292)<br>
 [2.9.1](#291)<br>
 [2.9.0](#290)<br>
 [2.8.0](#280)<br>
@@ -30,149 +26,11 @@
 [Older versions](#older-versions)<br>
 [Even Older versions](#even-older-versions)<br>
 
-## 3.0.0 (in progress)
-
-### (Potentially) Breaking changes
-* `ANON_TEST_CASE` has been removed, use `TEST_CASE` with no arguments instead (#1220)
-* `--list*` commands no longer have non-zero return code (#1410)
-* `--list-test-names-only` has been removed (#1190)
-  * You should use verbosity-modifiers for `--list-tests` instead
-* `--list*` commands are now piped through the reporters
-  * The top-level reporter interface provides default implementation that works just as the old one
-  * XmlReporter outputs a machine-parseable XML
-* `TEST_CASE` description support has been removed
-  * If the second argument has text outside tags, the text will be ignored.
-* Hidden test cases are no longer included just because they don't match an exclusion tag
-  * Previously, a `TEST_CASE("A", "[.foo]")` would be included by asking for `~[bar]`.
-* `PredicateMatcher` is no longer type erased.
-  * This means that the type of the provided predicate is part of the `PredicateMatcher`'s type
-* `SectionInfo` no longer contains section description as a member (#1319)
-  * You can still write `SECTION("ShortName", "Long and wordy description")`, but the description is thrown away
-  * The description type now must be a `const char*` or implicitly convertible to it
-
-
-### Fixes
-* The `INFO` macro no longer contains superfluous semicolon (#1456)
-* The `--list*` family of command line flags now return 0 on success (#1410, #1146)
-
-
-## 2.10.2
-
-### Improvements
-* Catch2 will now compile on platform where `INFINITY` is double (#1782)
-
-
-### Fixes
-* Warning suppressed during listener registration will no longer leak
-
-
-
-## 2.10.1
-
-### Improvements
-* Catch2 now guards itself against `min` and `max` macros from `windows.h` (#1772)
-* Templated tests will now compile with ICC (#1748)
-* `WithinULP` matcher now uses scientific notation for stringification (#1760)
-
-
-### Fixes
-* Templated tests no longer trigger `-Wunused-templates` (#1762)
-* Suppressed clang-analyzer false positive in context getter (#1230, #1735)
-
-
-### Miscellaneous
-* CMake no longer prohibits in-tree build when Catch2 is used as a subproject (#1773, #1774)
-
-
-
-## 2.10.0
-
-### Fixes
-* `TEMPLATE_LIST_TEST_CASE` now properly handles non-copyable and non-movable types (#1729)
-* Fixed compilation error on Solaris caused by a system header defining macro `TT` (#1722, #1723)
-* `REGISTER_ENUM` will now fail at compilation time if the registered enum is too large
-* Removed use of `std::is_same_v` in C++17 mode (#1757)
-* Fixed parsing of escaped special characters when reading test specs from a file (#1767, #1769)
-
-
-### Improvements
-* Trailing and leading whitespace in test/section specs are now ignored.
-* Writing to Android debug log now uses `__android_log_write` instead of `__android_log_print`
-* Android logging support can now be turned on/off at compile time (#1743)
-  * The toggle is `CATCH_CONFIG_ANDROID_LOGWRITE`
-* Added a generator that returns elements of a range
-  * Use via `from_range(from, to)` or `from_range(container)`
-* Added support for CRTs that do not provide `std::nextafter` (#1739)
-  * They must still provide global `nextafter{f,l,}`
-  * Enabled via `CATCH_CONFIG_GLOBAL_NEXTAFTER`
-* Special cased `Approx(inf)` not to match non-infinite values
-  * Very strictly speaking this might be a breaking change, but it should match user expectations better
-* The output of benchmarking through the Console reporter when `--benchmark-no-analysis` is set is now much simpler (#1768)
-* Added a matcher that can be used for checking an exceptions message (#1649, #1728)
-  * The matcher helper function is called `Message`
-  * The exception must publicly derive from `std::exception`
-  * The matching is done exactly, including case and whitespace
-* Added a matcher that can be used for checking relative equality of floating point numbers (#1746)
-  * Unlike `Approx`, it considers both sides when determining the allowed margin
-  * Special cases `NaN` and `INFINITY` to match user expectations
-  * The matcher helper function is called `WithinRel`
-* The ULP matcher now allows for any possible distance between the two numbers
-* The random number generators now use Catch-global instance of RNG (#1734, #1736)
-  * This means that nested random number generators actually generate different numbers
-
-
-### Miscellaneous
-* In-repo PNGs have been optimized to lower overhead of using Catch2 via git clone
-* Catch2 now uses its own implementation of the URBG concept
-  * In the future we also plan to use our own implementation of the distributions from `<random>` to provide cross-platform repeatability of random results
-
-
-
-## 2.9.2
-
-### Fixes
-* `ChunkGenerator` can now be used with chunks of size 0 (#1671)
-* Nested subsections are now run properly when specific section is run via the `-c` argument (#1670, #1673)
-* Catch2 now consistently uses `_WIN32` to detect Windows platform (#1676)
-* `TEMPLATE_LIST_TEST_CASE` now support non-default constructible type lists (#1697)
-* Fixed a crash in the XMLReporter when a benchmark throws exception during warmup (#1706)
-* Fixed a possible infinite loop in CompactReporter (#1715)
-* Fixed `-w NoTests` returning 0 even when no tests were matched (#1449, #1683, #1684)
-* Fixed matcher compilation under Obj-C++ (#1661)
-
-### Improvements
-* `RepeatGenerator` and `FixedValuesGenerator` now fail to compile when used with `bool` (#1692)
-  * Previously they would fail at runtime.
-* Catch2 now supports Android's debug logging for its debug output (#1710)
-* Catch2 now detects and configures itself for the RTX platform (#1693)
-  * You still need to pass `--benchmark-no-analysis` if you are using benchmarking under RTX
-* Removed a "storage class is not first" warning when compiling Catch2 with PGI compiler (#1717)
-
-### Miscellaneous
-* Documentation now contains indication when a specific feature was introduced (#1695)
-  * These start with Catch2 v2.3.0, (a bit over a year ago).
-  * `docs/contributing.md` has been updated to provide contributors guidance on how to add these to newly written documentation
-* Various other documentation improvements
-  * ToC fixes
-  * Documented `--order` and `--rng-seed` command line options
-  * Benchmarking documentation now clearly states that it requires opt-in
-  * Documented `CATCH_CONFIG_CPP17_OPTIONAL` and `CATCH_CONFIG_CPP17_BYTE` macros
-  * Properly documented built-in vector matchers
-  * Improved `*_THROWS_MATCHES` documentation a bit
-* CMake config file is now arch-independent even if `CMAKE_SIZEOF_VOID_P` is in CMake cache (#1660)
-* `CatchAddTests` now properly escapes `[` and `]` in test names (#1634, #1698)
-* Reverted `CatchAddTests` adding tags as CTest labels (#1658)
-  * The script broke when test names were too long
-  * Overwriting `LABELS` caused trouble for users who set them manually
-  * CMake does not let users append to `LABELS` if the test name has spaces
-
-
 ## 2.9.1
 
 ### Fixes
 * Fix benchmarking compilation failure in files without `CATCH_CONFIG_EXTERNAL_INTERFACES` (or implementation)
 
-
 ## 2.9.0
 
 ### Improvements
@@ -230,7 +88,7 @@
 
 ### Improvements
 * Reporters now print out the filters applied to test cases (#1550, #1585)
-* Added `GENERATE_COPY` and `GENERATE_REF` macros that can use variables inside the generator expression
+* 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)
 

docs/release-process.md

@@ -1,7 +1,7 @@
 <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 `tools/scripts/` directory.
+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.
 
 ## Necessary steps
 
@@ -42,8 +42,8 @@ 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, SonarQube) should also be attached as binaries, as they might be
+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.
 
 Since 2.5.0, the release tag and the "binaries" (headers) should be PGP

docs/reporters.md

@@ -29,7 +29,6 @@ Do this in one source file - the same one you have `CATCH_CONFIG_MAIN` or `CATCH
 Use this when building as part of a TeamCity build to see results as they happen ([code example](../examples/207-Rpt-TeamCityReporter.cpp)).
 * `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
-* `sonarqube` writes the [SonarQube Generic Test Data](https://docs.sonarqube.org/latest/analysis/generic-test/) XML format.
 
 You see what reporters are available from the command line by running with `--list-reporters`.
 

docs/test-cases-and-sections.md

@@ -15,17 +15,9 @@ Instead Catch provides a powerful mechanism for nesting test case sections withi
 Test cases and sections are very easy to use in practice:
 
 * **TEST_CASE(** _test name_ \[, _tags_ \] **)**
-* **SECTION(** _section name_, \[, _section description_ \] **)**
+* **SECTION(** _section name_ **)**
 
-
-_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, and are discussed below.
-_section description_ can be used to provide long form description
-of a section while keeping the _section name_ short for use with the
-[`-c` command line parameter](command-line.md#specify-the-section-to-run).
-
-**Test names must be unique within the Catch executable.**
+_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)
 
@@ -92,13 +84,10 @@ This macro maps onto ```TEST_CASE``` and works in the same way, except that the
 
 These macros map onto ```SECTION```s except that the section names are the _something_s prefixed by "given: ", "when: " or "then: " respectively.
 
-* **AND_GIVEN(** _something_ **)**
 * **AND_WHEN(** _something_ **)**
 * **AND_THEN(** _something_ **)**
 
-Similar to ```GIVEN```, ```WHEN``` and ```THEN``` except that the prefixes start with "and ". These are used to chain ```GIVEN```s, ```WHEN```s and ```THEN```s together.
-
-> `AND_GIVEN` was [introduced](https://github.com/catchorg/Catch2/issues/1360) in Catch 2.4.0.
+Similar to ```WHEN``` and ```THEN``` except that the prefixes start with "and ". These are used to chain ```WHEN```s and ```THEN```s together.
 
 When any of these macros are used the console reporter recognises them and formats the test case header such that the Givens, Whens and Thens are aligned to aid readability.
 
@@ -112,8 +101,6 @@ by types, in the form of `TEMPLATE_TEST_CASE`,
 
 * **TEMPLATE_TEST_CASE(** _test name_ , _tags_,  _type1_, _type2_, ..., _typen_ **)**
 
-> [Introduced](https://github.com/catchorg/Catch2/issues/1437) in Catch 2.5.0.
-
 _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
@@ -164,8 +151,6 @@ TEMPLATE_TEST_CASE( "vectors can be sized and resized", "[vector][template]", in
 
 * **TEMPLATE_PRODUCT_TEST_CASE(** _test name_ , _tags_, (_template-type1_, _template-type2_, ..., _template-typen_), (_template-arg1_, _template-arg2_, ..., _template-argm_) **)**
 
-> [Introduced](https://github.com/catchorg/Catch2/issues/1468) in Catch 2.6.0.
-
 _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,
@@ -209,8 +194,6 @@ is very high and should not be encountered in practice._
 
 * **TEMPLATE_LIST_TEST_CASE(** _test name_, _tags_, _type list_ **)**
 
-> [Introduced](https://github.com/catchorg/Catch2/issues/1627) in Catch 2.9.0.
-
 _type list_ is a generic list of types on which test case should be instantiated.
 List can be `std::tuple`, `boost::mpl::list`, `boost::mp11::mp_list` or anything with
 `template <typename...>` signature.
@@ -229,8 +212,6 @@ TEMPLATE_LIST_TEST_CASE("Template test case with test types specified inside std
 
 ## Signature based parametrised test cases
 
-> [Introduced](https://github.com/catchorg/Catch2/issues/1609) in Catch 2.8.0.
-
 In addition to [type parametrised test cases](#type-parametrised-test-cases) Catch2 also supports
 signature base parametrised test cases, in form of `TEMPLATE_TEST_CASE_SIG` and `TEMPLATE_PRODUCT_TEST_CASE_SIG`.
 These test cases have similar syntax like [type parametrised test cases](#type-parametrised-test-cases), with one

docs/test-fixtures.md

@@ -1,8 +1,6 @@
 <a id="top"></a>
 # Test fixtures
 
-## Defining 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++
@@ -86,9 +84,6 @@ _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._
 
-## Signature-based parametrised test fixtures
-
-> [Introduced](https://github.com/catchorg/Catch2/issues/1609) in Catch 2.8.0.
 
 Catch2 also provides `TEMPLATE_TEST_CASE_METHOD_SIG` and `TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG` to support
 fixtures using non-type template parameters. These test cases work similar to `TEMPLATE_TEST_CASE_METHOD` and `TEMPLATE_PRODUCT_TEST_CASE_METHOD`,
@@ -105,13 +100,6 @@ TEMPLATE_TEST_CASE_METHOD_SIG(Nttp_Fixture, "A TEMPLATE_TEST_CASE_METHOD_SIG bas
     REQUIRE(Nttp_Fixture<V>::value > 0);
 }
 
-template<typename T>
-struct Template_Fixture_2 {
-    Template_Fixture_2() {}
-
-    T m_a;
-};
-
 template< typename T, size_t V>
 struct Template_Foo_2 {
     size_t size() { return V; }
@@ -123,8 +111,6 @@ TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG(Template_Fixture_2, "A TEMPLATE_PRODUCT_TE
 }
 ```
 
-## Template fixtures with types specified in template type lists
-
 Catch2 also provides `TEMPLATE_LIST_TEST_CASE_METHOD` to support template fixtures with types specified in
 template type lists like `std::tuple`, `boost::mpl::list` or `boost::mp11::mp_list`. This test case works the same as `TEMPLATE_TEST_CASE_METHOD`,
 only difference is the source of types. This allows you to reuse the template type list in multiple test cases.

docs/tostring.md

@@ -71,8 +71,6 @@ CATCH_TRANSLATE_EXCEPTION( MyType& ex ) {
 
 ## Enums
 
-> Introduced in Catch 2.8.0.
-
 Enums that already have a `<<` overload for `std::ostream` will convert to strings as expected.
 If you only need to convert enums to strings for test reporting purposes you can provide a `StringMaker` specialisations as any other type.
 However, as a convenience, Catch provides the `REGISTER_ENUM` helper macro that will generate the `StringMaker` specialiation for you with minimal code.
@@ -110,8 +108,6 @@ TEST_CASE() {
 
 ## Floating point precision
 
-> [Introduced](https://github.com/catchorg/Catch2/issues/1614) in Catch 2.8.0.
-
 Catch provides a built-in `StringMaker` specialization for both `float`
 and `double`. By default, it uses what we think is a reasonable precision,
 but you can customize it by modifying the `precision` static variable

examples/000-CatchMain.cpp

@@ -1,10 +1,12 @@
 // 000-CatchMain.cpp
 
-// It is generally recommended to have a single file provide the main
-// of a testing binary, and other test files to link against it.
+// 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():
-#include <catch2/catch_default_main.hpp>
+#define CATCH_CONFIG_MAIN
+
+#include <catch2/catch.hpp>
 
 // That's it
 

examples/010-TestCase.cpp

@@ -1,9 +1,8 @@
 // 010-TestCase.cpp
 
 // Let Catch provide main():
-#include <catch2/catch_default_main.hpp>
+#define CATCH_CONFIG_MAIN
 
-// And write tests in the same file:
 #include <catch2/catch.hpp>
 
 int Factorial( int number ) {

examples/020-TestCase-1.cpp

@@ -4,7 +4,7 @@
 // source code of Catch itself and reuse the resulting object file for linking.
 
 // Let Catch provide main():
-#include <catch2/catch_default_main.hpp>
+#define CATCH_CONFIG_MAIN
 
 #include <catch2/catch.hpp>
 

examples/200-Rpt-CatchMain.cpp

@@ -0,0 +1,27 @@
+// 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

@@ -0,0 +1,171 @@
+// 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

@@ -21,10 +21,6 @@ std::string ws(int const level) {
     return std::string( 2 * level, ' ' );
 }
 
-std::ostream& operator<<(std::ostream& out, Catch::Tag t) {
-    return out << "original: " << t.original << "lower cased: " << t.lowerCased;
-}
-
 template< typename T >
 std::ostream& operator<<( std::ostream& os, std::vector<T> const& v ) {
     os << "{ ";
@@ -123,36 +119,32 @@ void print( std::ostream& os, int const level, std::string const& title, Catch::
     os << ws(level+1) << "- aborting: " << info.aborting << "\n";
 }
 
-//    struct Tag {
-//        StringRef original, lowerCased;
-//    };
+// 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;
 //
-//    enum class TestCaseProperties : uint8_t {
-//        None = 0,
-//        IsHidden = 1 << 1,
-//        ShouldFail = 1 << 2,
-//        MayFail = 1 << 3,
-//        Throws = 1 << 4,
-//        NonPortable = 1 << 5,
-//        Benchmark = 1 << 6
-//    };
+//     std::string tagsAsString() const;
 //
-//
-//    struct TestCaseInfo : NonCopyable {
-//
-//        bool isHidden() const;
-//        bool throws() const;
-//        bool okToFail() const;
-//        bool expectedToFail() const;
-//
-//
-//        std::string name;
-//        std::string className;
-//        std::vector<Tag> tags;
-//        SourceLineInfo lineInfo;
-//        TestCaseProperties properties = TestCaseProperties::None;
-//    };
+//     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"
@@ -163,9 +155,11 @@ void print( std::ostream& os, int const level, std::string const& title, Catch::
        << ws(level+1) << "- tagsAsString(): '"  << info.tagsAsString() << "'\n"
        << ws(level+1) << "- name: '"            << info.name << "'\n"
        << ws(level+1) << "- className: '"       << info.className << "'\n"
-       << ws(level+1) << "- tags: "             << info.tags << "\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 << static_cast<uint32_t>(info.properties) << std::dec << "\n";
+    os << ws(level+1) << "- properties (flags): 0x" << std::hex << info.properties << std::dec << "\n";
 }
 
 // struct TestCaseStats {
@@ -178,7 +172,7 @@ void print( std::ostream& os, int const level, std::string const& title, Catch::
 
 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 , "- 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"

examples/231-Cfg-OutputStreams.cpp

@@ -6,18 +6,15 @@
 // there is no important difference between having `std::cerr` buffered
 // or unbuffered.
 
-#include <catch2/catch_default_main.hpp>
-
+#define CATCH_CONFIG_NOSTDOUT
+#define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 
-#include <sstream>
-#include <cstdio>
-
 class out_buff : public std::stringbuf {
     std::FILE* m_stream;
 public:
-    out_buff(std::FILE* stream):m_stream(stream) {}
-    ~out_buff();
+    out_buff(std::FILE* stream) :m_stream(stream) {}
+    ~out_buff() { pubsync(); }
     int sync() {
         int ret = 0;
         for (unsigned char c : str()) {
@@ -32,12 +29,6 @@ public:
     }
 };
 
-out_buff::~out_buff() { pubsync(); }
-
-#if defined(__clang__)
-#pragma clang diagnostic ignored "-Wexit-time-destructors" // static variables in cout/cerr/clog
-#endif
-
 namespace Catch {
     std::ostream& cout() {
         static std::ostream ret(new out_buff(stdout));

examples/301-Gen-MapTypeConversion.cpp

@@ -22,17 +22,15 @@ public:
         }
     }
 
-    std::string const& get() const override;
+    std::string const& get() const override {
+        return m_line;
+    }
     
     bool next() override {
         return !!std::getline(m_stream, m_line);
     }
 };
 
-std::string const& LineGenerator::get() const {
-    return 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>>.

examples/CMakeLists.txt

@@ -1,30 +1,44 @@
-cmake_minimum_required( VERSION 3.5 )
+#
+# Build examples.
+#
+# Requires CATCH_BUILD_EXAMPLES to be defined 'true', see ../CMakeLists.txt.
+#
 
-project( Catch2Examples LANGUAGES CXX )
+cmake_minimum_required( VERSION 3.0 )
+
+project( CatchExamples CXX )
 
 message( STATUS "Examples included" )
 
+# define folders used:
 
-# Some one-offs first:
-# 1) Tests and main in one file
-add_executable( 010-TestCase
-  010-TestCase.cpp
-)
+set( EXAMPLES_DIR ${CATCH_DIR}/examples )
+set( HEADER_DIR   ${CATCH_DIR}/single_include )
+set( REPORTER_HEADER_DIR ${CATCH_DIR}/include/reporters )
 
-# 2) Tests and main across two files
-add_executable( 020-MultiFile
-  020-TestCase-1.cpp
-  020-TestCase-2.cpp
-)
+# single-file sources:
 
-add_executable(231-Cfg_OutputStreams
+set( SOURCES_SINGLE_FILE
+    010-TestCase.cpp
     231-Cfg-OutputStreams.cpp
 )
-target_link_libraries(231-Cfg_OutputStreams Catch2_buildall_interface)
-target_compile_definitions(231-Cfg_OutputStreams PUBLIC CATCH_CONFIG_NOSTDOUT)
 
-# These examples use the standard separate compilation
-set( SOURCES_IDIOMATIC_EXAMPLES
+# 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
@@ -36,25 +50,95 @@ set( SOURCES_IDIOMATIC_EXAMPLES
     311-Gen-CustomCapture.cpp
 )
 
-string( REPLACE ".cpp" "" BASENAMES_IDIOMATIC_EXAMPLES "${SOURCES_IDIOMATIC_EXAMPLES}" )
-set( TARGETS_IDIOMATIC_EXAMPLES ${BASENAMES_IDIOMATIC_EXAMPLES} )
+# main-s for reporter-specific test sources:
 
-
-foreach( name ${TARGETS_IDIOMATIC_EXAMPLES} )
-    add_executable( ${name}
-      000-CatchMain.cpp
-      ${EXAMPLES_DIR}/${name}.cpp )
-endforeach()
-
-set(ALL_EXAMPLE_TARGETS
-  ${TARGETS_IDIOMATIC_EXAMPLES}
-  010-TestCase
-  020-MultiFile
+set( SOURCES_REPORTERS_MAIN
+    200-Rpt-CatchMain.cpp
 )
 
-foreach( name ${ALL_EXAMPLE_TARGETS} )
-    target_link_libraries( ${name} Catch2 )
-    set_property(TARGET ${name} PROPERTY CXX_STANDARD 14)
+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
@@ -70,3 +154,4 @@ foreach( name ${ALL_EXAMPLE_TARGETS} )
         target_compile_options( ${name}  PRIVATE /W4 /w44265 /WX )
     endif()
 endforeach()
+

include/catch.hpp

@@ -10,8 +10,8 @@
 #define TWOBLUECUBES_CATCH_HPP_INCLUDED
 
 #define CATCH_VERSION_MAJOR 2
-#define CATCH_VERSION_MINOR 10
-#define CATCH_VERSION_PATCH 2
+#define CATCH_VERSION_MINOR 9
+#define CATCH_VERSION_PATCH 1
 
 #ifdef __clang__
 #    pragma clang system_header
@@ -19,45 +19,81 @@
 #    pragma GCC system_header
 #endif
 
-#include <catch2/catch_suppress_warnings.h>
+#include "internal/catch_suppress_warnings.h"
+
+#if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)
+#  define CATCH_IMPL
+#  define CATCH_CONFIG_ALL_PARTS
+#endif
+
+// In the impl file, we want to have access to all parts of the headers
+// Can also be used to sanely support PCHs
+#if defined(CATCH_CONFIG_ALL_PARTS)
+#  define CATCH_CONFIG_EXTERNAL_INTERFACES
+#  if defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#    undef CATCH_CONFIG_DISABLE_MATCHERS
+#  endif
+#  if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
+#    define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
+#  endif
+#endif
 
 #if !defined(CATCH_CONFIG_IMPL_ONLY)
-#include <catch2/catch_platform.h>
+#include "internal/catch_platform.h"
 
-#include <catch2/catch_user_interfaces.h>
-#include <catch2/catch_tag_alias_autoregistrar.h>
-#include <catch2/catch_test_registry.h>
-#include <catch2/catch_capture.hpp>
-#include <catch2/catch_section.h>
-#include <catch2/catch_interfaces_exception.h>
-#include <catch2/catch_approx.h>
-#include <catch2/catch_compiler_capabilities.h>
-#include <catch2/catch_string_manip.h>
+#ifdef CATCH_IMPL
+#  ifndef CLARA_CONFIG_MAIN
+#    define CLARA_CONFIG_MAIN_NOT_DEFINED
+#    define CLARA_CONFIG_MAIN
+#  endif
+#endif
+
+#include "internal/catch_user_interfaces.h"
+#include "internal/catch_tag_alias_autoregistrar.h"
+#include "internal/catch_test_registry.h"
+#include "internal/catch_capture.hpp"
+#include "internal/catch_section.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 <catch2/catch_capture_matchers.h>
+#include "internal/catch_capture_matchers.h"
 #endif
-#include <catch2/catch_generators.hpp>
-#include <catch2/catch_generators_generic.hpp>
-#include <catch2/catch_generators_specific.hpp>
+#include "internal/catch_generators.hpp"
+#include "internal/catch_generators_generic.hpp"
+#include "internal/catch_generators_specific.hpp"
 
 // These files are included here so the single_include script doesn't put them
 // in the conditionally compiled sections
-#include <catch2/catch_test_case_info.h>
-#include <catch2/catch_interfaces_runner.h>
+#include "internal/catch_test_case_info.h"
+#include "internal/catch_interfaces_runner.h"
 
 #ifdef __OBJC__
-#include <catch2/catch_objc.hpp>
+#include "internal/catch_objc.hpp"
 #endif
 
-#include <catch2/catch_external_interfaces.h>
+// Benchmarking needs the externally-facing parts of reporters to work
+#if defined(CATCH_CONFIG_EXTERNAL_INTERFACES) || defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+#include "internal/catch_external_interfaces.h"
+#endif
 
 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-#include <catch2/benchmark/catch_benchmark.hpp>
+#include "internal/benchmark/catch_benchmark.hpp"
 #endif
 
 #endif // ! CATCH_CONFIG_IMPL_ONLY
 
+#ifdef CATCH_IMPL
+#include "internal/catch_impl.hpp"
+#endif
+
+#ifdef CATCH_CONFIG_MAIN
+#include "internal/catch_default_main.hpp"
+#endif
+
+
 #if !defined(CATCH_CONFIG_IMPL_ONLY)
 
 #ifdef CLARA_CONFIG_MAIN_NOT_DEFINED
@@ -115,6 +151,8 @@
 #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_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
@@ -211,6 +249,7 @@
 #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__ )
@@ -321,6 +360,8 @@ using Catch::Detail::Approx;
 #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(__VA_ARGS__)
 #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
@@ -403,6 +444,7 @@ using Catch::Detail::Approx;
 #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(__VA_ARGS__)
@@ -449,6 +491,6 @@ using Catch::Detail::Approx;
 
 #endif // ! CATCH_CONFIG_IMPL_ONLY
 
-#include <catch2/catch_reenable_warnings.h>
+#include "internal/catch_reenable_warnings.h"
 
 #endif // TWOBLUECUBES_CATCH_HPP_INCLUDED

include/catch_with_main.hpp

@@ -0,0 +1,14 @@
+ /*
+ *  Created by Phil on 01/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_WITH_MAIN_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_WITH_MAIN_HPP_INCLUDED
+
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"
+
+#endif // TWOBLUECUBES_CATCH_WITH_MAIN_HPP_INCLUDED

include/internal/benchmark/catch_benchmark.hpp

@@ -10,20 +10,20 @@
 #ifndef TWOBLUECUBES_CATCH_BENCHMARK_HPP_INCLUDED
 #define TWOBLUECUBES_CATCH_BENCHMARK_HPP_INCLUDED
 
-#include <catch2/catch_config.hpp>
-#include <catch2/catch_context.h>
-#include <catch2/catch_interfaces_reporter.h>
-#include <catch2/catch_test_registry.h>
+#include "../catch_config.hpp"
+#include "../catch_context.h"
+#include "../catch_interfaces_reporter.h"
+#include "../catch_test_registry.h"
 
-#include <catch2/benchmark/catch_chronometer.hpp>
-#include <catch2/benchmark/catch_clock.hpp>
-#include <catch2/benchmark/catch_environment.hpp>
-#include <catch2/benchmark/catch_execution_plan.hpp>
-#include <catch2/benchmark/detail/catch_estimate_clock.hpp>
-#include <catch2/benchmark/detail/catch_complete_invoke.hpp>
-#include <catch2/benchmark/detail/catch_analyse.hpp>
-#include <catch2/benchmark/detail/catch_benchmark_function.hpp>
-#include <catch2/benchmark/detail/catch_run_for_at_least.hpp>
+#include "catch_chronometer.hpp"
+#include "catch_clock.hpp"
+#include "catch_environment.hpp"
+#include "catch_execution_plan.hpp"
+#include "detail/catch_estimate_clock.hpp"
+#include "detail/catch_complete_invoke.hpp"
+#include "detail/catch_analyse.hpp"
+#include "detail/catch_benchmark_function.hpp"
+#include "detail/catch_run_for_at_least.hpp"
 
 #include <algorithm>
 #include <functional>

include/internal/benchmark/catch_chronometer.hpp

@@ -11,10 +11,10 @@
 #ifndef TWOBLUECUBES_CATCH_CHRONOMETER_HPP_INCLUDED
 #define TWOBLUECUBES_CATCH_CHRONOMETER_HPP_INCLUDED
 
-#include <catch2/benchmark/catch_clock.hpp>
-#include <catch2/benchmark/catch_optimizer.hpp>
-#include <catch2/benchmark/detail/catch_complete_invoke.hpp>
-#include <catch2/catch_meta.hpp>
+#include "catch_clock.hpp"
+#include "catch_optimizer.hpp"
+#include "detail/catch_complete_invoke.hpp"
+#include "../catch_meta.hpp"
 
 namespace Catch {
     namespace Benchmark {

include/internal/benchmark/catch_environment.hpp

@@ -11,8 +11,8 @@
 #ifndef TWOBLUECUBES_CATCH_ENVIRONMENT_HPP_INCLUDED
 #define TWOBLUECUBES_CATCH_ENVIRONMENT_HPP_INCLUDED
 
-#include <catch2/benchmark/catch_clock.hpp>
-#include <catch2/benchmark/catch_outlier_classification.hpp>
+#include "catch_clock.hpp"
+#include "catch_outlier_classification.hpp"
 
 namespace Catch {
     namespace Benchmark {

include/internal/benchmark/catch_execution_plan.hpp

@@ -11,12 +11,12 @@
 #ifndef TWOBLUECUBES_CATCH_EXECUTION_PLAN_HPP_INCLUDED
 #define TWOBLUECUBES_CATCH_EXECUTION_PLAN_HPP_INCLUDED
 
-#include <catch2/catch_config.hpp>
-#include <catch2/benchmark/catch_clock.hpp>
-#include <catch2/benchmark/catch_environment.hpp>
-#include <catch2/benchmark/detail/catch_benchmark_function.hpp>
-#include <catch2/benchmark/detail/catch_repeat.hpp>
-#include <catch2/benchmark/detail/catch_run_for_at_least.hpp>
+#include "../catch_config.hpp"
+#include "catch_clock.hpp"
+#include "catch_environment.hpp"
+#include "detail/catch_benchmark_function.hpp"
+#include "detail/catch_repeat.hpp"
+#include "detail/catch_run_for_at_least.hpp"
 
 #include <algorithm>
 

include/internal/benchmark/catch_sample_analysis.hpp

@@ -11,9 +11,9 @@
 #ifndef TWOBLUECUBES_CATCH_BENCHMARK_RESULTS_HPP_INCLUDED
 #define TWOBLUECUBES_CATCH_BENCHMARK_RESULTS_HPP_INCLUDED
 
-#include <catch2/benchmark/catch_clock.hpp>
-#include <catch2/benchmark/catch_estimate.hpp>
-#include <catch2/benchmark/catch_outlier_classification.hpp>
+#include "catch_clock.hpp"
+#include "catch_estimate.hpp"
+#include "catch_outlier_classification.hpp"
 
 #include <algorithm>
 #include <vector>

include/internal/benchmark/detail/catch_analyse.hpp

@@ -11,9 +11,9 @@
 #ifndef TWOBLUECUBES_CATCH_DETAIL_ANALYSE_HPP_INCLUDED
 #define TWOBLUECUBES_CATCH_DETAIL_ANALYSE_HPP_INCLUDED
 
-#include <catch2/benchmark/catch_clock.hpp>
-#include <catch2/benchmark/catch_sample_analysis.hpp>
-#include <catch2/benchmark/detail/catch_stats.hpp>
+#include "../catch_clock.hpp"
+#include "../catch_sample_analysis.hpp"
+#include "catch_stats.hpp"
 
 #include <algorithm>
 #include <iterator>

include/internal/benchmark/detail/catch_benchmark_function.hpp

@@ -11,9 +11,9 @@
 #ifndef TWOBLUECUBES_CATCH_DETAIL_BENCHMARK_FUNCTION_HPP_INCLUDED
 #define TWOBLUECUBES_CATCH_DETAIL_BENCHMARK_FUNCTION_HPP_INCLUDED
 
-#include <catch2/benchmark/catch_chronometer.hpp>
-#include <catch2/benchmark/detail/catch_complete_invoke.hpp>
-#include <catch2/catch_meta.hpp>
+#include "../catch_chronometer.hpp"
+#include "catch_complete_invoke.hpp"
+#include "../../catch_meta.hpp"
 
 #include <cassert>
 #include <type_traits>

include/internal/benchmark/detail/catch_complete_invoke.hpp

@@ -11,7 +11,7 @@
 #ifndef TWOBLUECUBES_CATCH_DETAIL_COMPLETE_INVOKE_HPP_INCLUDED
 #define TWOBLUECUBES_CATCH_DETAIL_COMPLETE_INVOKE_HPP_INCLUDED
 
-#include <catch2/catch_enforce.h>
+#include "../../catch_enforce.h"
 
 #include <type_traits>
 #include <utility>

include/internal/benchmark/detail/catch_estimate_clock.hpp

@@ -11,12 +11,12 @@
 #ifndef TWOBLUECUBES_CATCH_DETAIL_ESTIMATE_CLOCK_HPP_INCLUDED
 #define TWOBLUECUBES_CATCH_DETAIL_ESTIMATE_CLOCK_HPP_INCLUDED
 
-#include <catch2/benchmark/catch_clock.hpp>
-#include <catch2/benchmark/catch_environment.hpp>
-#include <catch2/benchmark/detail/catch_stats.hpp>
-#include <catch2/benchmark/detail/catch_measure.hpp>
-#include <catch2/benchmark/detail/catch_run_for_at_least.hpp>
-#include <catch2/benchmark/catch_clock.hpp>
+#include "../catch_clock.hpp"
+#include "../catch_environment.hpp"
+#include "catch_stats.hpp"
+#include "catch_measure.hpp"
+#include "catch_run_for_at_least.hpp"
+#include "../catch_clock.hpp"
 
 #include <algorithm>
 #include <iterator>

include/internal/benchmark/detail/catch_measure.hpp

@@ -11,9 +11,9 @@
 #ifndef TWOBLUECUBES_CATCH_DETAIL_MEASURE_HPP_INCLUDED
 #define TWOBLUECUBES_CATCH_DETAIL_MEASURE_HPP_INCLUDED
 
-#include <catch2/benchmark/catch_clock.hpp>
-#include <catch2/benchmark/detail/catch_complete_invoke.hpp>
-#include <catch2/benchmark/detail/catch_timing.hpp>
+#include "../catch_clock.hpp"
+#include "catch_complete_invoke.hpp"
+#include "catch_timing.hpp"
 
 #include <utility>
 

include/internal/benchmark/detail/catch_run_for_at_least.hpp

@@ -11,12 +11,12 @@
 #ifndef TWOBLUECUBES_CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED
 #define TWOBLUECUBES_CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED
 
-#include <catch2/benchmark/catch_clock.hpp>
-#include <catch2/benchmark/catch_chronometer.hpp>
-#include <catch2/benchmark/detail/catch_measure.hpp>
-#include <catch2/benchmark/detail/catch_complete_invoke.hpp>
-#include <catch2/benchmark/detail/catch_timing.hpp>
-#include <catch2/catch_meta.hpp>
+#include "../catch_clock.hpp"
+#include "../catch_chronometer.hpp"
+#include "catch_measure.hpp"
+#include "catch_complete_invoke.hpp"
+#include "catch_timing.hpp"
+#include "../../catch_meta.hpp"
 
 #include <utility>
 #include <type_traits>

include/internal/benchmark/detail/catch_stats.cpp

@@ -10,9 +10,9 @@
 
 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
 
-#include <catch2/benchmark/detail/catch_stats.hpp>
+#include "catch_stats.hpp"
 
-#include <catch2/catch_compiler_capabilities.h>
+#include "../../catch_compiler_capabilities.h"
 
 #include <cassert>
 #include <random>
@@ -176,10 +176,9 @@ namespace Catch {
 
 
             bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last) {
-                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
                 CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
                 static std::random_device entropy;
-                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+                CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
 
                 auto n = static_cast<int>(last - first); // seriously, one can't use integral types without hell in C++
 

include/internal/benchmark/detail/catch_stats.hpp

@@ -11,9 +11,9 @@
 #ifndef TWOBLUECUBES_CATCH_DETAIL_ANALYSIS_HPP_INCLUDED
 #define TWOBLUECUBES_CATCH_DETAIL_ANALYSIS_HPP_INCLUDED
 
-#include <catch2/benchmark/catch_clock.hpp>
-#include <catch2/benchmark/catch_estimate.hpp>
-#include <catch2/benchmark/catch_outlier_classification.hpp>
+#include "../catch_clock.hpp"
+#include "../catch_estimate.hpp"
+#include "../catch_outlier_classification.hpp"
 
 #include <algorithm>
 #include <functional>

include/internal/benchmark/detail/catch_timing.hpp

@@ -11,8 +11,8 @@
 #ifndef TWOBLUECUBES_CATCH_DETAIL_TIMING_HPP_INCLUDED
 #define TWOBLUECUBES_CATCH_DETAIL_TIMING_HPP_INCLUDED
 
-#include <catch2/benchmark/catch_clock.hpp>
-#include <catch2/benchmark/detail/catch_complete_invoke.hpp>
+#include "../catch_clock.hpp"
+#include "catch_complete_invoke.hpp"
 
 #include <tuple>
 #include <type_traits>

include/internal/catch_approx.cpp

@@ -6,8 +6,8 @@
  *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  */
 
-#include <catch2/catch_approx.h>
-#include <catch2/catch_enforce.h>
+#include "catch_approx.h"
+#include "catch_enforce.h"
 
 #include <cmath>
 #include <limits>
@@ -52,8 +52,7 @@ namespace Detail {
     bool Approx::equalityComparisonImpl(const double other) const {
         // First try with fixed margin, then compute margin based on epsilon, scale and Approx's value
         // Thanks to Richard Harris for his help refining the scaled margin value
-        return marginComparison(m_value, other, m_margin)
-            || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(std::isinf(m_value)? 0 : m_value)));
+        return marginComparison(m_value, other, m_margin) || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(m_value)));
     }
 
     void Approx::setMargin(double newMargin) {

include/internal/catch_approx.h

@@ -8,7 +8,7 @@
 #ifndef TWOBLUECUBES_CATCH_APPROX_HPP_INCLUDED
 #define TWOBLUECUBES_CATCH_APPROX_HPP_INCLUDED
 
-#include <catch2/catch_tostring.h>
+#include "catch_tostring.h"
 
 #include <type_traits>
 

include/internal/catch_assertionhandler.cpp

@@ -6,16 +6,15 @@
  *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  */
 
-#include <catch2/catch_assertionhandler.h>
-#include <catch2/catch_assertionresult.h>
-#include <catch2/catch_interfaces_runner.h>
-#include <catch2/catch_interfaces_config.h>
-#include <catch2/catch_context.h>
-#include <catch2/catch_enforce.h>
-#include <catch2/catch_debugger.h>
-#include <catch2/catch_interfaces_registry_hub.h>
-#include <catch2/catch_capture_matchers.h>
-#include <catch2/catch_run_context.h>
+#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 {
 

include/internal/catch_assertionhandler.h

@@ -8,9 +8,9 @@
 #ifndef TWOBLUECUBES_CATCH_ASSERTIONHANDLER_H_INCLUDED
 #define TWOBLUECUBES_CATCH_ASSERTIONHANDLER_H_INCLUDED
 
-#include <catch2/catch_assertioninfo.h>
-#include <catch2/catch_decomposer.h>
-#include <catch2/catch_interfaces_capture.h>
+#include "catch_assertioninfo.h"
+#include "catch_decomposer.h"
+#include "catch_interfaces_capture.h"
 
 namespace Catch {
 

include/internal/catch_assertioninfo.h

@@ -8,19 +8,22 @@
 #ifndef TWOBLUECUBES_CATCH_ASSERTIONINFO_H_INCLUDED
 #define TWOBLUECUBES_CATCH_ASSERTIONINFO_H_INCLUDED
 
-#include <catch2/catch_result_type.h>
-#include <catch2/catch_common.h>
-#include <catch2/catch_stringref.h>
+#include "catch_result_type.h"
+#include "catch_common.h"
+#include "catch_stringref.h"
 
 namespace Catch {
 
-    struct AssertionInfo {
-        // AssertionInfo() = delete;
-
+    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

include/internal/catch_assertionresult.cpp

@@ -6,7 +6,7 @@
  *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  */
 
-#include <catch2/catch_assertionresult.h>
+#include "catch_assertionresult.h"
 
 namespace Catch {
     AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const & _lazyExpression):
@@ -45,7 +45,7 @@ namespace Catch {
     }
 
     bool AssertionResult::hasExpression() const {
-        return !m_info.capturedExpression.empty();
+        return m_info.capturedExpression[0] != 0;
     }
 
     bool AssertionResult::hasMessage() const {
@@ -53,22 +53,16 @@ namespace Catch {
     }
 
     std::string AssertionResult::getExpression() const {
-        // Possibly overallocating by 3 characters should be basically free
-        std::string expr; expr.reserve(m_info.capturedExpression.size() + 3);
-        if (isFalseTest(m_info.resultDisposition)) {
-            expr += "!(";
-        }
-        expr += m_info.capturedExpression;
-        if (isFalseTest(m_info.resultDisposition)) {
-            expr += ')';
-        }
-        return expr;
+        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.empty() )
-            expr = static_cast<std::string>(m_info.capturedExpression);
+        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;

include/internal/catch_assertionresult.h

@@ -9,11 +9,11 @@
 #define TWOBLUECUBES_CATCH_ASSERTIONRESULT_H_INCLUDED
 
 #include <string>
-#include <catch2/catch_assertioninfo.h>
-#include <catch2/catch_result_type.h>
-#include <catch2/catch_common.h>
-#include <catch2/catch_stringref.h>
-#include <catch2/catch_assertionhandler.h>
+#include "catch_assertioninfo.h"
+#include "catch_result_type.h"
+#include "catch_common.h"
+#include "catch_stringref.h"
+#include "catch_assertionhandler.h"
 
 namespace Catch {
 

include/internal/catch_capture.hpp

@@ -8,10 +8,10 @@
 #ifndef TWOBLUECUBES_CATCH_CAPTURE_HPP_INCLUDED
 #define TWOBLUECUBES_CATCH_CAPTURE_HPP_INCLUDED
 
-#include <catch2/catch_assertionhandler.h>
-#include <catch2/catch_interfaces_capture.h>
-#include <catch2/catch_message.h>
-#include <catch2/catch_stringref.h>
+#include "catch_assertionhandler.h"
+#include "catch_interfaces_capture.h"
+#include "catch_message.h"
+#include "catch_stringref.h"
 
 #if !defined(CATCH_CONFIG_DISABLE)
 
@@ -43,10 +43,9 @@
     do { \
         Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
         INTERNAL_CATCH_TRY { \
-            CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
             CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
             catchAssertionHandler.handleExpr( Catch::Decomposer() <= __VA_ARGS__ ); \
-            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+            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
@@ -129,7 +128,7 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 #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_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log );
 
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_UNSCOPED_INFO( macroName, log ) \

include/internal/catch_capture_matchers.cpp

@@ -5,8 +5,8 @@
  *  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 <catch2/catch_capture_matchers.h>
-#include <catch2/catch_interfaces_registry_hub.h>
+#include "catch_capture_matchers.h"
+#include "catch_interfaces_registry_hub.h"
 
 namespace Catch {
 

include/internal/catch_capture_matchers.h

@@ -8,14 +8,13 @@
 #ifndef TWOBLUECUBES_CATCH_CAPTURE_MATCHERS_HPP_INCLUDED
 #define TWOBLUECUBES_CATCH_CAPTURE_MATCHERS_HPP_INCLUDED
 
-#include <catch2/catch_capture.hpp>
-#include <catch2/catch_matchers.h>
-#include <catch2/catch_matchers_exception.hpp>
-#include <catch2/catch_matchers_floating.h>
-#include <catch2/catch_matchers_generic.hpp>
-#include <catch2/catch_matchers_string.h>
-#include <catch2/catch_matchers_vector.h>
-#include <catch2/catch_stringref.h>
+#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 {
 

include/internal/catch_clara.h

@@ -23,7 +23,7 @@
 #pragma clang diagnostic ignored "-Wshadow"
 #endif
 
-#include <catch2/external/clara.hpp>
+#include "../external/clara.hpp"
 
 #ifdef __clang__
 #pragma clang diagnostic pop

include/internal/catch_commandline.cpp

@@ -6,12 +6,12 @@
  *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  */
 
-#include <catch2/catch_commandline.h>
+#include "catch_commandline.h"
 
-#include <catch2/catch_string_manip.h>
+#include "catch_string_manip.h"
 
-#include <catch2/catch_interfaces_registry_hub.h>
-#include <catch2/catch_interfaces_reporter.h>
+#include "catch_interfaces_registry_hub.h"
+#include "catch_interfaces_reporter.h"
 
 #include <fstream>
 #include <ctime>
@@ -49,15 +49,9 @@ namespace Catch {
                     if( !line.empty() && !startsWith( line, '#' ) ) {
                         if( !startsWith( line, '"' ) )
                             line = '"' + line + '"';
-                        config.testsOrTags.push_back( line );
-                        config.testsOrTags.push_back( "," );
-                        
+                        config.testsOrTags.push_back( line + ',' );
                     }
                 }
-                //Remove comma in the end
-                if(!config.testsOrTags.empty())
-                    config.testsOrTags.erase( config.testsOrTags.end()-1 );
-                
                 return ParserResult::ok( ParseResultType::Matched );
             };
         auto const setTestOrder = [&]( std::string const& order ) {
@@ -181,6 +175,9 @@ namespace Catch {
             | 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" )

include/internal/catch_commandline.h

@@ -8,8 +8,8 @@
 #ifndef TWOBLUECUBES_CATCH_COMMANDLINE_HPP_INCLUDED
 #define TWOBLUECUBES_CATCH_COMMANDLINE_HPP_INCLUDED
 
-#include <catch2/catch_config.hpp>
-#include <catch2/catch_clara.h>
+#include "catch_config.hpp"
+#include "catch_clara.h"
 
 namespace Catch {
 

include/internal/catch_common.cpp

@@ -6,15 +6,18 @@
  *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  */
 
-#include <catch2/catch_common.h>
-#include <catch2/catch_context.h>
-#include <catch2/catch_interfaces_config.h>
+#include "catch_common.h"
+#include "catch_context.h"
+#include "catch_interfaces_config.h"
 
 #include <cstring>
 #include <ostream>
 
 namespace Catch {
 
+    bool SourceLineInfo::empty() const noexcept {
+        return file[0] == '\0';
+    }
     bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const noexcept {
         return line == other.line && (file == other.file || std::strcmp(file, other.file) == 0);
     }
@@ -37,4 +40,7 @@ namespace Catch {
         return std::string();
     }
 
-} // end namespace Catch
+    NonCopyable::NonCopyable() = default;
+    NonCopyable::~NonCopyable() = default;
+
+}

include/internal/catch_common.h

@@ -8,7 +8,7 @@
 #ifndef TWOBLUECUBES_CATCH_COMMON_H_INCLUDED
 #define TWOBLUECUBES_CATCH_COMMON_H_INCLUDED
 
-#include <catch2/catch_compiler_capabilities.h>
+#include "catch_compiler_capabilities.h"
 
 #define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line
 #define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )
@@ -38,15 +38,17 @@ namespace Catch {
         NonCopyable( NonCopyable && )                  = delete;
         NonCopyable& operator = ( NonCopyable const& ) = delete;
         NonCopyable& operator = ( NonCopyable && )     = delete;
+
     protected:
-        NonCopyable() noexcept = default;
+        NonCopyable();
+        virtual ~NonCopyable();
     };
 
     struct SourceLineInfo {
 
         SourceLineInfo() = delete;
-        constexpr SourceLineInfo( char const* _file, std::size_t _line ) noexcept:
-            file( _file ),
+        SourceLineInfo( char const* _file, std::size_t _line ) noexcept
+        :   file( _file ),
             line( _line )
         {}
 
@@ -55,6 +57,7 @@ namespace Catch {
         SourceLineInfo( SourceLineInfo&& )              noexcept = default;
         SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default;
 
+        bool empty() const noexcept;
         bool operator == ( SourceLineInfo const& other ) const noexcept;
         bool operator < ( SourceLineInfo const& other ) const noexcept;
 

include/internal/catch_compiler_capabilities.h

@@ -25,7 +25,7 @@
 // Many features, at point of detection, define an _INTERNAL_ macro, so they
 // can be combined, en-mass, with the _NO_ forms later.
 
-#include <catch2/catch_platform.h>
+#include "catch_platform.h"
 
 #ifdef __cplusplus
 
@@ -43,33 +43,32 @@
 #  define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
 #endif
 
-// We have to avoid both ICC and Clang, because they try to mask themselves
-// as gcc, and we want only GCC in this block
-#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC)
-#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic push" )
-#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "GCC diagnostic pop" )
-#endif
+#ifdef __clang__
 
-#if defined(__clang__)
+#       define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+            _Pragma( "clang diagnostic push" ) \
+            _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
+            _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
+#       define CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \
+            _Pragma( "clang diagnostic pop" )
 
-#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" )
-#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "clang diagnostic pop" )
+#       define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+            _Pragma( "clang diagnostic push" ) \
+            _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
+#       define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
+            _Pragma( "clang diagnostic pop" )
 
-#    define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
-         _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
+#       define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
+            _Pragma( "clang diagnostic push" ) \
+            _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
+#       define CATCH_INTERNAL_UNSUPPRESS_UNUSED_WARNINGS \
+            _Pragma( "clang diagnostic pop" )
 
-#    define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wunused-template\"" )
+#       define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+            _Pragma( "clang diagnostic push" ) \
+            _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
+#       define CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS \
+            _Pragma( "clang diagnostic pop" )
 
 #endif // __clang__
 
@@ -95,7 +94,6 @@
 // Android somehow still does not support std::to_string
 #if defined(__ANDROID__)
 #    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
-#    define CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -117,7 +115,7 @@
 // Required for some versions of Cygwin to declare gettimeofday
 // see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin
 #   define _BSD_SOURCE
-// some versions of cygwin (most) do not support std::to_string. Use the libstd check.
+// some versions of cygwin (most) do not support std::to_string. Use the libstd check. 
 // https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813
 # if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \
            && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))
@@ -129,10 +127,8 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // Visual C++
-#if defined(_MSC_VER)
+#ifdef _MSC_VER
 
-#  define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION __pragma( warning(push) )
-#  define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  __pragma( warning(pop) )
 
 #  if _MSC_VER >= 1900 // Visual Studio 2015 or newer
 #    define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
@@ -188,55 +184,49 @@
     #define CATCH_INTERNAL_CONFIG_COUNTER
 #endif
 
+////////////////////////////////////////////////////////////////////////////////
+// Check if string_view is available and usable
+// The check is split apart to work around v140 (VS2015) preprocessor issue...
+#if defined(__has_include)
+#if __has_include(<string_view>) && defined(CATCH_CPP17_OR_GREATER)
+#    define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW
+#endif
+#endif
 
 ////////////////////////////////////////////////////////////////////////////////
-
-// RTX is a special version of Windows that is real time.
-// This means that it is detected as Windows, but does not provide
-// the same set of capabilities as real Windows does.
-#if defined(UNDER_RTSS) || defined(RTX64_BUILD)
-    #define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
-    #define CATCH_INTERNAL_CONFIG_NO_ASYNC
-    #define CATCH_CONFIG_COLOUR_NONE
-#endif
-
-#if defined(__UCLIBC__)
-#define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER
-#endif
-
-// Various stdlib support checks that require __has_include
+// Check if optional is available and usable
 #if defined(__has_include)
-  // Check if string_view is available and usable
-  #if __has_include(<string_view>) && defined(CATCH_CPP17_OR_GREATER)
-  #    define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW
-  #endif
+#  if __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
+#    define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL
+#  endif // __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
+#endif // __has_include
 
-  // Check if optional is available and usable
-  #  if __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
-  #    define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL
-  #  endif // __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
+////////////////////////////////////////////////////////////////////////////////
+// Check if byte is available and usable
+#if defined(__has_include)
+#  if __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
+#    define CATCH_INTERNAL_CONFIG_CPP17_BYTE
+#  endif // __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
+#endif // __has_include
 
-  // Check if byte is available and usable
-  #  if __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
-  #    define CATCH_INTERNAL_CONFIG_CPP17_BYTE
-  #  endif // __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
-
-  // Check if variant is available and usable
-  #  if __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
-  #    if defined(__clang__) && (__clang_major__ < 8)
-         // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852
-         // fix should be in clang 8, workaround in libstdc++ 8.2
-  #      include <ciso646>
-  #      if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
-  #        define CATCH_CONFIG_NO_CPP17_VARIANT
-  #      else
-  #        define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
-  #      endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
-  #    else
-  #      define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
-  #    endif // defined(__clang__) && (__clang_major__ < 8)
-  #  endif // __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
-#endif // defined(__has_include)
+////////////////////////////////////////////////////////////////////////////////
+// Check if variant is available and usable
+#if defined(__has_include)
+#  if __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
+#    if defined(__clang__) && (__clang_major__ < 8)
+       // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852
+       // fix should be in clang 8, workaround in libstdc++ 8.2
+#      include <ciso646>
+#      if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
+#        define CATCH_CONFIG_NO_CPP17_VARIANT
+#      else
+#        define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
+#      endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
+#    else
+#      define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
+#    endif // defined(__clang__) && (__clang_major__ < 8)
+#  endif // __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
+#endif // __has_include
 
 
 #if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER)
@@ -295,49 +285,25 @@
 #  define CATCH_CONFIG_POLYFILL_ISNAN
 #endif
 
-#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC)  && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC)
+#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC)  && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC)
 #  define CATCH_CONFIG_USE_ASYNC
 #endif
 
-#if defined(CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_NO_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_ANDROID_LOGWRITE)
-#  define CATCH_CONFIG_ANDROID_LOGWRITE
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
-#  define CATCH_CONFIG_GLOBAL_NEXTAFTER
-#endif
-
-
-// Even if we do not think the compiler has that warning, we still have
-// to provide a macro that can be used by the code.
-#if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION)
-#   define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
-#endif
-#if !defined(CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION)
-#   define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-#endif
 #if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
 #   define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
+#   define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS
 #endif
 #if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS)
 #   define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+#   define CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
 #endif
 #if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS)
 #   define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS
+#   define CATCH_INTERNAL_UNSUPPRESS_UNUSED_WARNINGS
 #endif
 #if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS)
 #   define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
-#endif
-
-
-#if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10)
-#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
-#elif defined(__clang__) && (__clang_major__ < 5)
-#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
-#endif
-
-#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#   define CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS
 #endif
 
 #if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)

include/internal/catch_config.cpp

@@ -5,9 +5,9 @@
  *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  */
 
-#include <catch2/catch_config.hpp>
-#include <catch2/catch_enforce.h>
-#include <catch2/catch_stringref.h>
+#include "catch_config.hpp"
+#include "catch_enforce.h"
+#include "catch_stringref.h"
 
 namespace Catch {
 
@@ -15,23 +15,11 @@ namespace Catch {
     :   m_data( data ),
         m_stream( openStream() )
     {
-        // We need to trim filter specs to avoid trouble with superfluous
-        // whitespace (esp. important for bdd macros, as those are manually
-        // aligned with whitespace).
-
-        for (auto& elem : m_data.testsOrTags) {
-            elem = trim(elem);
-        }
-        for (auto& elem : m_data.sectionsToRun) {
-            elem = trim(elem);
-        }
-
         TestSpecParser parser(ITagAliasRegistry::get());
-        if (!m_data.testsOrTags.empty()) {
+        if (!data.testsOrTags.empty()) {
             m_hasTestFilters = true;
-            for (auto const& testOrTags : m_data.testsOrTags) {
-                parser.parse(testOrTags);
-            }
+            for( auto const& testOrTags : data.testsOrTags )
+                parser.parse( testOrTags );
         }
         m_testSpec = parser.testSpec();
     }
@@ -41,9 +29,10 @@ namespace Catch {
     }
 
     bool Config::listTests() const          { return m_data.listTests; }
+    bool Config::listTestNamesOnly() const  { return m_data.listTestNamesOnly; }
     bool Config::listTags() const           { return m_data.listTags; }
     bool Config::listReporters() const      { return m_data.listReporters; }
-
+	
     std::string Config::getProcessName() const { return m_data.processName; }
     std::string const& Config::getReporterName() const { return m_data.reporterName; }
 

include/internal/catch_config.hpp

@@ -8,11 +8,11 @@
 #ifndef TWOBLUECUBES_CATCH_CONFIG_HPP_INCLUDED
 #define TWOBLUECUBES_CATCH_CONFIG_HPP_INCLUDED
 
-#include <catch2/catch_test_spec_parser.h>
-#include <catch2/catch_interfaces_config.h>
+#include "catch_test_spec_parser.h"
+#include "catch_interfaces_config.h"
 
 // Libstdc++ doesn't like incomplete classes for unique_ptr
-#include <catch2/catch_stream.h>
+#include "catch_stream.h"
 
 #include <memory>
 #include <vector>
@@ -30,6 +30,7 @@ namespace Catch {
         bool listTests = false;
         bool listTags = false;
         bool listReporters = false;
+        bool listTestNamesOnly = false;
 
         bool showSuccessfulTests = false;
         bool shouldDebugBreak = false;
@@ -78,6 +79,7 @@ namespace Catch {
         std::string const& getFilename() const;
 
         bool listTests() const;
+        bool listTestNamesOnly() const;
         bool listTags() const;
         bool listReporters() const;
 

include/internal/catch_console_colour.cpp

@@ -13,15 +13,15 @@
 #endif
 
 
-#include <catch2/catch_console_colour.h>
-#include <catch2/catch_enforce.h>
-#include <catch2/catch_errno_guard.h>
-#include <catch2/catch_interfaces_config.h>
-#include <catch2/catch_stream.h>
-#include <catch2/catch_context.h>
-#include <catch2/catch_platform.h>
-#include <catch2/catch_debugger.h>
-#include <catch2/catch_windows_h_proxy.h>
+#include "catch_console_colour.h"
+#include "catch_enforce.h"
+#include "catch_errno_guard.h"
+#include "catch_interfaces_config.h"
+#include "catch_stream.h"
+#include "catch_context.h"
+#include "catch_platform.h"
+#include "catch_debugger.h"
+#include "catch_windows_h_proxy.h"
 
 #include <sstream>
 

include/internal/catch_console_colour.h

@@ -8,7 +8,7 @@
 #ifndef TWOBLUECUBES_CATCH_CONSOLE_COLOUR_HPP_INCLUDED
 #define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_HPP_INCLUDED
 
-#include <catch2/catch_common.h>
+#include "catch_common.h"
 
 namespace Catch {
 

include/internal/catch_context.cpp

@@ -5,9 +5,8 @@
  *  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 <catch2/catch_context.h>
-#include <catch2/catch_common.h>
-#include <catch2/catch_random_number_generator.h>
+#include "catch_context.h"
+#include "catch_common.h"
 
 namespace Catch {
 
@@ -60,11 +59,4 @@ namespace Catch {
     IContext::~IContext() = default;
     IMutableContext::~IMutableContext() = default;
     Context::~Context() = default;
-
-
-    SimplePcg32& rng() {
-        static SimplePcg32 s_rng;
-        return s_rng;
-    }
-
 }

include/internal/catch_context.h

@@ -46,7 +46,6 @@ namespace Catch {
     {
         if( !IMutableContext::currentContext )
             IMutableContext::createContext();
-        // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
         return *IMutableContext::currentContext;
     }
 
@@ -56,9 +55,6 @@ namespace Catch {
     }
 
     void cleanUpContext();
-
-    class SimplePcg32;
-    SimplePcg32& rng();
 }
 
 #endif // TWOBLUECUBES_CATCH_CONTEXT_H_INCLUDED

include/internal/catch_debug_console.cpp

@@ -6,22 +6,12 @@
  *
  */
 
-#include <catch2/catch_debug_console.h>
-#include <catch2/catch_compiler_capabilities.h>
-#include <catch2/catch_stream.h>
-#include <catch2/catch_platform.h>
-#include <catch2/catch_windows_h_proxy.h>
+#include "catch_debug_console.h"
+#include "catch_stream.h"
+#include "catch_platform.h"
+#include "catch_windows_h_proxy.h"
 
-#if defined(CATCH_CONFIG_ANDROID_LOGWRITE)
-#include <android/log.h>
-
-    namespace Catch {
-        void writeToDebugConsole( std::string const& text ) {
-            __android_log_write( ANDROID_LOG_DEBUG, "Catch", text.c_str() );
-        }
-    }
-
-#elif defined(CATCH_PLATFORM_WINDOWS)
+#ifdef CATCH_PLATFORM_WINDOWS
 
     namespace Catch {
         void writeToDebugConsole( std::string const& text ) {

include/internal/catch_debugger.cpp

@@ -7,10 +7,10 @@
  *
  */
 
-#include <catch2/catch_debugger.h>
-#include <catch2/catch_errno_guard.h>
-#include <catch2/catch_stream.h>
-#include <catch2/catch_platform.h>
+#include "catch_debugger.h"
+#include "catch_errno_guard.h"
+#include "catch_stream.h"
+#include "catch_platform.h"
 
 #ifdef CATCH_PLATFORM_MAC
 

include/internal/catch_debugger.h

@@ -9,7 +9,7 @@
 #ifndef TWOBLUECUBES_CATCH_DEBUGGER_H_INCLUDED
 #define TWOBLUECUBES_CATCH_DEBUGGER_H_INCLUDED
 
-#include <catch2/catch_platform.h>
+#include "catch_platform.h"
 
 namespace Catch {
     bool isDebuggerActive();

include/internal/catch_decomposer.cpp

@@ -6,8 +6,8 @@
  *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  */
 
-#include <catch2/catch_decomposer.h>
-#include <catch2/catch_config.hpp>
+#include "catch_decomposer.h"
+#include "catch_config.hpp"
 
 namespace Catch {
 

include/internal/catch_decomposer.h

@@ -8,9 +8,9 @@
 #ifndef TWOBLUECUBES_CATCH_DECOMPOSER_H_INCLUDED
 #define TWOBLUECUBES_CATCH_DECOMPOSER_H_INCLUDED
 
-#include <catch2/catch_tostring.h>
-#include <catch2/catch_stringref.h>
-#include <catch2/catch_meta.hpp>
+#include "catch_tostring.h"
+#include "catch_stringref.h"
+#include "catch_meta.hpp"
 
 #include <iosfwd>
 

include/internal/catch_default_main.hpp

@@ -8,7 +8,7 @@
 #ifndef TWOBLUECUBES_CATCH_DEFAULT_MAIN_HPP_INCLUDED
 #define TWOBLUECUBES_CATCH_DEFAULT_MAIN_HPP_INCLUDED
 
-#include <catch2/catch_session.h>
+#include "catch_session.h"
 
 #ifndef __OBJC__
 

include/internal/catch_enforce.cpp

@@ -5,7 +5,7 @@
  *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  */
 
-#include <catch2/catch_enforce.h>
+#include "catch_enforce.h"
 
 #include <stdexcept>