v1.9.4

Typo fix
Somehow I made that in 5ffc8a84cd without noticing
2025-09-12 16:35:40 +02:00 · 2017-05-16 13:59:29 +02:00 · 2017-05-16 13:51:17 +02:00 · 2017-05-11 13:00:03 +02:00 · 2017-05-03 21:09:27 +02:00 · 2017-05-01 19:55:17 +02:00
57 changed files with 1870 additions and 669 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -11,25 +11,25 @@ matrix:
        apt:
          sources: ['llvm-toolchain-precise', 'ubuntu-toolchain-r-test']
          packages: ['clang']
-      env: COMPILER='clang++' BUILD_TYPE='Release' CPP11=0
+      env: COMPILER='clang++' BUILD_TYPE='Release'

    - os: linux
      compiler: clang
      addons: *clang34
-      env: COMPILER='clang++' BUILD_TYPE='Debug' CPP11=0
-      
+      env: COMPILER='clang++' BUILD_TYPE='Debug'
+
    - os: linux
      compiler: clang
      addons: &clang35
        apt:
          sources: ['llvm-toolchain-precise-3.5', 'ubuntu-toolchain-r-test']
          packages: ['clang-3.5']
-      env: COMPILER='clang++-3.5' BUILD_TYPE='Release' CPP11=0
+      env: COMPILER='clang++-3.5' BUILD_TYPE='Release'

    - os: linux
      compiler: clang
      addons: *clang35
-      env: COMPILER='clang++-3.5' BUILD_TYPE='Debug' CPP11=0
+      env: COMPILER='clang++-3.5' BUILD_TYPE='Debug'


    - os: linux
@@ -38,12 +38,12 @@ matrix:
        apt:
          sources: ['llvm-toolchain-precise-3.6', 'ubuntu-toolchain-r-test']
          packages: ['clang-3.6']
-      env: COMPILER='clang++-3.6' BUILD_TYPE='Release' CPP11=0
+      env: COMPILER='clang++-3.6' BUILD_TYPE='Release'

    - os: linux
      compiler: clang
      addons: *clang36
-      env: COMPILER='clang++-3.6' BUILD_TYPE='Debug' CPP11=0
+      env: COMPILER='clang++-3.6' BUILD_TYPE='Debug'


    - os: linux
@@ -52,12 +52,12 @@ matrix:
        apt:
          sources: ['llvm-toolchain-precise-3.7', 'ubuntu-toolchain-r-test']
          packages: ['clang-3.7']
-      env: COMPILER='clang++-3.7' BUILD_TYPE='Release' CPP11=0
+      env: COMPILER='clang++-3.7' BUILD_TYPE='Release'

    - os: linux
      compiler: clang
      addons: *clang37
-      env: COMPILER='clang++-3.7' BUILD_TYPE='Debug' CPP11=0
+      env: COMPILER='clang++-3.7' BUILD_TYPE='Debug'


    - os: linux
@@ -66,12 +66,12 @@ matrix:
        apt:
          sources: ['llvm-toolchain-precise-3.8', 'ubuntu-toolchain-r-test']
          packages: ['clang-3.8']
-      env: COMPILER='clang++-3.8' BUILD_TYPE='Release' CPP11=0
+      env: COMPILER='clang++-3.8' BUILD_TYPE='Release'

    - os: linux
      compiler: clang
      addons: *clang38
-      env: COMPILER='clang++-3.8' BUILD_TYPE='Debug' CPP11=0
+      env: COMPILER='clang++-3.8' BUILD_TYPE='Debug'


    # 2/ Linux GCC Builds
@@ -81,12 +81,12 @@ matrix:
        apt:
         sources: ['ubuntu-toolchain-r-test']
         packages: ['g++-4.4']
-      env: COMPILER='g++-4.4' BUILD_TYPE='Release' CPP11=0
+      env: COMPILER='g++-4.4' BUILD_TYPE='Release'

    - os: linux
      compiler: gcc
      addons: *gcc44
-      env: COMPILER='g++-4.4' BUILD_TYPE='Debug' CPP11=0
+      env: COMPILER='g++-4.4' BUILD_TYPE='Debug'


    - os: linux
@@ -95,12 +95,12 @@ matrix:
        apt:
         sources: ['ubuntu-toolchain-r-test']
         packages: ['g++-4.7']
-      env: COMPILER='g++-4.7' BUILD_TYPE='Release' CPP11=0
+      env: COMPILER='g++-4.7' BUILD_TYPE='Release'

    - os: linux
      compiler: gcc
      addons: *gcc47
-      env: COMPILER='g++-4.7' BUILD_TYPE='Debug' CPP11=0
+      env: COMPILER='g++-4.7' BUILD_TYPE='Debug'


    - os: linux
@@ -109,12 +109,12 @@ matrix:
        apt:
         sources: ['ubuntu-toolchain-r-test']
         packages: ['g++-4.8']
-      env: COMPILER='g++-4.8' BUILD_TYPE='Release' CPP11=0
+      env: COMPILER='g++-4.8' BUILD_TYPE='Release'

    - os: linux
      compiler: gcc
      addons: *gcc48
-      env: COMPILER='g++-4.8' BUILD_TYPE='Debug' CPP11=0
+      env: COMPILER='g++-4.8' BUILD_TYPE='Debug'


    - os: linux
@@ -123,12 +123,12 @@ matrix:
        apt:
          sources: ['ubuntu-toolchain-r-test']
          packages: ['g++-4.9']
-      env: COMPILER='g++-4.9' BUILD_TYPE='Release' CPP11=0
+      env: COMPILER='g++-4.9' BUILD_TYPE='Release'

    - os: linux
      compiler: gcc
      addons: *gcc49
-      env: COMPILER='g++-4.9' BUILD_TYPE='Debug' CPP11=0
+      env: COMPILER='g++-4.9' BUILD_TYPE='Debug'


    - os: linux
@@ -137,12 +137,12 @@ matrix:
        apt:
          sources: ['ubuntu-toolchain-r-test']
          packages: ['g++-5']
-      env: COMPILER='g++-5' BUILD_TYPE='Release' CPP11=0
+      env: COMPILER='g++-5' BUILD_TYPE='Release'

    - os: linux
      compiler: gcc
      addons: *gcc5
-      env: COMPILER='g++-5' BUILD_TYPE='Debug' CPP11=0
+      env: COMPILER='g++-5' BUILD_TYPE='Debug'


    - os: linux
@@ -151,20 +151,17 @@ matrix:
        apt:
          sources: ['ubuntu-toolchain-r-test']
          packages: ['g++-6']
-      env: COMPILER='g++-6' BUILD_TYPE='Release' CPP11=0
+      env: COMPILER='g++-6' BUILD_TYPE='Release'

    - os: linux
      compiler: gcc
      addons: *gcc6
-      env: COMPILER='g++-6' BUILD_TYPE='Debug' CPP11=0
+      env: COMPILER='g++-6' BUILD_TYPE='Debug'

    # 3a/ Linux C++11 GCC builds
    - os: linux
      compiler: gcc
-      addons: &gcc48
-        apt:
-         sources: ['ubuntu-toolchain-r-test']
-         packages: ['g++-4.8']
+      addons: *gcc48
      env: COMPILER='g++-4.8' BUILD_TYPE='Release' CPP11=1

    - os: linux
@@ -175,10 +172,7 @@ matrix:
    # 3b/ Linux C++11 Clang builds
    - os: linux
      compiler: clang
-      addons: &clang38
-        apt:
-          sources: ['llvm-toolchain-precise-3.8', 'ubuntu-toolchain-r-test']
-          packages: ['clang-3.8']
+      addons: *clang38
      env: COMPILER='clang++-3.8' BUILD_TYPE='Release' CPP11=1

    - os: linux
@@ -186,27 +180,69 @@ matrix:
      addons: *clang38
      env: COMPILER='clang++-3.8' BUILD_TYPE='Debug' CPP11=1

+    # 4a/ Linux C++14 GCC builds
+    - os: linux
+      compiler: gcc
+      addons: *gcc6
+      env: COMPILER='g++-6' BUILD_TYPE='Release' CPP14=1

-    # 4/ OSX Clang Builds
+    - os: linux
+      compiler: gcc
+      addons: *gcc6
+      env: COMPILER='g++-6' BUILD_TYPE='Debug' CPP14=1
+
+    # 4b/ Linux C++14 Clang builds
+    - os: linux
+      compiler: clang
+      addons: *clang38
+      env: COMPILER='clang++-3.8' BUILD_TYPE='Release' CPP14=1
+
+    - os: linux
+      compiler: clang
+      addons: *clang38
+      env: COMPILER='clang++-3.8' BUILD_TYPE='Debug' CPP14=1
+
+
+    # 5/ OSX Clang Builds
    - os: osx
      osx_image: xcode7.3
      compiler: clang
-      env: COMPILER='clang++' BUILD_TYPE='Debug' CPP11=0
+      env: COMPILER='clang++' BUILD_TYPE='Debug'

    - os: osx
      osx_image: xcode7.3
      compiler: clang
-      env: COMPILER='clang++' BUILD_TYPE='Release' CPP11=0
+      env: COMPILER='clang++' BUILD_TYPE='Release'

    - os: osx
      osx_image: xcode8
      compiler: clang
-      env: COMPILER='clang++' BUILD_TYPE='Debug' CPP11=0
+      env: COMPILER='clang++' BUILD_TYPE='Debug'

    - os: osx
      osx_image: xcode8
      compiler: clang
-      env: COMPILER='clang++' BUILD_TYPE='Release' CPP11=0
+      env: COMPILER='clang++' BUILD_TYPE='Release'
+
+    - os: osx
+      osx_image: xcode8
+      compiler: clang
+      env: COMPILER='clang++' BUILD_TYPE='Debug' USE_CPP11=1
+
+    - os: osx
+      osx_image: xcode8
+      compiler: clang
+      env: COMPILER='clang++' BUILD_TYPE='Release' USE_CPP11=1
+
+    - os: osx
+      osx_image: xcode8
+      compiler: clang
+      env: COMPILER='clang++' BUILD_TYPE='Debug' USE_CPP14=1
+
+    - os: osx
+      osx_image: xcode8
+      compiler: clang
+      env: COMPILER='clang++' BUILD_TYPE='Release' USE_CPP14=1


 install:
@@ -218,13 +254,13 @@ install:
      mkdir cmake && travis_retry wget --no-check-certificate --quiet -O - ${CMAKE_URL} | tar --strip-components=1 -xz -C cmake
      export PATH=${DEPS_DIR}/cmake/bin:${PATH}
    elif [[ "${TRAVIS_OS_NAME}" == "osx" ]]; then
-      which cmake || brew install cmake 
+      which cmake || brew install cmake
    fi

 before_script:
  - export CXX=${COMPILER}
  - cd ${TRAVIS_BUILD_DIR}
-  - cmake -H. -BBuild -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -Wdev -DUSE_CPP11=${CPP11}
+  - cmake -H. -BBuild -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -Wdev -DUSE_CPP11=${CPP11} -DUSE_CPP14=${CPP14}
  - cd Build

 script:
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -19,6 +19,10 @@ elseif(USE_CPP14)
    set(CMAKE_CXX_FLAGS "-std=c++14 ${CMAKE_CXX_FLAGS}")
 endif()

+if(USE_WMAIN)
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /ENTRY:wmainCRTStartup")
+endif()
+
 #checks that the given hard-coded list contains all headers + sources in the given folder
 function(CheckFileList LIST_VAR FOLDER)
  set(MESSAGE " should be added to the variable ${LIST_VAR}")
@@ -245,28 +249,35 @@ SOURCE_GROUP("Benchmarks" FILES ${BENCH_SOURCES})

 # configure the executable
 include_directories(${HEADER_DIR})
-add_executable(SelfTest ${TEST_SOURCES} ${IMPL_SOURCES} ${HEADERS})
-add_executable(Benchmark ${BENCH_SOURCES} ${HEADERS})

-# Add desired warnings
-if ( CMAKE_CXX_COMPILER_ID MATCHES "Clang|AppleClang|GNU" )
-    target_compile_options( SelfTest PRIVATE -Wall -Wextra )
-    target_compile_options( Benchmark PRIVATE -Wall -Wextra )
-endif()
-if ( CMAKE_CXX_COMPILER_ID MATCHES "MSVC" )
-    target_compile_options( SelfTest PRIVATE /W4 /w44265 /WX )
-    target_compile_options( Benchmark PRIVATE /W4 )
-endif()
+# Projects consuming Catch via ExternalProject_Add might want to use install step
+# without building all of our selftests.
+if (NOT NO_SELFTEST)
+    add_executable(SelfTest ${TEST_SOURCES} ${IMPL_SOURCES} ${HEADERS})
+    add_executable(Benchmark ${BENCH_SOURCES} ${HEADERS})
+
+    # Add desired warnings
+    if ( CMAKE_CXX_COMPILER_ID MATCHES "Clang|AppleClang|GNU" )
+        target_compile_options( SelfTest PRIVATE -Wall -Wextra )
+        target_compile_options( Benchmark PRIVATE -Wall -Wextra )
+    endif()
+    if ( CMAKE_CXX_COMPILER_ID MATCHES "MSVC" )
+        target_compile_options( SelfTest PRIVATE /W4 /w44265 /WX )
+        target_compile_options( Benchmark PRIVATE /W4 )
+    endif()


-# configure unit tests via CTest
-enable_testing()
-add_test(NAME RunTests COMMAND SelfTest)
+    # configure unit tests via CTest
+    enable_testing()
+    add_test(NAME RunTests COMMAND SelfTest)

-add_test(NAME ListTests COMMAND SelfTest --list-tests)
-set_tests_properties(ListTests PROPERTIES PASS_REGULAR_EXPRESSION "[0-9]+ test cases")
+    add_test(NAME ListTests COMMAND SelfTest --list-tests)
+    set_tests_properties(ListTests PROPERTIES PASS_REGULAR_EXPRESSION "[0-9]+ test cases")

-add_test(NAME ListTags COMMAND SelfTest --list-tags)
-set_tests_properties(ListTags PROPERTIES PASS_REGULAR_EXPRESSION "[0-9]+ tags")
+    add_test(NAME ListTags COMMAND SelfTest --list-tags)
+    set_tests_properties(ListTags PROPERTIES PASS_REGULAR_EXPRESSION "[0-9]+ tags")

-install(DIRECTORY "single_include/" DESTINATION "include/catch/")
+endif() # !NO_SELFTEST
+
+
+install(DIRECTORY "single_include/" DESTINATION "include/catch")
--- a/LICENSE_1_0.txt
+++ b/LICENSE_1_0.txt
--- a/README.md
+++ b/README.md
@@ -4,7 +4,7 @@
 [![Build Status](https://travis-ci.org/philsquared/Catch.svg?branch=master)](https://travis-ci.org/philsquared/Catch)
 [![Build status](https://ci.appveyor.com/api/projects/status/hrtk60hv6tw6fght/branch/master?svg=true)](https://ci.appveyor.com/project/philsquared/catch/branch/master)

-<a href="https://github.com/philsquared/Catch/releases/download/v1.8.2/catch.hpp">The latest, single header, version can be downloaded directly using this link</a>
+<a href="https://github.com/philsquared/Catch/releases/download/v1.9.4/catch.hpp">The latest, single header, version can be downloaded directly using this link</a>

 ## What's the Catch?

--- a/appveyor.yml
+++ b/appveyor.yml
@@ -1,14 +1,30 @@
 # version string format -- This will be overwritten later anyway
 version: "{build}"

-# Disable the dead branch for v2 development
-branches:
-    except:
-        - develop-v2
-
 os:
-  - Visual Studio 2013
+  - Visual Studio 2017
  - Visual Studio 2015
+  - Visual Studio 2013
+
+environment:
+    matrix:
+        - additional_flags: "/permissive- /std:c++latest"
+          wmain: 0
+
+        - additional_flags: ""
+          wmain: 0
+
+        - additional_flags: "/D_UNICODE /DUNICODE"
+          wmain: 1
+
+matrix:
+    exclude:
+        -
+            additional_flags: "/permissive- /std:c++latest"
+            os: Visual Studio 2015
+        -
+            additional_flags: "/permissive- /std:c++latest"
+            os: Visual Studio 2013

 init:
  - git config --global core.autocrlf input
@@ -31,8 +47,8 @@ configuration:

 #Cmake will autodetect the compiler, but we set the arch
 before_build:
-  - echo Running cmake...
-  - cmake -H. -BBuild -A%PLATFORM%
+  - set CXXFLAGS=%additional_flags%
+  - cmake -H. -BBuild -A%PLATFORM% -DUSE_WMAIN=%wmain%

 # build with MSBuild
 build:
--- a/contrib/ParseAndAddCatchTests.cmake
+++ b/contrib/ParseAndAddCatchTests.cmake
@@ -0,0 +1,115 @@
+#==================================================================================================#
+#  supported macros                                                                                #
+#    - TEST_CASE,                                                                                  #
+#    - SCENARIO,                                                                                   #
+#    - TEST_CASE_METHOD,                                                                           #
+#    - CATCH_TEST_CASE,                                                                            #
+#    - CATCH_SCENARIO,                                                                             #
+#    - CATCH_TEST_CASE_METHOD.                                                                     #
+#                                                                                                  #
+#  Usage                                                                                           #
+# 1. make sure this module is in the path or add this otherwise:                                   #
+#    set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake.modules/")              #
+# 2. make sure that you've enabled testing option for the project by the call:                     #
+#    enable_testing()                                                                              #
+# 3. add the lines to the script for testing target (sample CMakeLists.txt):                       #
+#        project(testing_target)                                                                   #
+#        set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake.modules/")          #
+#        enable_testing()                                                                          #
+#                                                                                                  #
+#        find_path(CATCH_INCLUDE_DIR "catch.hpp")                                                  #
+#        include_directories(${INCLUDE_DIRECTORIES} ${CATCH_INCLUDE_DIR})                          #
+#                                                                                                  #
+#        file(GLOB SOURCE_FILES "*.cpp")                                                           #
+#        add_executable(${PROJECT_NAME} ${SOURCE_FILES})                                           #
+#                                                                                                  #
+#        include(ParseAndAddCatchTests)                                                            #
+#        ParseAndAddCatchTests(${PROJECT_NAME})                                                    #
+#==================================================================================================#
+
+cmake_minimum_required(VERSION 2.8.8)
+
+# This removes the contents between
+#  - block comments (i.e. /* ... */) 
+#  - full line comments (i.e. // ... ) 
+# contents have been read into '${CppCode}'.
+# !keep partial line comments
+function(RemoveComments CppCode)
+  string(ASCII 2 CMakeBeginBlockComment)
+  string(ASCII 3 CMakeEndBlockComment)
+  string(REGEX REPLACE "/\\*" "${CMakeBeginBlockComment}" ${CppCode} "${${CppCode}}")
+  string(REGEX REPLACE "\\*/" "${CMakeEndBlockComment}" ${CppCode} "${${CppCode}}")
+  string(REGEX REPLACE "${CMakeBeginBlockComment}[^${CMakeEndBlockComment}]*${CMakeEndBlockComment}" "" ${CppCode} "${${CppCode}}")
+  string(REGEX REPLACE "\n[ \t]*//+[^\n]+" "\n" ${CppCode} "${${CppCode}}")
+
+  set(${CppCode} "${${CppCode}}" PARENT_SCOPE)
+endfunction()
+
+# Worker function
+function(ParseFile SourceFile TestTarget)
+    if(NOT EXISTS ${SourceFile})
+        message(WARNING "Cannot find source file: ${SourceFile}")
+        return()
+    endif()
+    file(STRINGS ${SourceFile} Contents NEWLINE_CONSUME)
+
+    # Remove block and fullline comments
+    RemoveComments(Contents)
+
+    # Find definition of test names
+    string(REGEX MATCHALL "[ \t]*(CATCH_)?(TEST_CASE_METHOD|SCENARIO|TEST_CASE)[ \t]*\\([^\)]+\\)+[ \t\n]*{+[ \t]*(//[^\n]*[Tt][Ii][Mm][Ee][Oo][Uu][Tt][ \t]*[0-9]+)*" Tests "${Contents}")
+
+    foreach(TestName ${Tests})
+        # Strip newlines
+        string(REGEX REPLACE "\\\\\n|\n" "" TestName "${TestName}")
+
+        # Get test type and fixture if applicable
+        string(REGEX MATCH "(CATCH_)?(TEST_CASE_METHOD|SCENARIO|TEST_CASE)[ \t]*\\([^,^\"]*" TestTypeAndFixture "${TestName}")
+        string(REGEX MATCH "(CATCH_)?(TEST_CASE_METHOD|SCENARIO|TEST_CASE)" TestType "${TestTypeAndFixture}")
+        string(REPLACE "${TestType}(" "" TestFixture "${TestTypeAndFixture}")
+
+        # Get string parts of test definition
+        string(REGEX MATCHALL "\"+([^\\^\"]|\\\\\")+\"+" TestStrings "${TestName}")
+
+        # Strip wrapping quotation marks
+        string(REGEX REPLACE "^\"(.*)\"$" "\\1" TestStrings "${TestStrings}")
+        string(REPLACE "\";\"" ";" TestStrings "${TestStrings}")
+
+        # Validate that a test name and tags have been provided
+        list(LENGTH TestStrings TestStringsLength)
+        if(TestStringsLength GREATER 2 OR TestStringsLength LESS 1)
+            message(FATAL_ERROR "You must provide a valid test name and tags for all tests in ${SourceFile}")
+        endif()
+
+        # Assign name and tags
+        list(GET TestStrings 0 Name)
+        if("${TestType}" STREQUAL "SCENARIO")
+            set(Name "Scenario: ${Name}")
+        endif()
+        if(TestFixture)
+            set(CTestName "${TestFixture}:${Name}")
+        else()
+            set(CTestName "${Name}")
+        endif()
+        if(TestStringsLength EQUAL 2)
+            list(GET TestStrings 1 Tags)
+            string(TOLOWER "${Tags}" Tags)
+            string(REPLACE "]" ";" Tags "${Tags}")
+            string(REPLACE "[" "" Tags "${Tags}")
+        endif()
+
+        # Add the test and set its properties
+        add_test(NAME "\"${CTestName}\"" COMMAND ${TestTarget} ${Name} ${AdditionalCatchParameters})
+        set_tests_properties("\"${CTestName}\"" PROPERTIES FAIL_REGULAR_EXPRESSION "No tests ran"
+                                                LABELS "${Tags}")
+
+    endforeach()
+endfunction()
+
+# entry point
+function(ParseAndAddCatchTests TestTarget)
+    get_target_property(SourceFiles ${TestTarget} SOURCES)
+    foreach(SourceFile ${SourceFiles})
+        ParseFile(${SourceFile} ${TestTarget})
+    endforeach()
+endfunction()
--- a/docs/Readme.md
+++ b/docs/Readme.md
@@ -1,23 +1,29 @@
-These are the currently documented areas of the framework. There is more to come.
-
-Before looking at this material be sure to read the [tutorial](tutorial.md)
+To get the most out of Catch, start with the [tutorial](tutorial.md).
+Once you're up and running consider the following reference material.

+Writing tests:
 * [Assertion macros](assertions.md)
 * [Matchers](matchers.md)
 * [Logging macros](logging.md)
 * [Test cases and sections](test-cases-and-sections.md)
 * [Test fixtures](test-fixtures.md)
-* [Supplying your own main()](own-main.md)
+* [Reporters](reporters.md)
 * [Event Listeners](event-listeners.md)
-* [Configuration](configuration.md)
+
+Fine tuning:
+* [Supplying your own main()](own-main.md)
+* [Compile-time configuration](configuration.md)
 * [String Conversions](tostring.md)
+
+Running:
 * [Command line](command-line.md)
 * [Build systems](build-systems.md)
+
+FAQ:
 * [Why are my tests slow to compile?](slow-compiles.md)
 * [Known limitations](limitations.md)
 
-Other
-
+Other:
 * [Why Catch?](why-catch.md)
 * [Open Source Projects using Catch](opensource-users.md)
 * [Contributing](contributing.md)
--- a/docs/assertions.md
+++ b/docs/assertions.md
@@ -95,7 +95,7 @@ Expects that an exception (of any type) is be thrown during evaluation of the ex
 * **REQUIRE_THROWS_AS(** _expression_, _exception type_ **)** and  
 * **CHECK_THROWS_AS(** _expression_, _exception type_ **)**

-Expects that an exception of the _specified type_ is thrown during evaluation of the expression.
+Expects that an exception of the _specified type_ is thrown during evaluation of the expression. Note that the _exception type_ is used verbatim and you should include (const) reference.

 * **REQUIRE_THROWS_WITH(** _expression_, _string or string matcher_ **)** and  
 * **CHECK_THROWS_WITH(** _expression_, _string or string matcher_ **)**
@@ -131,6 +131,11 @@ To support Matchers a slightly different form is used. Matchers have [their own

 Matchers can be composed using `&&`, `||` and `!` operators.

+## Thread Safety
+
+Currently assertions in Catch are not thread safe.
+For more details, along with workarounds, see the section on [the limitations page](limitations.md#thread-safe-assertions).
+
 ---

 [Home](Readme.md)
--- a/docs/build-systems.md
+++ b/docs/build-systems.md
@@ -56,8 +56,26 @@ Because of the incremental nature of Catch's test suites and ability to run spec

 ## CMake

-You can use the following CMake script to automatically fetch Catch from github and configure it as an external project:
+In general we recommend "vendoring" Catch's single-include releases inside your own repository. If you do this, the following example shows a minimal CMake project:
+```CMake
+cmake_minimum_required(VERSION 3.0)

+project(cmake_test)
+
+# Prepare "Catch" library for other executables
+set(CATCH_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/catch)
+add_library(Catch INTERFACE)
+target_include_directories(Catch INTERFACE ${CATCH_INCLUDE_DIR})
+
+# Make test executable
+set(TEST_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/main.cpp)
+add_executable(tests ${TEST_SOURCES})
+target_link_libraries(tests Catch)
+```
+Note that it assumes that the path to the Catch's header is `catch/catch.hpp` from the `CMakeLists.txt` file.
+
+
+You can also use the following CMake snippet to automatically fetch the entire Catch repository from github and configure it as an external project:
 ```CMake
 cmake_minimum_required(VERSION 2.8.8)
 project(catch_builder CXX)
@@ -90,6 +108,32 @@ include_directories(${CATCH_INCLUDE_DIR} ${COMMON_INCLUDES})
 enable_testing(true)  # Enables unit-testing.
 ```

+The advantage of this approach is that you can always automatically update Catch to the latest release. The disadvantage is that it means bringing in lot more than you need.
+
+
+### Automatic test registration
+If you are also using ctest, `contrib/ParseAndAddCatchTests.cmake` is a CMake script that attempts to parse your test files and automatically register all test cases, using tags as labels. This means that these
+```cpp
+TEST_CASE("Test1", "[unit]") {
+    int a = 1;
+    int b = 2;
+    REQUIRE(a == b);
+}
+
+TEST_CASE("Test2") {
+    int a = 1;
+    int b = 2;
+    REQUIRE(a == b);
+}
+
+TEST_CASE("Test3", "[a][b][c]") {
+    int a = 1;
+    int b = 2;
+    REQUIRE(a == b);
+}
+```
+would be registered as 3 tests, `Test1`, `Test2` and `Test3`, and ctest 4 labels would be created, `a`, `b`, `c` and `unit`.
+
 ---

 [Home](Readme.md)
--- a/docs/commercial-users.md
+++ b/docs/commercial-users.md
@@ -1,12 +1,16 @@
 # Commercial users of Catch

-As well as [Open Source](opensource-users.md) users Catch is widely used within proprietary code bases too. Many companies like to keep this
-information internal, and that's fine, but if you're more open it would be great if we could list the names of as
-many organisations as possible that use Catch somewhere in their codebase. Enterprise environments often tend to be
-far more conservative in their tool adoption - and being aware that other companies are using Catch can ease the
-path in.
+As well as [Open Source](opensource-users.md) users Catch is widely used within proprietary code bases too.
+Many organisations like to keep this information internal, and that's fine, 
+but if you're more open it would be great if we could list the names of as
+many organisations as possible that use Catch somewhere in their codebase. 
+Enterprise environments often tend to be far more conservative in their tool adoption - 
+and being aware that other companies are using Catch can ease the path in.

 So if you are aware of Catch usage in your organisation, and are fairly confident there is no issue with sharing this
-fact then please let us know - either directly, via a PR or [issue](https://github.com/philsquared/Catch/issues), or on the [forums](https://groups.google.com/forum/?fromgroups#!forum/catch-forum).
+fact then please let us know - either directly, via a PR or 
+[issue](https://github.com/philsquared/Catch/issues), or on the [forums](https://groups.google.com/forum/?fromgroups#!forum/catch-forum).
 
 - Bloomberg
+ - NASA
+ 
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -52,17 +52,18 @@ This can be useful on certain platforms that do not provide ```std::cout``` and

 # C++ conformance toggles

-	CATCH_CONFIG_CPP11_NULLPTR 				// nullptr is supported?
-	CATCH_CONFIG_CPP11_NOEXCEPT				// noexcept is supported?
-	CATCH_CONFIG_CPP11_GENERATED_METHODS	// delete and default keywords for methods
-	CATCH_CONFIG_CPP11_IS_ENUM				// std::is_enum is supported?
-	CATCH_CONFIG_CPP11_TUPLE				// std::tuple is supported
-	CATCH_CONFIG_VARIADIC_MACROS 			// Usually pre-C++11 compiler extensions are sufficient
-	CATCH_CONFIG_CPP11_LONG_LONG			// generates overloads for the long long type
-	CATCH_CONFIG_CPP11_OVERRIDE				// CATCH_OVERRIDE expands to override (for virtual function implementations)
-	CATCH_CONFIG_CPP11_UNIQUE_PTR			// Use std::unique_ptr instead of std::auto_ptr
-    CATCH_CONFIG_CPP11_SHUFFLE              // Use std::shuffle instead of std::random_shuffle
-    CATCH_CONFIG_CPP11_TYPE_TRAITS          // Use std::enable_if and <type_traits>
+    CATCH_CONFIG_CPP11_NULLPTR                 // nullptr is supported?
+    CATCH_CONFIG_CPP11_NOEXCEPT                // noexcept is supported?
+    CATCH_CONFIG_CPP11_GENERATED_METHODS       // delete and default keywords for methods
+    CATCH_CONFIG_CPP11_IS_ENUM                 // std::is_enum is supported?
+    CATCH_CONFIG_CPP11_TUPLE                   // std::tuple is supported
+    CATCH_CONFIG_VARIADIC_MACROS               // Usually pre-C++11 compiler extensions are sufficient
+    CATCH_CONFIG_CPP11_LONG_LONG               // generates overloads for the long long type
+    CATCH_CONFIG_CPP11_OVERRIDE                // CATCH_OVERRIDE expands to override (for virtual function implementations)
+    CATCH_CONFIG_CPP11_UNIQUE_PTR              // Use std::unique_ptr instead of std::auto_ptr
+    CATCH_CONFIG_CPP11_SHUFFLE                 // Use std::shuffle instead of std::random_shuffle
+    CATCH_CONFIG_CPP11_TYPE_TRAITS             // Use std::enable_if and <type_traits>
+    CATCH_CONFIG_CPP11_STREAM_INSERTABLE_CHECK // Use C++11 expression SFINAE to check if class can be inserted to std::ostream

 Catch has some basic compiler detection that will attempt to select the appropriate mix of these macros. However being incomplete - and often without access to the respective compilers - this detection tends to be conservative.
 So overriding control is given to the user. If a compiler supports a feature (and Catch does not already detect it) then one or more of these may be defined to enable it (or suppress it, in some cases). If you do do this please raise an issue, specifying your compiler version (ideally with an idea of how to detect it) and stating that it has such support.
@@ -70,24 +71,51 @@ You may also suppress any of these features by using the `_NO_` form, e.g. `CATC

 All C++11 support can be disabled with `CATCH_CONFIG_NO_CPP11`

+## `CATCH_CONFIG_CPP11_STREAM_INSERTABLE_CHECK`
+
+This flag is off by default, but allows you to resolve problems caused by types with private base class that are streamable, but the classes themselves are not. Without it, the following code will cause a compilation error:
+```cpp
+#define CATCH_CONFIG_MAIN
+#include <catch.hpp>
+struct A {};
+std::ostream &operator<< (std::ostream &o, const A &v) { return o << 0; }
+
+struct B : private A {
+    bool operator==(int){ return true;}
+};
+
+B f ();
+std::ostream g ();
+
+TEST_CASE ("Error in streamable check") {
+    B x;
+    REQUIRE (x == 4);
+}
+```
+
 # Other toggles

    CATCH_CONFIG_COUNTER                    // Use __COUNTER__ to generate unique names for test cases
    CATCH_CONFIG_WINDOWS_SEH                // Enable SEH handling on Windows
-    CATCH_CONFIG_FAST_COMPILE               // Sacrifices some (extremely minor) features for compilation speed
+    CATCH_CONFIG_FAST_COMPILE               // Sacrifices some (rather minor) features for compilation speed
    CATCH_CONFIG_POSIX_SIGNALS              // Enable handling POSIX signals
    CATCH_CONFIG_WINDOWS_CRTDBG             // Enable leak checking using Windows's CRT Debug Heap

 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.

-At this moment, `CATCH_CONFIG_FAST_COMPILE` changes only the behaviour of the `-b` (`--break`) flag, making it break into debugger in a stack frame *below* the actual test, unlike the default behaviour, where the break into debugger occurs in the same stack frame as the actual test. `CATCH_CONFIG_FAST_COMPILE` has to be either defined, or not defined, in all translation units that are linked into single test binary, or the behaviour of setting `-b` flag will be unpredictable.
-
 `CATCH_CONFIG_POSIX_SIGNALS` is on by default, except when Catch is compiled under `Cygwin`, where it is disabled by default (but can be force-enabled by defining `CATCH_CONFIG_POSIX_SIGNALS`).

 `CATCH_CONFIG_WINDOWS_CRTDBG` is off by default. If enabled, Windows's CRT is used to check for memory leaks, and displays them after the tests finish running.

 Just as with the C++11 conformance toggles, these toggles can be disabled by using `_NO_` form of the toggle, e.g. `CATCH_CONFIG_NO_WINDOWS_SEH`.

+## `CATCH_CONFIG_FAST_COMPILE`
+Defining this flag speeds up compilation of test files by ~20%, by making 2 changes:
+* The `-b` (`--break`) flag no longer makes Catch break into debugger in the same stack frame as the failed test, but rather in a stack frame *below*.
+* The `REQUIRE` family of macros (`REQUIRE`, `REQUIRE_FALSE` and `REQUIRE_THAT`) no longer uses local try-catch block. This disables exception translation, but should not lead to false negatives.
+
+`CATCH_CONFIG_FAST_COMPILE` has to be either defined, or not defined, in all translation units that are linked into single test binary, or the behaviour of setting `-b` flag and throwing unexpected exceptions will be unpredictable.
+
 # Windows header clutter

 On Windows Catch includes `windows.h`. To minimize global namespace clutter in the implementation file, it defines `NOMINMAX` and `WIN32_LEAN_AND_MEAN` before including it. You can control this behaviour via two macros:
--- a/docs/opensource-users.md
+++ b/docs/opensource-users.md
@@ -1,6 +1,6 @@
 # Open Source projects using Catch

-Catch is great for open source. With it's [liberal license](../LICENSE_1_0.txt) and single-header, dependency-free, distribution 
+Catch is great for open source. With it's [liberal license](../LICENSE.txt) and single-header, dependency-free, distribution 
 it's easy to just drop the header into your project and start writing tests - what's not to like?

 As a result Catch is now being used in many Open Source projects, including some quite well known ones.
@@ -34,9 +34,18 @@ A, single-header, JSON parsing library that takes advantage of what C++ has to o
 ### [MNMLSTC Core](https://github.com/mnmlstc/core)
 a small and easy to use C++11 library that adds a functionality set that will be available in C++14 and later, as well as some useful additions

+### [nanodbc](https://github.com/lexicalunit/nanodbc/)
+A small C++ library wrapper for the native C ODBC API.
+
+### [Nonius](https://github.com/libnonius/nonius)
+A header-only framework for benchmarking small snippets of C++ code.
+
 ### [SOCI](https://github.com/SOCI/soci)
 The C++ Database Access Library

+### [polymorphic_value](https://github.com/jbcoe/polymorphic_value)
+A polymorphic value-type for C++
+
 ### [Ppconsul](https://github.com/oliora/ppconsul)
 A C++ client library for Consul. Consul is a distributed tool for discovering and configuring services in your infrastructure

@@ -54,6 +63,9 @@ ArangoDB is a native multi-model database with flexible data models for document
 ### [MAME](https://github.com/mamedev/mame)
 MAME originally stood for Multiple Arcade Machine Emulator

+### [Newsbeuter](https://github.com/akrennmair/newsbeuter)
+Newsbeuter is an open-source RSS/Atom feed reader for text terminals.
+
 ### [Standardese](https://github.com/foonathan/standardese)
 Standardese aims to be a nextgen Doxygen

--- a/docs/release-notes.md
+++ b/docs/release-notes.md
@@ -1,3 +1,77 @@
+# 1.9.4
+
+### Fixes
+* `CATCH_FAIL` macro no longer causes compilation error without variadic macro support
+* `INFO` messages are no longer cleared after being reported once
+
+### Improvements and minor changes
+* Catch now uses `wmain` when compiled under Windows and `UNICODE` is defined.
+  * Note that Catch still officially supports only ASCII
+
+# 1.9.3
+
+### Fixes
+* Completed the fix for (lack of) uint64_t in earlier Visual Studios
+
+# 1.9.2
+
+### Improvements and minor changes
+* All of `Approx`'s member functions now accept strong typedefs in C++11 mode (#888)
+  * Previously `Approx::scale`, `Approx::epsilon`, `Approx::margin` and `Approx::operator()` didn't.
+
+
+### Fixes
+* POSIX signals are now disabled by default under QNX (#889)
+  * QNX does not support current enough (2001) POSIX specification
+* JUnit no longer counts exceptions as failures if given test case is marked as ok to fail.
+* `Catch::Option` should now have its storage properly aligned.
+* Catch no longer attempts to define `uint64_t` on windows (#862)
+  * This was causing trouble when compiled under Cygwin
+
+### Other
+* Catch is now compiled under MSVC 2017 using `std:c++latest` (C++17 mode) in CI
+* We now provide cmake script that autoregisters Catch tests into ctest.
+  * See `contrib` folder.
+
+
+# 1.9.1
+
+### Fixes
+* Unexpected exceptions are no longer ignored by default (#885, #887)
+
+
+# 1.9.0
+
+
+### Improvements and minor changes
+* Catch no longer attempts to ensure the exception type passed by user in `REQUIRE_THROWS_AS` is a constant reference.
+  * It was causing trouble when `REQUIRE_THROWS_AS` was used inside templated functions
+  * This actually reverts changes made in v1.7.2
+* Catch's `Version` struct should no longer be double freed when multiple instances of Catch tests are loaded into single program (#858)
+  * It is now a static variable in an inline function instead of being an `extern`ed struct.
+* Attempt to register invalid tag or tag alias now throws instead of calling `exit()`.
+  * Because this happen before entering main, it still aborts execution
+  * Further improvements to this are coming
+* `CATCH_CONFIG_FAST_COMPILE` now speeds-up compilation of `REQUIRE*` assertions by further ~15%.
+  * The trade-off is disabling translation of unexpected exceptions into text.
+* When Catch is compiled using C++11, `Approx` is now constructible with anything that can be explicitly converted to `double`.
+* Captured messages are now printed on unexpected exceptions
+
+### Fixes:
+* Clang's `-Wexit-time-destructors` should be suppressed for Catch's internals
+* GCC's `-Wparentheses` is now suppressed for all TU's that include `catch.hpp`.
+  * This is functionally a revert of changes made in 1.8.0, where we tried using `_Pragma` based suppression. This should have kept the suppression local to Catch's assertions, but bugs in GCC's handling of `_Pragma`s in C++ mode meant that it did not always work.
+* You can now tell Catch to use C++11-based check when checking whether a type can be streamed to output.
+  * This fixes cases when an unstreamable type has streamable private base (#877)
+  * [Details can be found in documentation](configuration.md#catch_config_cpp11_stream_insertable_check)
+
+
+### Other notes:
+* We have added VS 2017 to our CI
+* Work on Catch 2 should start soon
+
+
+
 # 1.8.2


@@ -29,6 +103,7 @@
 * Clara no longer assumes first argument (binary name) is always present (#729)
  * If it is missing, empty string is used as default.
 * Clara no longer reads 1 character past argument string (#830)
+* Regression in Objective-C bindings (Matchers) fixed (#854)


 ### Other notes:
@@ -49,7 +124,7 @@ Cygwin issue with `gettimeofday` - `#define` was not early enough

 * Matchers have new, simpler (and documented) interface.
  * Catch provides string and vector matchers.
-  * For details see [Matchers documentation](docs/matchers.md).
+  * For details see [Matchers documentation](matchers.md).
 * Changed console reporter test duration reporting format (#322)
  * Old format: `Some simple comparisons between doubles completed in 0.000123s`
  * New format: `xxx.123s: Some simple comparisons between doubles` _(There will always be exactly 3 decimal places)_
@@ -63,7 +138,7 @@ Cygwin issue with `gettimeofday` - `#define` was not early enough
  * For details see [documentation about integrating with build systems](build-systems.md).
 *  XML reporter now reports filename as part of the `Section` and `TestCase` tags.
 * `Approx` now supports an optional margin of absolute error
-  * It has also received [new documentation](docs/assertions.md).
+  * It has also received [new documentation](assertions.md).

 ### Fixes
 * Silenced C4312 ("conversion from int to 'ClassName *") warnings in the evaluate layer.
@@ -106,7 +181,7 @@ Other:
 ### Fixes:
 * Fixed inconsistency in defining `NOMINMAX` and `WIN32_LEAN_AND_MEAN` inside `catch.hpp`.
 * Fixed SEH-related compilation error under older MinGW compilers, by making Windows SEH handling opt-in for compilers other than MSVC.
-  * For specifics, look into the [documentation](docs/configuration.md).
+  * For specifics, look into the [documentation](configuration.md).
 * Fixed compilation error under MinGW caused by improper compiler detection.
 * Fixed XML reporter sometimes leaving an empty output file when a test ends with signal/structured exception.
 * Fixed XML reporter not reporting captured stdout/stderr.
@@ -120,7 +195,7 @@ Other:
  * Microbenchmark focused on Catch's overhead went from ~3.4s to ~0.7s.
  * Real world test using [JSON for Modern C++](https://github.com/nlohmann/json)'s test suite went from ~6m 25s to ~4m 14s.
 * Catch can now run specific sections within test cases.
-  * For now the support is only basic (no wildcards or tags), for details see the [documentation](docs/command-line.md).
+  * For now the support is only basic (no wildcards or tags), for details see the [documentation](command-line.md).
 * Catch now supports SEH on Windows as well as signals on Linux.
  * After receiving a signal, Catch reports failing assertion and then passes the signal onto the previous handler.
 * Approx can be used to compare values against strong typedefs (available in C++11 mode only).
@@ -157,7 +232,7 @@ Other:
 * Approval tests can now be run on Windows
 * CMake will now warn if a file is present in the `include` folder but not is not enumerated as part of the project
 * Catch now defines `NOMINMAX` and `WIN32_LEAN_AND_MEAN` before including `windows.h`
-  * This can be disabled if needed, see [documentation](docs/configuration.md) for details.
+  * This can be disabled if needed, see [documentation](configuration.md) for details.


 ## 1.6.0
--- a/docs/reporters.md
+++ b/docs/reporters.md
@@ -0,0 +1,45 @@
+# Reporters
+
+Catch has a modular reporting system and comes bundled with a handful of useful reporters built in.
+You can also write your own reporters.
+
+## Using different reporters
+
+The reporter to use can easily be controlled from the command line.
+To specify a reporter use [`-r` or `--reporter`](command-line.md#choosing-a-reporter-to-use), followed by the name of the reporter, e.g.:
+
+```
+-r xml
+```
+
+If you don't specify a reporter then the console reporter is used by default.
+There are four reporters built in to the single include:
+
+* `console` writes as lines of text, formatted to a typical terminal width, with colours if a capable terminal is detected.
+* `compact` similar to `console` but optimised for minimal output - each entry on one line
+* `junit` writes xml that corresponds to Ant's [junitreport](http://help.catchsoftware.com/display/ET/JUnit+Format) target. Useful for build systems that understand Junit. 
+Because of the way the junit format is structured the run must complete before anything is written. 
+* `xml` writes an xml format tailored to Catch. Unlike `junit` this is a streaming format so results are delivered progressively.
+
+There are a few additional reporters, for specific build systems, in the Catch repository (in `include\reporters`) which you can `#include` in your project if you would like to make use of them.
+Do this in one source file - typically the same one you have `CATCH_CONFIG_MAIN` or `CATCH_CONFIG_RUNNER`.
+
+* `teamcity` writes the native, streaming, format that [TeamCity](https://www.jetbrains.com/teamcity/) understands.
+Use this when building as part of a TeamCity build to see results as they happen.
+* `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
+
+You see what reporters are available from the command line by running with `--list-reporters`.
+
+By default all these reports are written to stdout, but can be redirected to a file with [`-o` or `--out`](command-line.md#sending-output-to-a-file)
+
+## Writing your own reporter
+
+You can write your own custom reporter and register it with Catch.
+At time of writing the interface is subject to some changes so is not, yet, documented here.
+If you are determined you shouldn't have too much trouble working it out from the existing implementations -
+but do keep in mind upcoming changes (these will be minor, simplifying, changes such as not needing to forward calls to the base class).
+
+---
+
+[Home](Readme.md)
--- a/docs/tostring.md
+++ b/docs/tostring.md
@@ -16,16 +16,7 @@ std::ostream& operator << ( std::ostream& os, T const& value ) {

 (where ```T``` is your type and ```convertMyTypeToString``` is where you'll write whatever code is necessary to make your type printable - it doesn't have to be in another function).

-You should put this function in the same namespace as your type.
-
-Alternatively you may prefer to write it as a member function:
-
-```
-std::ostream& T::operator << ( std::ostream& os ) const {
-	os << convertMyTypeToString( *this );
-	return os;
-}
-```
+You should put this function in the same namespace as your type and it has to be declared before including Catch's header.

 ## Catch::toString overload

@@ -39,11 +30,12 @@ namespace Catch {
 }
 ```

-Again ```T``` is your type and ```convertMyTypeToString``` is where you'll write whatever code is necessary to make your type printable. Note that the function must be in the Catch namespace, which itself must be in the global namespace.
+Again ```T``` is your type and ```convertMyTypeToString``` is where you'll write whatever code is necessary to make your type printable. Note that the function must be in the Catch namespace, which itself must be in the global namespace and must be declared _before_ Catch's header is included.
+
+**Please note that overloading `Catch::toString` is currently considered legacy and will not be supported in the next major version of Catch.**

 ## Catch::StringMaker<T> specialisation
-
-There are some cases where overloading toString does not work as expected. Specialising StringMaker<T> gives you more precise, and reliable, control - but at the cost of slightly more code and complexity:
+Another way of telling Catch how to convert a type to string is specialising `Catch::StringMaker` template. This allows you to have separate way of stringifying types for Catch, than you have for writing it to a stream and also doesn't require you to declare it before including Catch's header.

 ```
 namespace Catch {
--- a/include/catch.hpp
+++ b/include/catch.hpp
@@ -91,33 +91,44 @@ LeakDetector leakDetector;
 // If this config identifier is defined then all CATCH macros are prefixed with CATCH_
 #ifdef CATCH_CONFIG_PREFIX_ALL

-#define CATCH_REQUIRE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal, "CATCH_REQUIRE" )
-#define CATCH_REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, "CATCH_REQUIRE_FALSE" )
+#if defined(CATCH_CONFIG_FAST_COMPILE)
+#define CATCH_REQUIRE( expr ) INTERNAL_CATCH_TEST_NO_TRY( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, expr )
+#define CATCH_REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST_NO_TRY( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, expr )
+#else
+#define CATCH_REQUIRE( expr ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, expr )
+#define CATCH_REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, expr  )
+#endif

-#define CATCH_REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::Normal, "", "CATCH_REQUIRE_THROWS" )
-#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_THROWS_AS" )
-#define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::Normal, matcher, "CATCH_REQUIRE_THROWS_WITH" )
-#define CATCH_REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_NOTHROW" )
+#define CATCH_REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, "", expr )
+#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
+#define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
+#define CATCH_REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( "CATCH_REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, expr )

-#define CATCH_CHECK( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK" )
-#define CATCH_CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, "CATCH_CHECK_FALSE" )
-#define CATCH_CHECKED_IF( expr ) INTERNAL_CATCH_IF( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECKED_IF" )
-#define CATCH_CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECKED_ELSE" )
-#define CATCH_CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, "CATCH_CHECK_NOFAIL" )
+#define CATCH_CHECK( expr ) INTERNAL_CATCH_TEST( "CATCH_CHECK", Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CATCH_CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( "CATCH_CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, expr )
+#define CATCH_CHECKED_IF( expr ) INTERNAL_CATCH_IF( "CATCH_CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CATCH_CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CATCH_CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, expr )

-#define CATCH_CHECK_THROWS( expr )  INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::ContinueOnFailure, "", "CATCH_CHECK_THROWS" )
-#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THROWS_AS" )
-#define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::ContinueOnFailure, matcher, "CATCH_CHECK_THROWS_WITH" )
-#define CATCH_CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_NOTHROW" )
+#define CATCH_CHECK_THROWS( expr )  INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, "", expr )
+#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#define CATCH_CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( "CATCH_CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, expr )

-#define CATCH_CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THAT" )
-#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_THAT" )
+#define CATCH_CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )

-#define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( msg, "CATCH_INFO" )
-#define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, "CATCH_WARN", msg )
-#define CATCH_SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( msg, "CATCH_INFO" )
-#define CATCH_CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << Catch::toString(msg), "CATCH_CAPTURE" )
-#define CATCH_SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << Catch::toString(msg), "CATCH_CAPTURE" )
+#if defined(CATCH_CONFIG_FAST_COMPILE)
+#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT_NO_TRY( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+#else
+#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+#endif
+
+
+#define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
+#define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( "CATCH_WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
+#define CATCH_SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
+#define CATCH_CAPTURE( msg ) INTERNAL_CATCH_INFO( "CATCH_CAPTURE", #msg " := " << Catch::toString(msg) )
+#define CATCH_SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( "CATCH_CAPTURE", #msg " := " << Catch::toString(msg) )

 #ifdef CATCH_CONFIG_VARIADIC_MACROS
    #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
@@ -125,18 +136,18 @@ LeakDetector leakDetector;
    #define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
    #define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
    #define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
-    #define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "CATCH_FAIL", __VA_ARGS__ )
-    #define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, "CATCH_FAIL_CHECK", __VA_ARGS__ )
-    #define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "CATCH_SUCCEED", __VA_ARGS__ )
+    #define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
+    #define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+    #define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
 #else
    #define CATCH_TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description )
    #define CATCH_TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description )
    #define CATCH_METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description )
    #define CATCH_REGISTER_TEST_CASE( function, name, description ) INTERNAL_CATCH_REGISTER_TESTCASE( function, name, description )
    #define CATCH_SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description )
-    #define CATCH_FAIL( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "CATCH_FAIL", msg )
-    #define CATCH_FAIL_CHECK( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, "CATCH_FAIL_CHECK", msg )
-    #define CATCH_SUCCEED( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "CATCH_SUCCEED", msg )
+    #define CATCH_FAIL( msg ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, msg )
+    #define CATCH_FAIL_CHECK( msg ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, msg )
+    #define CATCH_SUCCEED( msg ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, msg )
 #endif
 #define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" )

@@ -162,33 +173,45 @@ LeakDetector leakDetector;
 // If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
 #else

-#define REQUIRE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal, "REQUIRE" )
-#define REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, "REQUIRE_FALSE" )
+#if defined(CATCH_CONFIG_FAST_COMPILE)
+#define REQUIRE( expr ) INTERNAL_CATCH_TEST_NO_TRY( "REQUIRE", Catch::ResultDisposition::Normal, expr )
+#define REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST_NO_TRY( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, expr )

-#define REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::Normal, "", "REQUIRE_THROWS" )
-#define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::Normal, "REQUIRE_THROWS_AS" )
-#define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::Normal, matcher, "REQUIRE_THROWS_WITH" )
-#define REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::Normal, "REQUIRE_NOTHROW" )
+#else
+#define REQUIRE( expr ) INTERNAL_CATCH_TEST( "REQUIRE", Catch::ResultDisposition::Normal, expr  )
+#define REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, expr )
+#endif

-#define CHECK( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECK" )
-#define CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, "CHECK_FALSE" )
-#define CHECKED_IF( expr ) INTERNAL_CATCH_IF( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECKED_IF" )
-#define CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECKED_ELSE" )
-#define CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, "CHECK_NOFAIL" )
+#define REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS", Catch::ResultDisposition::Normal, "", expr )
+#define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
+#define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
+#define REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( "REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, expr )

-#define CHECK_THROWS( expr )  INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::ContinueOnFailure, "", "CHECK_THROWS" )
-#define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::ContinueOnFailure, "CHECK_THROWS_AS" )
-#define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::ContinueOnFailure, matcher, "CHECK_THROWS_WITH" )
-#define CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECK_NOTHROW" )
+#define CHECK( expr ) INTERNAL_CATCH_TEST( "CHECK", Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( "CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, expr )
+#define CHECKED_IF( expr ) INTERNAL_CATCH_IF( "CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( "CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( "CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, expr )

-#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::ContinueOnFailure, "CHECK_THAT" )
-#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::Normal, "REQUIRE_THAT" )
+#define CHECK_THROWS( expr )  INTERNAL_CATCH_THROWS( "CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, "", expr )
+#define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#define CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( "CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, expr )

-#define INFO( msg ) INTERNAL_CATCH_INFO( msg, "INFO" )
-#define WARN( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, "WARN", msg )
-#define SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( msg, "INFO" )
-#define CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << Catch::toString(msg), "CAPTURE" )
-#define SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << Catch::toString(msg), "CAPTURE" )
+#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
+
+#if defined(CATCH_CONFIG_FAST_COMPILE)
+#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT_NO_TRY( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+#else
+#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+#endif
+
+
+#define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
+#define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
+#define SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
+#define CAPTURE( msg ) INTERNAL_CATCH_INFO( "CAPTURE", #msg " := " << Catch::toString(msg) )
+#define SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( "CAPTURE", #msg " := " << Catch::toString(msg) )

 #ifdef CATCH_CONFIG_VARIADIC_MACROS
 #define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
@@ -196,18 +219,18 @@ LeakDetector leakDetector;
 #define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
 #define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
 #define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
-#define FAIL( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "FAIL", __VA_ARGS__ )
-#define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, "FAIL_CHECK", __VA_ARGS__ )
-#define SUCCEED( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "SUCCEED", __VA_ARGS__ )
+#define FAIL( ... ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
+#define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
 #else
 #define TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description )
    #define TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description )
    #define METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description )
    #define REGISTER_TEST_CASE( method, name, description ) INTERNAL_CATCH_REGISTER_TESTCASE( method, name, description )
    #define SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description )
-    #define FAIL( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "FAIL", msg )
-    #define FAIL_CHECK( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, "FAIL_CHECK", msg )
-    #define SUCCEED( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "SUCCEED", msg )
+    #define FAIL( msg ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, msg )
+    #define FAIL_CHECK( msg ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, msg )
+    #define SUCCEED( msg ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, msg )
 #endif
 #define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" )

--- a/include/catch_session.hpp
+++ b/include/catch_session.hpp
@@ -125,7 +125,7 @@ namespace Catch {
        }

        void showHelp( std::string const& processName ) {
-            Catch::cout() << "\nCatch v" << libraryVersion << "\n";
+            Catch::cout() << "\nCatch v" << libraryVersion() << "\n";

            m_cli.usage( Catch::cout(), processName );
            Catch::cout() << "For more detail usage please see the project docs\n" << std::endl;
@@ -166,6 +166,32 @@ namespace Catch {
            return returnCode;
        }

+    #if defined(WIN32) && defined(UNICODE)
+        int run( int argc, wchar_t const* const* const argv ) {
+
+            char **utf8Argv = new char *[ argc ];
+
+            for ( int i = 0; i < argc; ++i ) {
+                int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, NULL, 0, NULL, NULL );
+
+                utf8Argv[ i ] = new char[ bufSize ];
+
+                WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, NULL, NULL );
+            }
+
+            int returnCode = applyCommandLine( argc, utf8Argv );
+            if( returnCode == 0 )
+                returnCode = run();
+
+            for ( int i = 0; i < argc; ++i )
+                delete [] utf8Argv[ i ];
+
+            delete [] utf8Argv;
+
+            return returnCode;
+        }
+    #endif
+
        int run() {
            if( m_configData.showHelp )
                return 0;
--- a/include/internal/catch_approx.hpp
+++ b/include/internal/catch_approx.hpp
@@ -40,15 +40,22 @@ namespace Detail {
            return Approx( 0 );
        }

-        Approx operator()( double value ) {
-            Approx approx( value );
+#if defined(CATCH_CONFIG_CPP11_TYPE_TRAITS)
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx operator()( T value ) {
+            Approx approx( static_cast<double>(value) );
            approx.epsilon( m_epsilon );
            approx.margin( m_margin );
            approx.scale( m_scale );
            return approx;
        }

-#if defined(CATCH_CONFIG_CPP11_TYPE_TRAITS)
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        explicit Approx( T value ): Approx(static_cast<double>(value))
+        {}
+
+
        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
        friend bool operator == ( const T& lhs, Approx const& rhs ) {
            // Thanks to Richard Harris for his help refining this formula
@@ -76,29 +83,54 @@ namespace Detail {
        }

        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator <= ( T lhs, Approx const& rhs )
-        {
-          return double(lhs) < rhs.m_value || lhs == rhs;
+        friend bool operator <= ( T lhs, Approx const& rhs ) {
+            return double(lhs) < rhs.m_value || lhs == rhs;
        }

        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator <= ( Approx const& lhs, T rhs )
-        {
-          return lhs.m_value < double(rhs) || lhs == rhs;
+        friend bool operator <= ( Approx const& lhs, T rhs ) {
+            return lhs.m_value < double(rhs) || lhs == rhs;
        }

        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator >= ( T lhs, Approx const& rhs )
-        {
-          return double(lhs) > rhs.m_value || lhs == rhs;
+        friend bool operator >= ( T lhs, Approx const& rhs ) {
+            return double(lhs) > rhs.m_value || lhs == rhs;
        }

        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator >= ( Approx const& lhs, T rhs )
-        {
-          return lhs.m_value > double(rhs) || lhs == rhs;
+        friend bool operator >= ( Approx const& lhs, T rhs ) {
+            return lhs.m_value > double(rhs) || lhs == rhs;
        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx& epsilon( T newEpsilon ) {
+            m_epsilon = double(newEpsilon);
+            return *this;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx& margin( T newMargin ) {
+            m_margin = double(newMargin);
+            return *this;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx& scale( T newScale ) {
+            m_scale = double(newScale);
+            return *this;
+        }
+
 #else
+
+        Approx operator()( double value ) {
+            Approx approx( value );
+            approx.epsilon( m_epsilon );
+            approx.margin( m_margin );
+            approx.scale( m_scale );
+            return approx;
+        }
+
+
        friend bool operator == ( double lhs, Approx const& rhs ) {
            // Thanks to Richard Harris for his help refining this formula
            bool relativeOK = std::fabs( lhs - rhs.m_value ) < rhs.m_epsilon * (rhs.m_scale + (std::max)( std::fabs(lhs), std::fabs(rhs.m_value) ) );
@@ -120,26 +152,21 @@ namespace Detail {
            return !operator==( rhs, lhs );
        }

-        friend bool operator <= ( double lhs, Approx const& rhs )
-        {
-          return lhs < rhs.m_value || lhs == rhs;
+        friend bool operator <= ( double lhs, Approx const& rhs ) {
+            return lhs < rhs.m_value || lhs == rhs;
        }

-        friend bool operator <= ( Approx const& lhs, double rhs )
-        {
-          return lhs.m_value < rhs || lhs == rhs;
+        friend bool operator <= ( Approx const& lhs, double rhs ) {
+            return lhs.m_value < rhs || lhs == rhs;
        }

-        friend bool operator >= ( double lhs, Approx const& rhs )
-        {
-          return lhs > rhs.m_value || lhs == rhs;
+        friend bool operator >= ( double lhs, Approx const& rhs ) {
+            return lhs > rhs.m_value || lhs == rhs;
        }

-        friend bool operator >= ( Approx const& lhs, double rhs )
-        {
-          return lhs.m_value > rhs || lhs == rhs;
+        friend bool operator >= ( Approx const& lhs, double rhs ) {
+            return lhs.m_value > rhs || lhs == rhs;
        }
-#endif

        Approx& epsilon( double newEpsilon ) {
            m_epsilon = newEpsilon;
@@ -155,6 +182,7 @@ namespace Detail {
            m_scale = newScale;
            return *this;
        }
+#endif

        std::string toString() const {
            std::ostringstream oss;
--- a/include/internal/catch_capture.hpp
+++ b/include/internal/catch_capture.hpp
@@ -16,7 +16,6 @@
 #include "catch_tostring.h"
 #include "catch_interfaces_runner.h"
 #include "catch_compiler_capabilities.h"
-#include "catch_type_traits.hpp"


 #if defined(CATCH_CONFIG_FAST_COMPILE)
@@ -26,6 +25,33 @@
 // macro in each assertion
 #define INTERNAL_CATCH_REACT( resultBuilder ) \
    resultBuilder.react();
+
+///////////////////////////////////////////////////////////////////////////////
+// Another way to speed-up compilation is to omit local try-catch for REQUIRE*
+// macros.
+// This can potentially cause false negative, if the test code catches
+// the exception before it propagates back up to the runner.
+#define INTERNAL_CATCH_TEST_NO_TRY( macroName, resultDisposition, expr ) \
+    do { \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \
+        __catchResult.setExceptionGuard(); \
+        CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+        ( __catchResult <= expr ).endExpression(); \
+        CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
+        __catchResult.unsetExceptionGuard(); \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::isTrue( false && static_cast<bool>( !!(expr) ) ) ) // expr here is never evaluated at runtime but it forces the compiler to give it a look
+// The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&.
+
+#define INTERNAL_CHECK_THAT_NO_TRY( macroName, matcher, resultDisposition, arg ) \
+    do { \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #arg ", " #matcher, resultDisposition ); \
+        __catchResult.setExceptionGuard(); \
+        __catchResult.captureMatch( arg, matcher, #matcher ); \
+        __catchResult.unsetExceptionGuard(); \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::alwaysFalse() )
+
 #else
 ///////////////////////////////////////////////////////////////////////////////
 // In the event of a failure works out if the debugger needs to be invoked
@@ -39,7 +65,7 @@


 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_TEST( expr, resultDisposition, macroName ) \
+#define INTERNAL_CATCH_TEST( macroName, resultDisposition, expr ) \
    do { \
        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \
        try { \
@@ -55,17 +81,17 @@
    // The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&.

 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_IF( expr, resultDisposition, macroName ) \
-    INTERNAL_CATCH_TEST( expr, resultDisposition, macroName ); \
+#define INTERNAL_CATCH_IF( macroName, resultDisposition, expr ) \
+    INTERNAL_CATCH_TEST( macroName, resultDisposition, expr ); \
    if( Catch::getResultCapture().getLastResult()->succeeded() )

 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_ELSE( expr, resultDisposition, macroName ) \
-    INTERNAL_CATCH_TEST( expr, resultDisposition, macroName ); \
+#define INTERNAL_CATCH_ELSE( macroName, resultDisposition, expr ) \
+    INTERNAL_CATCH_TEST( macroName, resultDisposition, expr ); \
    if( !Catch::getResultCapture().getLastResult()->succeeded() )

 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_NO_THROW( expr, resultDisposition, macroName ) \
+#define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, expr ) \
    do { \
        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \
        try { \
@@ -79,7 +105,7 @@
    } while( Catch::alwaysFalse() )

 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_THROWS( expr, resultDisposition, matcher, macroName ) \
+#define INTERNAL_CATCH_THROWS( macroName, resultDisposition, matcher, expr ) \
    do { \
        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition, #matcher ); \
        if( __catchResult.allowThrows() ) \
@@ -96,7 +122,7 @@
    } while( Catch::alwaysFalse() )

 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_THROWS_AS( expr, exceptionType, resultDisposition, macroName ) \
+#define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \
    do { \
        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr ", " #exceptionType, resultDisposition ); \
        if( __catchResult.allowThrows() ) \
@@ -104,7 +130,7 @@
                static_cast<void>(expr); \
                __catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \
            } \
-            catch( Catch::add_const<Catch::add_lvalue_reference<exceptionType>::type>::type ) { \
+            catch( exceptionType ) { \
                __catchResult.captureResult( Catch::ResultWas::Ok ); \
            } \
            catch( ... ) { \
@@ -118,7 +144,7 @@

 ///////////////////////////////////////////////////////////////////////////////
 #ifdef CATCH_CONFIG_VARIADIC_MACROS
-    #define INTERNAL_CATCH_MSG( messageType, resultDisposition, macroName, ... ) \
+    #define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \
        do { \
            Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \
            __catchResult << __VA_ARGS__ + ::Catch::StreamEndStop(); \
@@ -126,7 +152,7 @@
            INTERNAL_CATCH_REACT( __catchResult ) \
        } while( Catch::alwaysFalse() )
 #else
-    #define INTERNAL_CATCH_MSG( messageType, resultDisposition, macroName, log ) \
+    #define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, log ) \
        do { \
            Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \
            __catchResult << log + ::Catch::StreamEndStop(); \
@@ -136,11 +162,11 @@
 #endif

 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_INFO( log, macroName ) \
+#define INTERNAL_CATCH_INFO( macroName, log ) \
    Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage ) = Catch::MessageBuilder( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log;

 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CHECK_THAT( arg, matcher, resultDisposition, macroName ) \
+#define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
    do { \
        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #arg ", " #matcher, resultDisposition ); \
        try { \
--- a/include/internal/catch_compiler_capabilities.h
+++ b/include/internal/catch_compiler_capabilities.h
@@ -63,6 +63,12 @@
 #  endif

 #   if defined(CATCH_CPP11_OR_GREATER)
+#       define CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
+            _Pragma( "clang diagnostic push" ) \
+            _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" )
+#       define CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
+            _Pragma( "clang diagnostic pop" )
+
 #       define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
            _Pragma( "clang diagnostic push" ) \
            _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
@@ -74,13 +80,20 @@


 ////////////////////////////////////////////////////////////////////////////////
-// Cygwin
-#ifdef __CYGWIN__
+// We know some environments not to support full POSIX signals
+#if defined(__CYGWIN__) || defined(__QNX__)

 #   if !defined(CATCH_CONFIG_POSIX_SIGNALS)
 #       define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
 #   endif

+#endif
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Cygwin
+#ifdef __CYGWIN__
+
 // Required for some versions of Cygwin to declare gettimeofday
 // see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin
 #   define _BSD_SOURCE
@@ -112,23 +125,10 @@
 // GCC
 #ifdef __GNUC__

-#   if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
-#       define CATCH_GCC_HAS_NEW_PRAGMA
-#   endif
-
 #   if __GNUC__ == 4 && __GNUC_MINOR__ >= 6 && defined(__GXX_EXPERIMENTAL_CXX0X__)
 #       define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR
 #   endif

-#   if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS) && defined(CATCH_GCC_HAS_NEW_PRAGMA)
-#       define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
-            _Pragma( "GCC diagnostic push" ) \
-            _Pragma( "GCC diagnostic ignored \"-Wparentheses\"" )
-#       define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
-            _Pragma( "GCC diagnostic pop" )
-#   endif
-
-

 // - otherwise more recent versions define __cplusplus >= 201103L
 // and will get picked up below
@@ -270,7 +270,7 @@
 #   define CATCH_CONFIG_WINDOWS_SEH
 #endif
 // This is set by default, because we assume that unix compilers are posix-signal-compatible by default.
-#if !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS) 
+#if !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS)
 #   define CATCH_CONFIG_POSIX_SIGNALS
 #endif

@@ -278,6 +278,10 @@
 #   define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
 #   define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS
 #endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS
+#   define CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS
+#endif

 // noexcept support:
 #if defined(CATCH_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_NOEXCEPT)
--- a/include/internal/catch_default_main.hpp
+++ b/include/internal/catch_default_main.hpp
@@ -10,8 +10,14 @@

 #ifndef __OBJC__

+#if defined(WIN32) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
+// Standard C/C++ Win32 Unicode wmain entry point
+extern "C" int wmain (int argc, wchar_t * argv[], wchar_t * []) {
+#else
 // Standard C/C++ main entry point
 int main (int argc, char * argv[]) {
+#endif
+
 	int result = Catch::Session().run( argc, argv );
    return ( result < 0xff ? result : 0xff );
 }
--- a/include/internal/catch_generators.hpp
+++ b/include/internal/catch_generators.hpp
@@ -10,7 +10,6 @@

 #include "catch_context.h"

-#include <iterator>
 #include <vector>
 #include <string>
 #include <stdlib.h>
@@ -124,7 +123,7 @@ public:
 private:

    void move( CompositeGenerator& other ) {
-        std::copy( other.m_composed.begin(), other.m_composed.end(), std::back_inserter( m_composed ) );
+        m_composed.insert( m_composed.end(), other.m_composed.begin(), other.m_composed.end() );
        m_totalSize += other.m_totalSize;
        other.m_composed.clear();
    }
--- a/include/internal/catch_interfaces_capture.h
+++ b/include/internal/catch_interfaces_capture.h
@@ -38,6 +38,8 @@ namespace Catch {
        virtual std::string getCurrentTestName() const = 0;
        virtual const AssertionResult* getLastResult() const = 0;

+        virtual void exceptionEarlyReported() = 0;
+
        virtual void handleFatalErrorCondition( std::string const& message ) = 0;
    };

--- a/include/internal/catch_interfaces_registry_hub.h
+++ b/include/internal/catch_interfaces_registry_hub.h
@@ -20,12 +20,15 @@ namespace Catch {
    struct IExceptionTranslator;
    struct IReporterRegistry;
    struct IReporterFactory;
+    struct ITagAliasRegistry;

    struct IRegistryHub {
        virtual ~IRegistryHub();

        virtual IReporterRegistry const& getReporterRegistry() const = 0;
        virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
+        virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0;
+
        virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() = 0;
    };

@@ -35,6 +38,7 @@ namespace Catch {
        virtual void registerListener( Ptr<IReporterFactory> const& factory ) = 0;
        virtual void registerTest( TestCase const& testInfo ) = 0;
        virtual void registerTranslator( const IExceptionTranslator* translator ) = 0;
+        virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) = 0;
    };

    IRegistryHub& getRegistryHub();
--- a/include/internal/catch_message.hpp
+++ b/include/internal/catch_message.hpp
@@ -38,7 +38,9 @@ namespace Catch {
    {}

    ScopedMessage::~ScopedMessage() {
-        getResultCapture().popScopedMessage( m_info );
+        if ( !std::uncaught_exception() ){
+            getResultCapture().popScopedMessage(m_info);
+        }
    }


--- a/include/internal/catch_option.hpp
+++ b/include/internal/catch_option.hpp
@@ -66,8 +66,18 @@ namespace Catch {
        }

    private:
-        T* nullableValue;
-        char storage[sizeof(T)];
+        T *nullableValue;
+        union {
+            char storage[sizeof(T)];
+    
+            // These are here to force alignment for the storage
+            long double dummy1;
+            void (*dummy2)();
+            long double dummy3;
+#ifdef CATCH_CONFIG_CPP11_LONG_LONG
+            long long dummy4;
+#endif
+        };
    };

 } // end namespace Catch
--- a/include/internal/catch_registry_hub.hpp
+++ b/include/internal/catch_registry_hub.hpp
@@ -13,6 +13,7 @@
 #include "catch_test_case_registry_impl.hpp"
 #include "catch_reporter_registry.hpp"
 #include "catch_exception_translator_registry.hpp"
+#include "catch_tag_alias_registry.h"

 namespace Catch {

@@ -35,6 +36,10 @@ namespace Catch {
            virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() CATCH_OVERRIDE {
                return m_exceptionTranslatorRegistry;
            }
+            virtual ITagAliasRegistry const& getTagAliasRegistry() const CATCH_OVERRIDE {
+                return m_tagAliasRegistry;
+            }
+

        public: // IMutableRegistryHub
            virtual void registerReporter( std::string const& name, Ptr<IReporterFactory> const& factory ) CATCH_OVERRIDE {
@@ -49,11 +54,15 @@ namespace Catch {
            virtual void registerTranslator( const IExceptionTranslator* translator ) CATCH_OVERRIDE {
                m_exceptionTranslatorRegistry.registerTranslator( translator );
            }
+            virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) CATCH_OVERRIDE {
+                m_tagAliasRegistry.add( alias, tag, lineInfo );
+            }

        private:
            TestRegistry m_testCaseRegistry;
            ReporterRegistry m_reporterRegistry;
            ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
+            TagAliasRegistry m_tagAliasRegistry;
        };

        // Single, global, instance
--- a/include/internal/catch_result_builder.h
+++ b/include/internal/catch_result_builder.h
@@ -39,6 +39,7 @@ namespace Catch {
                        char const* capturedExpression,
                        ResultDisposition::Flags resultDisposition,
                        char const* secondArg = "" );
+        ~ResultBuilder();

        template<typename T>
        ExpressionLhs<T const&> operator <= ( T const& operand );
@@ -73,6 +74,9 @@ namespace Catch {
        template<typename ArgT, typename MatcherT>
        void captureMatch( ArgT const& arg, MatcherT const& matcher, char const* matcherString );

+        void setExceptionGuard();
+        void unsetExceptionGuard();
+
    private:
        AssertionInfo m_assertionInfo;
        AssertionResultData m_data;
@@ -80,6 +84,7 @@ namespace Catch {

        bool m_shouldDebugBreak;
        bool m_shouldThrow;
+        bool m_guardException;
    };

 } // namespace Catch
--- a/include/internal/catch_result_builder.hpp
+++ b/include/internal/catch_result_builder.hpp
@@ -30,9 +30,20 @@ namespace Catch {
                                    char const* secondArg )
    :   m_assertionInfo( macroName, lineInfo, capturedExpressionWithSecondArgument( capturedExpression, secondArg ), resultDisposition ),
        m_shouldDebugBreak( false ),
-        m_shouldThrow( false )
+        m_shouldThrow( false ),
+        m_guardException( false )
    {}

+    ResultBuilder::~ResultBuilder() {
+#if defined(CATCH_CONFIG_FAST_COMPILE)
+        if ( m_guardException ) {
+            m_stream.oss << "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE";
+            captureResult( ResultWas::ThrewException );
+            getCurrentContext().getResultCapture()->exceptionEarlyReported();
+        }
+#endif
+    }
+
    ResultBuilder& ResultBuilder::setResultType( ResultWas::OfType result ) {
        m_data.resultType = result;
        return *this;
@@ -146,6 +157,13 @@ namespace Catch {
        dest = m_assertionInfo.capturedExpression;
    }

+    void ResultBuilder::setExceptionGuard() {
+        m_guardException = true;
+    }
+    void ResultBuilder::unsetExceptionGuard() {
+        m_guardException = false;
+    }
+
 } // end namespace Catch

 #endif // TWOBLUECUBES_CATCH_RESULT_BUILDER_HPP_INCLUDED
--- a/include/internal/catch_run_context.hpp
+++ b/include/internal/catch_run_context.hpp
@@ -64,7 +64,8 @@ namespace Catch {
            m_context( getCurrentMutableContext() ),
            m_activeTestCase( CATCH_NULL ),
            m_config( _config ),
-            m_reporter( reporter )
+            m_reporter( reporter ),
+            m_shouldReportUnexpected ( true )
        {
            m_context.setRunner( this );
            m_context.setConfig( m_config );
@@ -144,8 +145,9 @@ namespace Catch {
                m_totals.assertions.failed++;
            }

-            if( m_reporter->assertionEnded( AssertionStats( result, m_messages, m_totals ) ) )
-                m_messages.clear();
+            // We have no use for the return value (whether messages should be cleared), because messages were made scoped
+            // and should be let to clear themselves out.
+            static_cast<void>(m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals)));

            // Reset working state
            m_lastAssertionInfo = AssertionInfo( std::string(), m_lastAssertionInfo.lineInfo, "{Unknown expression after the reported line}" , m_lastAssertionInfo.resultDisposition );
@@ -223,6 +225,10 @@ namespace Catch {
            return &m_lastResult;
        }

+        virtual void exceptionEarlyReported() {
+            m_shouldReportUnexpected = false;
+        }
+
        virtual void handleFatalErrorCondition( std::string const& message ) {
            // Don't rebuild the result -- the stringification itself can cause more fatal errors
            // Instead, fake a result data.
@@ -272,6 +278,7 @@ namespace Catch {
            m_reporter->sectionStarting( testCaseSection );
            Counts prevAssertions = m_totals.assertions;
            double duration = 0;
+            m_shouldReportUnexpected = true;
            try {
                m_lastAssertionInfo = AssertionInfo( "TEST_CASE", testCaseInfo.lineInfo, std::string(), ResultDisposition::Normal );

@@ -293,7 +300,11 @@ namespace Catch {
                // This just means the test was aborted due to failure
            }
            catch(...) {
-                makeUnexpectedResultBuilder().useActiveException();
+                // Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions 
+                // are reported without translation at the point of origin.
+                if (m_shouldReportUnexpected) {
+                    makeUnexpectedResultBuilder().useActiveException();
+                }
            }
            m_testCaseTracker->close();
            handleUnfinishedSections();
@@ -353,6 +364,7 @@ namespace Catch {
        std::vector<SectionEndInfo> m_unfinishedSections;
        std::vector<ITracker*> m_activeSections;
        TrackerContext m_trackerContext;
+        bool m_shouldReportUnexpected;
    };

    IResultCapture& getResultCapture() {
--- a/include/internal/catch_suppress_warnings.h
+++ b/include/internal/catch_suppress_warnings.h
@@ -24,11 +24,7 @@
 #elif defined __GNUC__
 #    pragma GCC diagnostic ignored "-Wvariadic-macros"
 #    pragma GCC diagnostic ignored "-Wunused-variable"
-
-     // For newer version we can use __Pragma to disable the warnings locally
-#    if __GNUC__ == 4 && __GNUC_MINOR__ >= 4 && __GNUC_MINOR__ <= 7
-#        pragma GCC diagnostic ignored "-Wparentheses"
-#    endif
+#    pragma GCC diagnostic ignored "-Wparentheses"

 #    pragma GCC diagnostic push
 #    pragma GCC diagnostic ignored "-Wpadded"
--- a/include/internal/catch_tag_alias_registry.h
+++ b/include/internal/catch_tag_alias_registry.h
@@ -19,8 +19,7 @@ namespace Catch {
        virtual ~TagAliasRegistry();
        virtual Option<TagAlias> find( std::string const& alias ) const;
        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const;
-        void add( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
-        static TagAliasRegistry& get();
+        void add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo );

    private:
        std::map<std::string, TagAlias> m_registry;
--- a/include/internal/catch_tag_alias_registry.hpp
+++ b/include/internal/catch_tag_alias_registry.hpp
@@ -10,6 +10,8 @@

 #include "catch_tag_alias_registry.h"
 #include "catch_console_colour.hpp"
+#include "catch_interfaces_registry_hub.h"
+#include "catch_stream.h"

 namespace Catch {

@@ -38,41 +40,36 @@ namespace Catch {
        return expandedTestSpec;
    }

-    void TagAliasRegistry::add( char const* alias, char const* tag, SourceLineInfo const& lineInfo ) {
+    void TagAliasRegistry::add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) {

        if( !startsWith( alias, "[@" ) || !endsWith( alias, ']' ) ) {
            std::ostringstream oss;
-            oss << "error: tag alias, \"" << alias << "\" is not of the form [@alias name].\n" << lineInfo;
+            oss << Colour( Colour::Red )
+                << "error: tag alias, \"" << alias << "\" is not of the form [@alias name].\n"
+                << Colour( Colour::FileName )
+                << lineInfo << '\n';
            throw std::domain_error( oss.str().c_str() );
        }
        if( !m_registry.insert( std::make_pair( alias, TagAlias( tag, lineInfo ) ) ).second ) {
            std::ostringstream oss;
-            oss << "error: tag alias, \"" << alias << "\" already registered.\n"
-                << "\tFirst seen at " << find(alias)->lineInfo << '\n'
-                << "\tRedefined at " << lineInfo;
+            oss << Colour( Colour::Red )
+                << "error: tag alias, \"" << alias << "\" already registered.\n"
+                << "\tFirst seen at "
+                << Colour( Colour::Red ) << find(alias)->lineInfo << '\n'
+                << Colour( Colour::Red ) << "\tRedefined at "
+                << Colour( Colour::FileName) << lineInfo << '\n';
            throw std::domain_error( oss.str().c_str() );
        }
    }

-    TagAliasRegistry& TagAliasRegistry::get() {
-        static TagAliasRegistry instance;
-        return instance;
+    ITagAliasRegistry::~ITagAliasRegistry() {}

+    ITagAliasRegistry const& ITagAliasRegistry::get() {
+        return getRegistryHub().getTagAliasRegistry();
    }

-    ITagAliasRegistry::~ITagAliasRegistry() {}
-    ITagAliasRegistry const& ITagAliasRegistry::get() { return TagAliasRegistry::get(); }
-
-
    RegistrarForTagAliases::RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo ) {
-        try {
-            TagAliasRegistry::get().add( alias, tag, lineInfo );
-        }
-        catch( std::exception& ex ) {
-            Colour colourGuard( Colour::Red );
-            Catch::cerr() << ex.what() << std::endl;
-            exit(1);
-        }
+        getMutableRegistryHub().registerTagAlias( alias, tag, lineInfo );
    }

 } // end namespace Catch
--- a/include/internal/catch_test_case_info.hpp
+++ b/include/internal/catch_test_case_info.hpp
@@ -38,17 +38,13 @@ namespace Catch {
    }
    inline void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
        if( isReservedTag( tag ) ) {
-            {
-                Colour colourGuard( Colour::Red );
-                Catch::cerr()
-                    << "Tag name [" << tag << "] not allowed.\n"
-                    << "Tag names starting with non alpha-numeric characters are reserved\n";
-            }
-            {
-                Colour colourGuard( Colour::FileName );
-                Catch::cerr() << _lineInfo << std::endl;
-            }
-            exit(1);
+            std::ostringstream ss;
+            ss << Colour(Colour::Red)
+               << "Tag name [" << tag << "] not allowed.\n"
+               << "Tag names starting with non alpha-numeric characters are reserved\n"
+               << Colour(Colour::FileName)
+               << _lineInfo << '\n';
+            throw std::runtime_error(ss.str());
        }
    }

--- a/include/internal/catch_test_case_tracker.hpp
+++ b/include/internal/catch_test_case_tracker.hpp
@@ -11,13 +11,14 @@
 #include "catch_compiler_capabilities.h"
 #include "catch_ptr.hpp"

-#include <map>
+#include <algorithm>
 #include <string>
 #include <assert.h>
 #include <vector>
-#include <iterator>
 #include <stdexcept>

+CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS
+
 namespace Catch {
 namespace TestCaseTracking {

@@ -290,12 +291,12 @@ namespace TestCaseTracking {
            if( !filters.empty() ) {
                m_filters.push_back(""); // Root - should never be consulted
                m_filters.push_back(""); // Test Case - not a section filter
-                std::copy( filters.begin(), filters.end(), std::back_inserter( m_filters ) );
+                m_filters.insert( m_filters.end(), filters.begin(), filters.end() );
            }
        }
        void addNextFilters( std::vector<std::string> const& filters ) {
            if( filters.size() > 1 )
-                std::copy( filters.begin()+1, filters.end(), std::back_inserter( m_filters ) );
+                m_filters.insert( m_filters.end(), ++filters.begin(), filters.end() );
        }
    };

@@ -365,4 +366,6 @@ using TestCaseTracking::IndexTracker;

 } // namespace Catch

+CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS
+
 #endif // TWOBLUECUBES_CATCH_TEST_CASE_TRACKER_HPP_INCLUDED
--- a/include/internal/catch_test_registry.hpp
+++ b/include/internal/catch_test_registry.hpp
@@ -87,59 +87,76 @@ void registerTestCaseFunction
    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \
        static void TestName(); \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &TestName, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); }\
+        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &TestName, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); } \
+        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
        static void TestName()
    #define INTERNAL_CATCH_TESTCASE( ... ) \
        INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), __VA_ARGS__ )

    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); }
+        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); } \
+        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS

    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\
+        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
        namespace{ \
            struct TestName : ClassName{ \
                void test(); \
            }; \
            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &TestName::test, #ClassName, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); \
        } \
+        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
        void TestName::test()
    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \
        INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), ClassName, __VA_ARGS__ )

    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \
-        Catch::AutoReg( Function, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) );
+        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
+        Catch::AutoReg( Function, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); \
+        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS

 #else
    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_TESTCASE2( TestName, Name, Desc ) \
        static void TestName(); \
+        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &TestName, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) ); }\
+        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
        static void TestName()
    #define INTERNAL_CATCH_TESTCASE( Name, Desc ) \
        INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), Name, Desc )

    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, Name, Desc ) \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( Name, Desc ), CATCH_INTERNAL_LINEINFO ); }
+        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( Name, Desc ), CATCH_INTERNAL_LINEINFO ); } \
+        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS

    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestCaseName, ClassName, TestName, Desc )\
+        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
        namespace{ \
            struct TestCaseName : ClassName{ \
                void test(); \
            }; \
            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &TestCaseName::test, #ClassName, Catch::NameAndDesc( TestName, Desc ), CATCH_INTERNAL_LINEINFO ); \
        } \
+        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
        void TestCaseName::test()
    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, TestName, Desc )\
        INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), ClassName, TestName, Desc )

    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, Name, Desc ) \
-        Catch::AutoReg( Function, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) );
+        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
+        Catch::AutoReg( Function, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) ); \
+        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS
+
 #endif

 #endif // TWOBLUECUBES_CATCH_TEST_REGISTRY_HPP_INCLUDED
--- a/include/internal/catch_timer.h
+++ b/include/internal/catch_timer.h
@@ -10,14 +10,20 @@

 #include "catch_platform.h"

-#ifdef CATCH_PLATFORM_WINDOWS
-typedef unsigned long long uint64_t;
-#else
-#include <stdint.h>
-#endif
+#ifdef _MSC_VER

 namespace Catch {
+    typedef unsigned long long UInt64;
+}
+#else
+#include <stdint.h>
+namespace Catch {
+    typedef uint64_t UInt64;
+}
+#endif

+
+namespace Catch {
    class Timer {
    public:
        Timer() : m_ticks( 0 ) {}
@@ -27,7 +33,7 @@ namespace Catch {
        double getElapsedSeconds() const;

    private:
-        uint64_t m_ticks;
+        UInt64 m_ticks;
    };

 } // namespace Catch
--- a/include/internal/catch_timer.hpp
+++ b/include/internal/catch_timer.hpp
@@ -28,21 +28,21 @@ namespace Catch {

    namespace {
 #ifdef CATCH_PLATFORM_WINDOWS
-        uint64_t getCurrentTicks() {
-            static uint64_t hz=0, hzo=0;
+        UInt64 getCurrentTicks() {
+            static UInt64 hz=0, hzo=0;
            if (!hz) {
                QueryPerformanceFrequency( reinterpret_cast<LARGE_INTEGER*>( &hz ) );
                QueryPerformanceCounter( reinterpret_cast<LARGE_INTEGER*>( &hzo ) );
            }
-            uint64_t t;
+            UInt64 t;
            QueryPerformanceCounter( reinterpret_cast<LARGE_INTEGER*>( &t ) );
            return ((t-hzo)*1000000)/hz;
        }
 #else
-        uint64_t getCurrentTicks() {
+        UInt64 getCurrentTicks() {
            timeval t;
            gettimeofday(&t,CATCH_NULL);
-            return static_cast<uint64_t>( t.tv_sec ) * 1000000ull + static_cast<uint64_t>( t.tv_usec );
+            return static_cast<UInt64>( t.tv_sec ) * 1000000ull + static_cast<UInt64>( t.tv_usec );
        }
 #endif
    }
--- a/include/internal/catch_tostring.h
+++ b/include/internal/catch_tostring.h
@@ -72,6 +72,7 @@ namespace Detail {

    extern const std::string unprintableString;

+ #if !defined(CATCH_CONFIG_CPP11_STREAM_INSERTABLE_CHECK)
    struct BorgType {
        template<typename T> BorgType( T const& );
    };
@@ -90,6 +91,20 @@ namespace Detail {
        static T  const&t;
        enum { value = sizeof( testStreamable(s << t) ) == sizeof( TrueType ) };
    };
+#else
+    template<typename T>
+    class IsStreamInsertable {
+        template<typename SS, typename TT>
+        static auto test(int)
+        -> decltype( std::declval<SS&>() << std::declval<TT>(), std::true_type() );
+
+        template<typename, typename>
+        static auto test(...) -> std::false_type;
+
+    public:
+        static const bool value = decltype(test<std::ostream,const T&>(0))::value;
+    };
+#endif

 #if defined(CATCH_CONFIG_CPP11_IS_ENUM)
    template<typename T,
--- a/include/internal/catch_version.h
+++ b/include/internal/catch_version.h
@@ -15,7 +15,7 @@ namespace Catch {
        Version(    unsigned int _majorVersion,
                    unsigned int _minorVersion,
                    unsigned int _patchNumber,
-                    std::string const& _branchName,
+                    char const * const _branchName,
                    unsigned int _buildNumber );

        unsigned int const majorVersion;
@@ -23,7 +23,7 @@ namespace Catch {
        unsigned int const patchNumber;

        // buildNumber is only used if branchName is not null
-        std::string const branchName;
+        char const * const branchName;
        unsigned int const buildNumber;

        friend std::ostream& operator << ( std::ostream& os, Version const& version );
@@ -32,7 +32,7 @@ namespace Catch {
        void operator=( Version const& );
    };

-    extern Version libraryVersion;
+    inline Version libraryVersion();
 }

 #endif // TWOBLUECUBES_CATCH_VERSION_H_INCLUDED
--- a/include/internal/catch_version.hpp
+++ b/include/internal/catch_version.hpp
@@ -16,7 +16,7 @@ namespace Catch {
        (   unsigned int _majorVersion,
            unsigned int _minorVersion,
            unsigned int _patchNumber,
-            std::string const& _branchName,
+            char const * const _branchName,
            unsigned int _buildNumber )
    :   majorVersion( _majorVersion ),
        minorVersion( _minorVersion ),
@@ -29,15 +29,18 @@ namespace Catch {
        os  << version.majorVersion << '.'
            << version.minorVersion << '.'
            << version.patchNumber;
-
-        if( !version.branchName.empty() ) {
-            os  << '-' << version.branchName
-                << '.' << version.buildNumber;
+        // branchName is never null -> 0th char is \0 if it is empty
+        if (version.branchName[0]) {
+            os << '-' << version.branchName
+               << '.' << version.buildNumber;
        }
        return os;
    }

-    Version libraryVersion( 1, 8, 2, "", 0 );
+    inline Version libraryVersion() {
+        static Version version( 1, 9, 4, "", 0 );
+        return version;
+    }

 }

--- a/include/reporters/catch_reporter_console.hpp
+++ b/include/reporters/catch_reporter_console.hpp
@@ -138,7 +138,11 @@ namespace Catch {
                    case ResultWas::ThrewException:
                        colour = Colour::Error;
                        passOrFail = "FAILED";
-                        messageLabel = "due to unexpected exception with message";
+                        messageLabel = "due to unexpected exception with ";
+                        if (_stats.infoMessages.size() == 1)
+                            messageLabel += "message";
+                        if (_stats.infoMessages.size() > 1)
+                            messageLabel += "messages";
                        break;
                    case ResultWas::FatalErrorCondition:
                        colour = Colour::Error;
@@ -254,7 +258,7 @@ namespace Catch {
            stream  << '\n' << getLineOfChars<'~'>() << '\n';
            Colour colour( Colour::SecondaryText );
            stream  << currentTestRunInfo->name
-                    << " is a Catch v"  << libraryVersion << " host application.\n"
+                    << " is a Catch v"  << libraryVersion() << " host application.\n"
                    << "Run with -? for options\n\n";

            if( m_config->rngSeed() != 0 )
--- a/include/reporters/catch_reporter_junit.hpp
+++ b/include/reporters/catch_reporter_junit.hpp
@@ -51,7 +51,8 @@ namespace Catch {
    public:
        JunitReporter( ReporterConfig const& _config )
        :   CumulativeReporterBase( _config ),
-            xml( _config.stream() )
+            xml( _config.stream() ),
+            m_okToFail( false )
        {
            m_reporterPrefs.shouldRedirectStdOut = true;
        }
@@ -77,8 +78,11 @@ namespace Catch {
            CumulativeReporterBase::testGroupStarting( groupInfo );
        }

+        virtual void testCaseStarting( TestCaseInfo const& testCaseInfo ) CATCH_OVERRIDE {
+            m_okToFail = testCaseInfo.okToFail();
+        }
        virtual bool assertionEnded( AssertionStats const& assertionStats ) CATCH_OVERRIDE {
-            if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException )
+            if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException && !m_okToFail )
                unexpectedExceptions++;
            return CumulativeReporterBase::assertionEnded( assertionStats );
        }
@@ -243,6 +247,7 @@ namespace Catch {
        std::ostringstream stdOutForSuite;
        std::ostringstream stdErrForSuite;
        unsigned int unexpectedExceptions;
+        bool m_okToFail;
    };

    INTERNAL_CATCH_REGISTER_REPORTER( "junit", JunitReporter )
--- a/include/reporters/catch_reporter_teamcity.hpp
+++ b/include/reporters/catch_reporter_teamcity.hpp
@@ -49,14 +49,7 @@ namespace Catch {
            return "Reports test results as TeamCity service messages";
        }

-        virtual void skipTest( TestCaseInfo const& testInfo ) CATCH_OVERRIDE {
-            stream  << "##teamcity[testIgnored name='"
-                    << escape( testInfo.name ) << "'";
-            if( testInfo.isHidden() )
-                stream << " message='hidden test'";
-            else
-                stream << " message='test skipped because it didn|'t match the test spec'";
-            stream << "]\n";
+        virtual void skipTest( TestCaseInfo const& /* testInfo */ ) CATCH_OVERRIDE {
        }

        virtual void noMatchingTestCases( std::string const& /* spec */ ) CATCH_OVERRIDE {}
@@ -134,10 +127,19 @@ namespace Catch {
                        "  " << result.getExpandedExpression() << "\n";
                }

-                stream << "##teamcity[testFailed"
-                    << " name='" << escape( currentTestCaseInfo->name )<< "'"
-                    << " message='" << escape( msg.str() ) << "'"
-                    << "]\n";
+                if( currentTestCaseInfo->okToFail() ) {
+                    msg << "- failure ignore as test marked as 'ok to fail'\n";
+                    stream << "##teamcity[testIgnored"
+                           << " name='" << escape( currentTestCaseInfo->name )<< "'"
+                           << " message='" << escape( msg.str() ) << "'"
+                           << "]\n";
+                }
+                else {
+                    stream << "##teamcity[testFailed"
+                           << " name='" << escape( currentTestCaseInfo->name )<< "'"
+                           << " message='" << escape( msg.str() ) << "'"
+                           << "]\n";
+                }
            }
            return true;
        }
@@ -203,7 +205,6 @@ namespace Catch {
        }
    private:
        bool m_headerPrintedForThisSection;
-
    };

 #ifdef CATCH_IMPL
--- a/projects/SelfTest/Baselines/console.std.approved.txt
+++ b/projects/SelfTest/Baselines/console.std.approved.txt
@@ -3,6 +3,31 @@
 <exe-name> is a <version> host application.
 Run with -? for options

+-------------------------------------------------------------------------------
+#748 - captures with unexpected exceptions
+  outside assertions
+-------------------------------------------------------------------------------
+ExceptionTests.cpp:<line number>
+...............................................................................
+
+ExceptionTests.cpp:<line number>: FAILED:
+due to unexpected exception with messages:
+  answer := 42
+  expected exception
+
+-------------------------------------------------------------------------------
+#748 - captures with unexpected exceptions
+  inside REQUIRE_NOTHROW
+-------------------------------------------------------------------------------
+ExceptionTests.cpp:<line number>
+...............................................................................
+
+ExceptionTests.cpp:<line number>: FAILED:
+  REQUIRE_NOTHROW( thisThrows() )
+due to unexpected exception with messages:
+  answer := 42
+  expected exception
+
 -------------------------------------------------------------------------------
 #835 -- errno should not be touched by Catch
 -------------------------------------------------------------------------------
@@ -343,7 +368,9 @@ MessageTests.cpp:<line number>: FAILED:
  CHECK( a == 0 )
 with expansion:
  2 == 0
-with message:
+with messages:
+  this message may be logged later
+  this message should be logged
  and this, but later

 -------------------------------------------------------------------------------
@@ -915,6 +942,6 @@ with expansion:
  "first" == "second"

 ===============================================================================
-test cases: 166 | 119 passed | 44 failed |  3 failed as expected
-assertions: 961 | 855 passed | 87 failed | 19 failed as expected
+test cases: 167 | 119 passed | 44 failed |  4 failed as expected
+assertions: 967 | 859 passed | 87 failed | 21 failed as expected

--- a/projects/SelfTest/Baselines/console.sw.approved.txt
+++ b/projects/SelfTest/Baselines/console.sw.approved.txt
@@ -15,26 +15,42 @@ with message:
  yay

 -------------------------------------------------------------------------------
-#542
+#748 - captures with unexpected exceptions
+  outside assertions
 -------------------------------------------------------------------------------
-CompilationTests.cpp:<line number>
+ExceptionTests.cpp:<line number>
 ...............................................................................

-CompilationTests.cpp:<line number>:
-PASSED:
-  CHECK_THROWS_AS( throws_int(true), int )
+ExceptionTests.cpp:<line number>: FAILED:
+due to unexpected exception with messages:
+  answer := 42
+  expected exception

-CompilationTests.cpp:<line number>:
-PASSED:
-  CHECK_THROWS_AS( throws_int(true), int& )
+-------------------------------------------------------------------------------
+#748 - captures with unexpected exceptions
+  inside REQUIRE_NOTHROW
+-------------------------------------------------------------------------------
+ExceptionTests.cpp:<line number>
+...............................................................................

-CompilationTests.cpp:<line number>:
-PASSED:
-  CHECK_THROWS_AS( throws_int(true), const int )
+ExceptionTests.cpp:<line number>: FAILED:
+  REQUIRE_NOTHROW( thisThrows() )
+due to unexpected exception with messages:
+  answer := 42
+  expected exception

-CompilationTests.cpp:<line number>:
+-------------------------------------------------------------------------------
+#748 - captures with unexpected exceptions
+  inside REQUIRE_THROWS
+-------------------------------------------------------------------------------
+ExceptionTests.cpp:<line number>
+...............................................................................
+
+ExceptionTests.cpp:<line number>:
 PASSED:
-  CHECK_THROWS_AS( throws_int(true), const int& )
+  REQUIRE_THROWS( thisThrows() )
+with message:
+  answer := 42

 -------------------------------------------------------------------------------
 #809
@@ -48,6 +64,48 @@ PASSED:
 with expansion:
  42 == {?}

+-------------------------------------------------------------------------------
+#833
+-------------------------------------------------------------------------------
+CompilationTests.cpp:<line number>
+...............................................................................
+
+CompilationTests.cpp:<line number>:
+PASSED:
+  REQUIRE( a == t )
+with expansion:
+  3 == 3
+
+CompilationTests.cpp:<line number>:
+PASSED:
+  CHECK( a == t )
+with expansion:
+  3 == 3
+
+CompilationTests.cpp:<line number>:
+PASSED:
+  REQUIRE_THROWS( throws_int(true) )
+
+CompilationTests.cpp:<line number>:
+PASSED:
+  CHECK_THROWS_AS( throws_int(true), const int& )
+
+CompilationTests.cpp:<line number>:
+PASSED:
+  REQUIRE_NOTHROW( throws_int(false) )
+
+CompilationTests.cpp:<line number>:
+PASSED:
+  REQUIRE_THAT( "aaa", Catch::EndsWith("aaa") )
+with expansion:
+  "aaa" ends with: "aaa"
+
+CompilationTests.cpp:<line number>:
+PASSED:
+  REQUIRE( templated_tests<int>(3) )
+with expansion:
+  true
+
 -------------------------------------------------------------------------------
 #835 -- errno should not be touched by Catch
 -------------------------------------------------------------------------------
@@ -61,7 +119,7 @@ with expansion:

 MiscTests.cpp:<line number>:
 PASSED:
-  REQUIRE( (*__error()) == 1 )
+  REQUIRE( errno == 1 )
 with expansion:
  1 == 1

@@ -2659,14 +2717,17 @@ MessageTests.cpp:<line number>: FAILED:
  CHECK( a == 1 )
 with expansion:
  2 == 1
-with message:
+with messages:
+  this message may be logged later
  this message should be logged

 MessageTests.cpp:<line number>: FAILED:
  CHECK( a == 0 )
 with expansion:
  2 == 0
-with message:
+with messages:
+  this message may be logged later
+  this message should be logged
  and this, but later

 MessageTests.cpp:<line number>:
@@ -2674,7 +2735,10 @@ PASSED:
  CHECK( a == 2 )
 with expansion:
  2 == 2
-with message:
+with messages:
+  this message may be logged later
+  this message should be logged
+  and this, but later
  but not this

 -------------------------------------------------------------------------------
@@ -6807,7 +6871,8 @@ PASSED:
 with expansion:
  "error: tag alias, "[@zzz]" already registered.
  	First seen at file:2
-  	Redefined at file:10" contains: "[@zzz]"
+  	Redefined at file:10
+  " contains: "[@zzz]"

 TagAliasTests.cpp:<line number>:
 PASSED:
@@ -6815,7 +6880,8 @@ PASSED:
 with expansion:
  "error: tag alias, "[@zzz]" already registered.
  	First seen at file:2
-  	Redefined at file:10" contains: "file"
+  	Redefined at file:10
+  " contains: "file"

 TagAliasTests.cpp:<line number>:
 PASSED:
@@ -6823,7 +6889,8 @@ PASSED:
 with expansion:
  "error: tag alias, "[@zzz]" already registered.
  	First seen at file:2
-  	Redefined at file:10" contains: "2"
+  	Redefined at file:10
+  " contains: "2"

 TagAliasTests.cpp:<line number>:
 PASSED:
@@ -6831,7 +6898,8 @@ PASSED:
 with expansion:
  "error: tag alias, "[@zzz]" already registered.
  	First seen at file:2
-  	Redefined at file:10" contains: "10"
+  	Redefined at file:10
+  " contains: "10"

 -------------------------------------------------------------------------------
 Tag alias can be registered against tag patterns
@@ -9404,6 +9472,6 @@ MiscTests.cpp:<line number>:
 PASSED:

 ===============================================================================
-test cases: 166 | 118 passed | 45 failed |  3 failed as expected
-assertions: 963 | 855 passed | 89 failed | 19 failed as expected
+test cases: 167 | 118 passed | 45 failed |  4 failed as expected
+assertions: 969 | 859 passed | 89 failed | 21 failed as expected

--- a/projects/SelfTest/Baselines/console.swa4.approved.txt
+++ b/projects/SelfTest/Baselines/console.swa4.approved.txt
@@ -15,26 +15,42 @@ with message:
  yay

 -------------------------------------------------------------------------------
-#542
+#748 - captures with unexpected exceptions
+  outside assertions
 -------------------------------------------------------------------------------
-CompilationTests.cpp:<line number>
+ExceptionTests.cpp:<line number>
 ...............................................................................

-CompilationTests.cpp:<line number>:
-PASSED:
-  CHECK_THROWS_AS( throws_int(true), int )
+ExceptionTests.cpp:<line number>: FAILED:
+due to unexpected exception with messages:
+  answer := 42
+  expected exception

-CompilationTests.cpp:<line number>:
-PASSED:
-  CHECK_THROWS_AS( throws_int(true), int& )
+-------------------------------------------------------------------------------
+#748 - captures with unexpected exceptions
+  inside REQUIRE_NOTHROW
+-------------------------------------------------------------------------------
+ExceptionTests.cpp:<line number>
+...............................................................................

-CompilationTests.cpp:<line number>:
-PASSED:
-  CHECK_THROWS_AS( throws_int(true), const int )
+ExceptionTests.cpp:<line number>: FAILED:
+  REQUIRE_NOTHROW( thisThrows() )
+due to unexpected exception with messages:
+  answer := 42
+  expected exception

-CompilationTests.cpp:<line number>:
+-------------------------------------------------------------------------------
+#748 - captures with unexpected exceptions
+  inside REQUIRE_THROWS
+-------------------------------------------------------------------------------
+ExceptionTests.cpp:<line number>
+...............................................................................
+
+ExceptionTests.cpp:<line number>:
 PASSED:
-  CHECK_THROWS_AS( throws_int(true), const int& )
+  REQUIRE_THROWS( thisThrows() )
+with message:
+  answer := 42

 -------------------------------------------------------------------------------
 #809
@@ -48,6 +64,48 @@ PASSED:
 with expansion:
  42 == {?}

+-------------------------------------------------------------------------------
+#833
+-------------------------------------------------------------------------------
+CompilationTests.cpp:<line number>
+...............................................................................
+
+CompilationTests.cpp:<line number>:
+PASSED:
+  REQUIRE( a == t )
+with expansion:
+  3 == 3
+
+CompilationTests.cpp:<line number>:
+PASSED:
+  CHECK( a == t )
+with expansion:
+  3 == 3
+
+CompilationTests.cpp:<line number>:
+PASSED:
+  REQUIRE_THROWS( throws_int(true) )
+
+CompilationTests.cpp:<line number>:
+PASSED:
+  CHECK_THROWS_AS( throws_int(true), const int& )
+
+CompilationTests.cpp:<line number>:
+PASSED:
+  REQUIRE_NOTHROW( throws_int(false) )
+
+CompilationTests.cpp:<line number>:
+PASSED:
+  REQUIRE_THAT( "aaa", Catch::EndsWith("aaa") )
+with expansion:
+  "aaa" ends with: "aaa"
+
+CompilationTests.cpp:<line number>:
+PASSED:
+  REQUIRE( templated_tests<int>(3) )
+with expansion:
+  true
+
 -------------------------------------------------------------------------------
 #835 -- errno should not be touched by Catch
 -------------------------------------------------------------------------------
@@ -61,7 +119,7 @@ with expansion:

 MiscTests.cpp:<line number>:
 PASSED:
-  REQUIRE( (*__error()) == 1 )
+  REQUIRE( errno == 1 )
 with expansion:
  1 == 1

@@ -86,6 +144,6 @@ ConditionTests.cpp:<line number>: FAILED:
  CHECK_FALSE( true )

 ===============================================================================
-test cases:  5 | 3 passed | 1 failed | 1 failed as expected
-assertions: 12 | 7 passed | 4 failed | 1 failed as expected
+test cases:  6 |  3 passed | 1 failed | 2 failed as expected
+assertions: 18 | 11 passed | 4 failed | 3 failed as expected

--- a/projects/SelfTest/Baselines/junit.sw.approved.txt
+++ b/projects/SelfTest/Baselines/junit.sw.approved.txt
@@ -1,9 +1,24 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <testsuitesspanner>
-  <testsuite name="<exe-name>" errors="13" failures="77" tests="964" hostname="tbd" time="{duration}" timestamp="{iso8601-timestamp}">
+  <testsuite name="<exe-name>" errors="13" failures="77" tests="970" hostname="tbd" time="{duration}" timestamp="{iso8601-timestamp}">
    <testcase classname="global" name="# A test name that starts with a #" time="{duration}"/>
-    <testcase classname="global" name="#542" time="{duration}"/>
+    <testcase classname="#748 - captures with unexpected exceptions" name="outside assertions" time="{duration}">
+      <error type="TEST_CASE">
+expected exception
+answer := 42
+ExceptionTests.cpp:<line number>
+      </error>
+    </testcase>
+    <testcase classname="#748 - captures with unexpected exceptions" name="inside REQUIRE_NOTHROW" time="{duration}">
+      <error message="thisThrows()" type="REQUIRE_NOTHROW">
+expected exception
+answer := 42
+ExceptionTests.cpp:<line number>
+      </error>
+    </testcase>
+    <testcase classname="#748 - captures with unexpected exceptions" name="inside REQUIRE_THROWS" time="{duration}"/>
    <testcase classname="global" name="#809" time="{duration}"/>
+    <testcase classname="global" name="#833" time="{duration}"/>
    <testcase classname="global" name="#835 -- errno should not be touched by Catch" time="{duration}">
      <failure message="1 == 0" type="CHECK">
 MiscTests.cpp:<line number>
@@ -222,10 +237,13 @@ MessageTests.cpp:<line number>
    </testcase>
    <testcase classname="global" name="INFO gets logged on failure, even if captured before successful assertions" time="{duration}">
      <failure message="2 == 1" type="CHECK">
+this message may be logged later
 this message should be logged
 MessageTests.cpp:<line number>
      </failure>
      <failure message="2 == 0" type="CHECK">
+this message may be logged later
+this message should be logged
 and this, but later
 MessageTests.cpp:<line number>
      </failure>
--- a/projects/SelfTest/Baselines/xml.sw.approved.txt
+++ b/projects/SelfTest/Baselines/xml.sw.approved.txt
@@ -4,39 +4,47 @@
    <TestCase name="# A test name that starts with a #" filename="projects/<exe-name>/MiscTests.cpp" >
      <OverallResult success="true"/>
    </TestCase>
-    <TestCase name="#542" filename="projects/<exe-name>/CompilationTests.cpp" >
-      <Expression success="true" type="CHECK_THROWS_AS" filename="projects/<exe-name>/CompilationTests.cpp" >
-        <Original>
-          throws_int(true), int
-        </Original>
-        <Expanded>
-          throws_int(true), int
-        </Expanded>
-      </Expression>
-      <Expression success="true" type="CHECK_THROWS_AS" filename="projects/<exe-name>/CompilationTests.cpp" >
-        <Original>
-          throws_int(true), int&amp;
-        </Original>
-        <Expanded>
-          throws_int(true), int&amp;
-        </Expanded>
-      </Expression>
-      <Expression success="true" type="CHECK_THROWS_AS" filename="projects/<exe-name>/CompilationTests.cpp" >
-        <Original>
-          throws_int(true), const int
-        </Original>
-        <Expanded>
-          throws_int(true), const int
-        </Expanded>
-      </Expression>
-      <Expression success="true" type="CHECK_THROWS_AS" filename="projects/<exe-name>/CompilationTests.cpp" >
-        <Original>
-          throws_int(true), const int&amp;
-        </Original>
-        <Expanded>
-          throws_int(true), const int&amp;
-        </Expanded>
-      </Expression>
+    <TestCase name="#748 - captures with unexpected exceptions" tags="[!shouldfail][!throws]" filename="projects/<exe-name>/ExceptionTests.cpp" >
+      <Section name="outside assertions" filename="projects/<exe-name>/ExceptionTests.cpp" >
+        <Info>
+          answer := 42
+        </Info>
+        <Exception filename="projects/<exe-name>/ExceptionTests.cpp" >
+          expected exception
+        </Exception>
+        <OverallResults successes="0" failures="1" expectedFailures="0"/>
+      </Section>
+      <Section name="inside REQUIRE_NOTHROW" filename="projects/<exe-name>/ExceptionTests.cpp" >
+        <Info>
+          answer := 42
+        </Info>
+        <Expression success="false" type="REQUIRE_NOTHROW" filename="projects/<exe-name>/ExceptionTests.cpp" >
+          <Original>
+            thisThrows()
+          </Original>
+          <Expanded>
+            thisThrows()
+          </Expanded>
+          <Exception filename="projects/<exe-name>/ExceptionTests.cpp" >
+            expected exception
+          </Exception>
+        </Expression>
+        <OverallResults successes="0" failures="1" expectedFailures="0"/>
+      </Section>
+      <Section name="inside REQUIRE_THROWS" filename="projects/<exe-name>/ExceptionTests.cpp" >
+        <Info>
+          answer := 42
+        </Info>
+        <Expression success="true" type="REQUIRE_THROWS" filename="projects/<exe-name>/ExceptionTests.cpp" >
+          <Original>
+            thisThrows()
+          </Original>
+          <Expanded>
+            thisThrows()
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
      <OverallResult success="true"/>
    </TestCase>
    <TestCase name="#809" filename="projects/<exe-name>/CompilationTests.cpp" >
@@ -50,6 +58,65 @@
      </Expression>
      <OverallResult success="true"/>
    </TestCase>
+    <TestCase name="#833" filename="projects/<exe-name>/CompilationTests.cpp" >
+      <Expression success="true" type="REQUIRE" filename="projects/<exe-name>/CompilationTests.cpp" >
+        <Original>
+          a == t
+        </Original>
+        <Expanded>
+          3 == 3
+        </Expanded>
+      </Expression>
+      <Expression success="true" type="CHECK" filename="projects/<exe-name>/CompilationTests.cpp" >
+        <Original>
+          a == t
+        </Original>
+        <Expanded>
+          3 == 3
+        </Expanded>
+      </Expression>
+      <Expression success="true" type="REQUIRE_THROWS" filename="projects/<exe-name>/CompilationTests.cpp" >
+        <Original>
+          throws_int(true)
+        </Original>
+        <Expanded>
+          throws_int(true)
+        </Expanded>
+      </Expression>
+      <Expression success="true" type="CHECK_THROWS_AS" filename="projects/<exe-name>/CompilationTests.cpp" >
+        <Original>
+          throws_int(true), const int&amp;
+        </Original>
+        <Expanded>
+          throws_int(true), const int&amp;
+        </Expanded>
+      </Expression>
+      <Expression success="true" type="REQUIRE_NOTHROW" filename="projects/<exe-name>/CompilationTests.cpp" >
+        <Original>
+          throws_int(false)
+        </Original>
+        <Expanded>
+          throws_int(false)
+        </Expanded>
+      </Expression>
+      <Expression success="true" type="REQUIRE_THAT" filename="projects/<exe-name>/CompilationTests.cpp" >
+        <Original>
+          "aaa", Catch::EndsWith("aaa")
+        </Original>
+        <Expanded>
+          "aaa" ends with: "aaa"
+        </Expanded>
+      </Expression>
+      <Expression success="true" type="REQUIRE" filename="projects/<exe-name>/CompilationTests.cpp" >
+        <Original>
+          templated_tests&lt;int>(3)
+        </Original>
+        <Expanded>
+          true
+        </Expanded>
+      </Expression>
+      <OverallResult success="true"/>
+    </TestCase>
    <TestCase name="#835 -- errno should not be touched by Catch" tags="[!shouldfail]" filename="projects/<exe-name>/MiscTests.cpp" >
      <Expression success="false" type="CHECK" filename="projects/<exe-name>/MiscTests.cpp" >
        <Original>
@@ -61,7 +128,7 @@
      </Expression>
      <Expression success="true" type="REQUIRE" filename="projects/<exe-name>/MiscTests.cpp" >
        <Original>
-          (*__error()) == 1
+          errno == 1
        </Original>
        <Expanded>
          1 == 1
@@ -2677,6 +2744,9 @@
          2 == 2
        </Expanded>
      </Expression>
+      <Info>
+        this message may be logged later
+      </Info>
      <Info>
        this message should be logged
      </Info>
@@ -2688,6 +2758,12 @@
          2 == 1
        </Expanded>
      </Expression>
+      <Info>
+        this message may be logged later
+      </Info>
+      <Info>
+        this message should be logged
+      </Info>
      <Info>
        and this, but later
      </Info>
@@ -2699,6 +2775,15 @@
          2 == 0
        </Expanded>
      </Expression>
+      <Info>
+        this message may be logged later
+      </Info>
+      <Info>
+        this message should be logged
+      </Info>
+      <Info>
+        and this, but later
+      </Info>
      <Info>
        but not this
      </Info>
@@ -7308,7 +7393,8 @@ hello
          <Expanded>
            "error: tag alias, "[@zzz]" already registered.
 	First seen at file:2
-	Redefined at file:10" contains: "[@zzz]"
+	Redefined at file:10
+" contains: "[@zzz]"
          </Expanded>
        </Expression>
        <Expression success="true" type="CHECK_THAT" filename="projects/<exe-name>/TagAliasTests.cpp" >
@@ -7318,7 +7404,8 @@ hello
          <Expanded>
            "error: tag alias, "[@zzz]" already registered.
 	First seen at file:2
-	Redefined at file:10" contains: "file"
+	Redefined at file:10
+" contains: "file"
          </Expanded>
        </Expression>
        <Expression success="true" type="CHECK_THAT" filename="projects/<exe-name>/TagAliasTests.cpp" >
@@ -7328,7 +7415,8 @@ hello
          <Expanded>
            "error: tag alias, "[@zzz]" already registered.
 	First seen at file:2
-	Redefined at file:10" contains: "2"
+	Redefined at file:10
+" contains: "2"
          </Expanded>
        </Expression>
        <Expression success="true" type="CHECK_THAT" filename="projects/<exe-name>/TagAliasTests.cpp" >
@@ -7338,7 +7426,8 @@ hello
          <Expanded>
            "error: tag alias, "[@zzz]" already registered.
 	First seen at file:2
-	Redefined at file:10" contains: "10"
+	Redefined at file:10
+" contains: "10"
          </Expanded>
        </Expression>
        <OverallResults successes="4" failures="0" expectedFailures="0"/>
@@ -10043,7 +10132,7 @@ spanner      <OverallResult success="true"/>
      </Section>
      <OverallResult success="true"/>
    </TestCase>
-    <OverallResults successes="855" failures="90" expectedFailures="19"/>
+    <OverallResults successes="859" failures="90" expectedFailures="21"/>
  </Group>
-  <OverallResults successes="855" failures="89" expectedFailures="19"/>
+  <OverallResults successes="859" failures="89" expectedFailures="21"/>
 </Catch>
--- a/projects/SelfTest/CompilationTests.cpp
+++ b/projects/SelfTest/CompilationTests.cpp
@@ -23,20 +23,50 @@ TEST_CASE("#809") {
    REQUIRE(42 == f);
 }

-// ------------------------------------------------------------------
-// REQUIRE_THROWS_AS was changed to catch exceptions by const&
-// using type traits. This means that this should compile cleanly

-// Provides indirection to prevent unreachable-code warnings
+// ------------------------------------------------------------------
+// Changes to REQUIRE_THROWS_AS made it stop working in a template in
+// an unfixable way (as long as C++03 compatibility is being kept).
+// To prevent these from happening in the future, this needs to compile
+
 void throws_int(bool b) {
    if (b) {
        throw 1;
    }
 }

-TEST_CASE("#542") {
-    CHECK_THROWS_AS(throws_int(true), int);
-    CHECK_THROWS_AS(throws_int(true), int&);
-    CHECK_THROWS_AS(throws_int(true), const int);
+template <typename T>
+bool templated_tests(T t) {
+    int a = 3;
+    REQUIRE(a == t);
+    CHECK(a == t);
+    REQUIRE_THROWS(throws_int(true));
    CHECK_THROWS_AS(throws_int(true), const int&);
+    REQUIRE_NOTHROW(throws_int(false));
+    REQUIRE_THAT("aaa", Catch::EndsWith("aaa"));
+    return true;
 }
+
+TEST_CASE("#833") {
+    REQUIRE(templated_tests<int>(3));
+}
+
+// Test containing example where original stream insertable check breaks compilation
+#if defined (CATCH_CONFIG_CPP11_STREAM_INSERTABLE_CHECK)
+namespace {
+    struct A {};
+    std::ostream& operator<< (std::ostream &o, const A &) { return o << 0; }
+
+    struct B : private A {
+        bool operator== (int) const { return true; }
+    };
+
+    B f ();
+    std::ostream g ();
+}
+
+TEST_CASE( "#872" ) {
+    B x;
+    REQUIRE (x == 4);
+}
+#endif
--- a/projects/SelfTest/ExceptionTests.cpp
+++ b/projects/SelfTest/ExceptionTests.cpp
@@ -209,3 +209,18 @@ TEST_CASE( "Mismatching exception messages failing the test", "[.][failing][!thr
    REQUIRE_THROWS_WITH( thisThrows(), "should fail" );
    REQUIRE_THROWS_WITH( thisThrows(), "expected exception" );
 }
+
+TEST_CASE( "#748 - captures with unexpected exceptions", "[!shouldfail][!throws]" ) {
+    int answer = 42;
+    CAPTURE( answer );
+    // the message should be printed on the first two sections but not on the third
+    SECTION( "outside assertions" ) {
+        thisThrows();
+    }
+    SECTION( "inside REQUIRE_NOTHROW" ) {
+        REQUIRE_NOTHROW( thisThrows() );
+    }
+    SECTION( "inside REQUIRE_THROWS" ) {
+        REQUIRE_THROWS( thisThrows() );
+    }
+}
--- a/scripts/approvalTests.py
+++ b/scripts/approvalTests.py
@@ -36,6 +36,13 @@ exeNameParser = re.compile(r'''
 # This is a hack until something more reasonable is figured out
 specialCaseParser = re.compile(r'file\((\d+)\)')

+# errno macro expands into various names depending on platform, so we need to fix them up as well
+errnoParser = re.compile(r'''
+    \(\*__errno_location\ \(\)\)
+    |
+    \(\*__error\(\)\)
+''', re.VERBOSE)
+
 if len(sys.argv) == 2:
    cmdPath = sys.argv[1]
 else:
@@ -45,9 +52,9 @@ overallResult = 0

 def diffFiles(fileA, fileB):
    with open(fileA, 'r') as file:
-        aLines = file.readlines()
+        aLines = [line.rstrip() for line in file.readlines()]
    with open(fileB, 'r') as file:
-        bLines = file.readlines()
+        bLines = [line.rstrip() for line in file.readlines()]

    shortenedFilenameA = fileA.rsplit(os.sep, 1)[-1]
    shortenedFilenameB = fileB.rsplit(os.sep, 1)[-1]
@@ -90,6 +97,7 @@ def filterLine(line):
    line = durationsParser.sub(' time="{duration}"', line)
    line = timestampsParser.sub(' timestamp="{iso8601-timestamp}"', line)
    line = specialCaseParser.sub('file:\g<1>', line)
+    line = errnoParser.sub('errno', line)
    return line


@@ -119,7 +127,7 @@ def approve(baseName, args):
    if os.path.exists(baselinesPath):
        diffResult = diffFiles(baselinesPath, filteredResultsPath)
        if diffResult:
-            print(''.join(diffResult))
+            print('\n'.join(diffResult))
            print("  \n****************************\n  \033[91mResults differed")
            if len(diffResult) > overallResult:
                overallResult = len(diffResult)
--- a/scripts/developBuild.py
+++ b/scripts/developBuild.py
--- a/scripts/releaseCommon.py
+++ b/scripts/releaseCommon.py
@@ -7,7 +7,7 @@ import string

 from scriptCommon import catchPath

-versionParser = re.compile( r'(\s*Version\slibraryVersion)\s*\(\s*(.*)\s*,\s*(.*)\s*,\s*(.*)\s*,\s*\"(.*)\"\s*,\s*(.*)\s*\).*' )
+versionParser = re.compile( r'(\s*static\sVersion\sversion)\s*\(\s*(.*)\s*,\s*(.*)\s*,\s*(.*)\s*,\s*\"(.*)\"\s*,\s*(.*)\s*\).*' )
 rootPath = os.path.join( catchPath, 'include/' )
 versionPath = os.path.join( rootPath, "internal/catch_version.hpp" )
 readmePath = os.path.join( catchPath, "README.md" )
--- a/scripts/releaseNotes.py
+++ b/scripts/releaseNotes.py
--- a/scripts/updateVcpkgPackage.py
+++ b/scripts/updateVcpkgPackage.py
@@ -0,0 +1,114 @@
+#!/usr/bin/env python
+
+import io, os, re, sys, subprocess
+import hashlib
+
+from scriptCommon import catchPath
+from releaseCommon import Version
+
+print(catchPath)
+
+default_path = '../vcpkg/ports/catch/'
+
+def adjusted_path(path):
+    return os.path.join(catchPath, path)
+
+def get_hash(path):
+    BUFF_SIZE = 65536
+    sha512 = hashlib.sha512()
+    # The newlines should be normalized into \n, which is what we want
+    # If reused use 'rb' with a file written with io.open(newline='\n')
+    with open(path, 'r') as f:
+        while True:
+            data = f.read(BUFF_SIZE)
+            if not data:
+                break
+            if sys.version_info[0] < 3:
+                sha512.update(data)
+            else:
+                sha512.update(data.encode('utf-8'))
+    return sha512.hexdigest()
+
+def update_control(path):
+    v = Version()
+    ver_string = v.getVersionString()
+
+    # Update control
+    lines = []
+    control_path = os.path.join(path, 'CONTROL')
+    with open(control_path, 'r') as f:
+        for line in f:
+            lines.append(line)
+    with open(control_path, 'w') as f:
+        for line in lines:
+            if 'Version: ' in line:
+                line = 'Version: {}\n'.format(v.getVersionString())
+            f.write(line)
+
+def update_portfile(path, header_hash, licence_hash):
+    print('Updating portfile')
+    v = Version()
+    ver_string = v.getVersionString()
+
+    # Update portfile
+    lines = []
+    portfile_path = os.path.join(path, 'portfile.cmake')
+    with open(portfile_path, 'r') as f:
+        for line in f:
+            lines.append(line)
+    with open(portfile_path, 'w') as f:
+        # Two things we need to change/update
+        # 1) Link and hash of releaseCommon
+        # 2) Link and hash of licence
+        # We could assume licence never changes, but where is the fun in that?
+        first_hash = True
+        for line in lines:
+            # Check what we are updating
+            if 'vcpkg_download_distfile' in line:
+                kind = line.split('(')[-1].strip()
+                print(kind)
+
+            # Deal with URLS
+            if 'URLS' in line and kind == 'HEADER':
+                line = '    URLS "https://github.com/philsquared/Catch/releases/download/v{}/catch.hpp"\n'.format(v.getVersionString())
+            if 'URLS' in line and kind == 'LICENSE':
+                line = '    URLS "https://raw.githubusercontent.com/philsquared/Catch/v{}/LICENSE.txt"\n'.format(v.getVersionString())
+
+            # Deal with hashes
+            if 'SHA512' in line and kind == 'HEADER':
+                line = '    SHA512 {}\n'.format(header_hash)
+            if 'SHA512' in line and kind == 'LICENSE':
+                line = '    SHA512 {}\n'.format(licence_hash)
+            f.write(line)
+
+
+def git_push(path_to_repo):
+    v = Version()
+    ver_string = v.getVersionString()
+
+    # Move to the repo dir
+    old_path = os.getcwd()
+    os.chdir(path_to_repo)
+
+    # Work with git
+    # Make sure we branch off master
+    subprocess.call('git checkout master', shell=True)
+    
+    # Update repo to current master, so we don't work off old version of the portsfile 
+    subprocess.call('git pull Microsoft master', shell=True)
+
+    # Create a new branch for the update
+    subprocess.call('git checkout -b catch-{}'.format(ver_string), shell=True)
+    # Add changed files (should be only our files)
+    subprocess.call('git add -u .', shell=True)
+    # Create a commit with these changes
+    subprocess.call('git commit -m "Update Catch to {}"'.format(ver_string), shell=True)
+    # Don't push, so author can review
+    print('Changes were commited to the vcpkg fork. Please check, push and open PR.')
+
+header_hash = get_hash(adjusted_path('single_include/catch.hpp'))
+licence_hash = get_hash(adjusted_path('LICENSE.txt'))
+update_control(adjusted_path(default_path))
+update_portfile(adjusted_path(default_path), header_hash, licence_hash)
+
+git_push(adjusted_path('../vcpkg'))
--- a/single_include/catch.hpp
+++ b/single_include/catch.hpp
Author	SHA1	Message	Date
Martin Hořeňovský	3dcc923351	v1.9.4	2017-05-16 13:59:29 +02:00
Martin Hořeňovský	589c40077b	Typo fix Somehow I made that in `5ffc8a84cd` without noticing	2017-05-16 13:51:17 +02:00
Antonio Di Monaco	b8443e67da	Added Win32 UNICODE wmain support (#903 ) * Added wmain support * Added appveyor.yml wmain configuration * Added wmain configuration flag to CMake	2017-05-11 13:00:03 +02:00
Martin Hořeňovský	5604ec7266	Updated toString documentation It will need another update when Catch 2 goes live. Closes #741	2017-05-03 21:09:27 +02:00
Benjamin R. Jack	6f012f2d1d	Added warning if source file cannot be found If source files are defined using relative paths, CMake will compile the tests, but this script will (sometimes) fail to find and parse the tests from the source files. I have added an explicit warning when ParseAndAddCatchTests fails to find a source file.	2017-05-01 19:55:17 +02:00
Martin Hořeňovský	98e61c31df	Approval tests now see different line endings as ok This is mostly to deal with WSL, where git will checkout file with CRLF, but code that uses formatted output will be writing LFs.	2017-04-29 18:06:36 +02:00
Martin Hořeňovský	e641485132	Updated approval tests	2017-04-29 17:54:10 +02:00
Martin Hořeňovský	a3ceb8f007	Approval tests now can deal with different expansions of errno	2017-04-29 17:52:12 +02:00
Martin Hořeňovský	b819432271	Don't clear out all messages upon printing an assertion. Previously, this would not print out any messages for the last CHECK ```cpp TEST_CASE("Foo") { INFO("Test case start"); for (int i = 0; i < 2; ++i) { INFO("The number is " << i); CHECK(i == 0); } CHECK(false); } ``` now it does.	2017-04-29 17:50:03 +02:00
Martin Hořeňovský	9ceae8f51f	CMake binaries are now conditionally enabled Defining NO_SELFTEST=1 when cmake configuration is being done now turns off SelfTest and Benchmark executables. This is for projects that consume Catch using ExternalProject_Add and don't want to build our selftest binaries for their unit test suite. Closes #897	2017-04-28 20:27:10 +02:00
Martin Hořeňovský	5ffc8a84cd	Fix order of arguments in CATCH_FAIL and nonvariadic INTERNAL_CATCH_MSG Fixes #896	2017-04-28 18:30:04 +02:00
JayAndCatchFire	6e0fa4be68	Update opensource-users.md Fixed broken link to LICENSE	2017-04-27 10:29:58 +02:00
Phil Nash	a0ada2e935	v1.9.3	2017-04-25 14:23:06 +00:00
Phil Nash	e4694f58da	Removed errant uses of uint64_t fixes #894	2017-04-25 14:15:59 +00:00
Martin Hořeňovský	fc7f0a02b8	v1.9.2	2017-04-25 11:08:02 +02:00
Phil Nash	211b330346	Don’t unconditionally #include <stdint.h> (as earlier MSVC don’t have it)	2017-04-25 08:43:14 +01:00
Phil Nash	d36fe214a6	Further tweaked alignment hack for Option	2017-04-25 08:38:25 +01:00
Martin Hořeňovský	a34c053f0a	All of Approx's member functions now accept strong typedefs Previously `Approx::operator()`, `Approx::epsilon`, `Approx::margin` and `Approx::scale` didn't. Closes #888	2017-04-24 22:01:45 +02:00
Martin Hořeňovský	4cdb203ec3	Improve documentation about using Catch with CMake Also added a note about the `contrib/ParseAndAddCatchTests.cmake` script. Closes #882	2017-04-24 16:27:43 +02:00
Ernst Maurer	8014bf1124	cmake script to generate ctest definitions from catch tests: fix for test case body bracket	2017-04-24 13:33:04 +02:00
Alexander Batischev	49d87cf182	Add Newsbeuter to OSS users list (#891 )	2017-04-22 16:02:55 +02:00
Phil Nash	eedcc82d31	Tweaked storage alignment "workaround" a bit more in Option.	2017-04-21 07:19:39 +01:00
Martin Hořeňovský	8e8259091c	Fix .travis.yml syntax	2017-04-20 22:54:17 +02:00
Martin Hořeňovský	7869e5b007	Enable C++11 and C++14 on OSX on Travis	2017-04-20 22:52:41 +02:00
Martin Hořeňovský	a49af4648c	Minor .travis.yml cleanup Still could use someone more experienced to clean it up properly...	2017-04-20 22:50:07 +02:00
Martin Hořeňovský	417b2bcf5c	Enable C++14 on Linux on Travis	2017-04-20 22:47:05 +02:00
Martin Hořeňovský	8f0feaa6d2	Enable /std:c++latest (C++17) for AppVeyor VS 2017	2017-04-20 21:32:50 +02:00
Martin Hořeňovský	b95163bd3a	Don't enable POSIX signals under QNX Fixes #889	2017-04-20 21:02:25 +02:00
Phil Nash	2809be87cc	“fixed” alignment in Option	2017-04-20 14:39:07 +01:00
Martin Hořeňovský	ac369b7b83	Add script that helps with updating the Vcpkg package. Kind of a hackjob, that assumes vcpkg is already checked out and is next to the Catch's directory.	2017-04-11 17:25:04 +02:00
Ernst Maurer	1aa3e4abfa	Add CMake script to generate ctest definitions from Catch tests (#879 ) Added cmake script to parse the source files containing Catch's test and generate ctest definitions. It generates one ctest test per `TEST_CASE` and labels them, using the `TEST_CASE`'s tags. Closes #719.	2017-04-11 16:51:02 +02:00
Phil Nash	e5c5a636a9	junit reporter does not count exceptions as failures if ok-to-fail	2017-04-11 15:47:42 +01:00
Phil Nash	2bf30e9e5a	Use (locally defined) UInt64 instead of uint64_t - typedefs long long for MSVC - typedefs uint64_t otherwise Should probably do finer grained compiler checking - but this should at least be better than what was there before	2017-04-11 15:06:25 +01:00
Phil Nash	b591cb9a03	Added note about thread safety in assertions - closes #875	2017-04-11 14:25:19 +01:00
Phil Nash	714d01c07c	approved tests that were correct the first time (previous approvals were erroneous)	2017-04-09 20:40:11 +01:00
Martin Hořeňovský	c6990cdf91	v1.9.1 release	2017-04-09 21:25:20 +02:00
Martin Hořeňovský	da8786b8fd	Unexpected exception are no longer ignored by default What an embarassing bug, I'll have to look into why it wasn't caught by any of Catch's self-tests. Fixes #885 and closes #887 (duplicate)	2017-04-09 21:20:58 +02:00
Phil Nash	5577322062	Added Nonius to open-sources users	2017-04-08 22:47:13 +01:00
Martin Hořeňovský	1b03c5ab6a	v1.9.0 release	2017-04-07 22:56:36 +02:00
Phil Nash	7dd3c19027	Added NASA to commercial users list	2017-04-07 19:12:13 +01:00
Phil Nash	29d26d3179	Commented out unused argument	2017-04-07 11:36:54 +01:00
Phil Nash	ca764ec8d9	TeamCity reporter “ignores” failures in tests marked “ok to fail” - also don’t report hidden/ not-selected tests	2017-04-07 11:15:37 +01:00
Phil Nash	250f0ee7fb	Added approvals for “failed as expected” tests	2017-04-07 09:33:19 +01:00
Martin Hořeňovský	09e4830199	Added VS2017 to AppVeyor matrix	2017-04-06 11:01:49 +02:00
Martin Hořeňovský	8f85d08e9f	Give up on _Pragma for gcc, force disable Wparentheses in all TUs	2017-04-05 21:37:27 +02:00
Martin Hořeňovský	3ae076ce8d	Updated REQUIRE* documentation under FAST_COMPILE	2017-04-05 10:26:19 +02:00
Sergey Semushin	94425ad59b	Add opt-in c++11 stream insertable check. (#877 ) * Add opt-in c++11 stream insertable check. To opt-in, define CATCH_CONFIG_CPP11_STREAM_INSERTABLE_CHECK. Opt-in fixes #872 and should fix #757 as well.	2017-04-05 09:53:10 +02:00
Martin Hořeňovský	0354d50278	Added templated constructor to C++11 Approx When using C++11, comparison operators are already templated to take anything that can be explicitly converted to double, but constructor took only doubles. This lead to warnings when an `Approx` was constructed from floats, which was problematic for some users. Since just adding float constructor would be a large breaking change, as suddenly `Approx( 1 )` would become ambiguous, I added a templated constructor that will take anything that is explicitly convertible to double. This has the added benefit of allowing constructing `Approx` instances from instances of strong typedefs, ie allowing `calculated_temp == Approx( known_temp)`. Closes #873	2017-04-04 15:19:15 +02:00
Martin Hořeňovský	cdd83c2e15	Fmt and tag fixup for #876 Github wouldn't let me push to the PR, probably because it was made from fork of a fork...	2017-04-04 11:31:13 +02:00
dvirtz	9a07dde16d	print messages when unexpected exceptions are thrown	2017-04-04 11:27:19 +02:00
Martin Hořeňovský	6e091d3991	Reset the UnexpectedException report state	2017-04-03 11:48:50 +02:00
Martin Hořeňovský	95d85fb186	Fixed up CATCH_CONFIG_FAST_COMPILE for REQUIREs Unexpected exceptions no longer cause abort and there should be no more potential for false negatives. The trade-off now is that exceptions are no longer translated.	2017-04-03 11:36:55 +02:00
Martin Hořeňovský	3a3f152979	Updated documentation of CATCH_CONFIG_FAST_COMPILE	2017-03-29 21:13:51 +02:00
Martin Hořeňovský	4fe2432e05	Rework of REQUIRE* changes in CATCH_CONFIG_FAST_COMPILE `ResultBuilder`s destructor now checks for exceptions, preventing false negatives. The speedup should remain the same give or take a tiny bit.	2017-03-29 21:12:06 +02:00
Martin Hořeňovský	c3a41e26a7	Suppress -Wexit-time-destructors in Catch code This is another warning that follows test macros, making it painful to suppress without leaking outside. Luckily clang's `_Pragma` implementation works. Should fix #308	2017-03-29 20:30:59 +02:00
Phil Nash	4838039b65	Merge pull request #869 from mloskot/patch-1 Add nanodbc library to Catch users	2017-03-27 07:43:27 +01:00
Mateusz Łoskot	2a221b8fcd	Add nanodbc library to Catch users	2017-03-26 21:26:08 +02:00
Rian Quinn	79ce6930a2	remove redundant "/" This "/" is not needed as CMake adds this automatically	2017-03-23 21:18:07 +01:00
Martin Hořeňovský	d762a7ca6c	Expanded documentation about THROWS_AS assertions	2017-03-23 21:16:52 +01:00
Martin Hořeňovský	f23b6b8b85	Don't sanitize exception type in REQUIRE_THROWS_AS Effectively a revert of previous commit, fixing #542, where this was added to stop linters complaining about `REQUIRE_THROWS_AS` used like `REQUIRE_THROWS_AS(expr, std::exception);`, which would be slicing the caught exception. Now it is user's responsibility to pass us proper exception type. Closes #833 which wanted to add `typename`, so that the construct works in a template, but that would not work with MSVC and older GCC's, as having `typename` outside of a template is allowed only from C++11 onward.	2017-03-23 21:11:21 +01:00
Martin Hořeňovský	4597b43912	Throw instead of calling exit in RegistrarForTagAliases constructor Caries a problem vis-a-vis Windows, just like previous commit, but that can be fixed later on. Closes #866	2017-03-22 18:40:07 +01:00
Martin Hořeňovský	f64d914bff	Throw instead of calling exit in enforceNotReservedTag Closes #865	2017-03-22 17:53:22 +01:00
Martin Hořeňovský	d07999ddff	Version struct now uses char* for holding branch name Since the info is constant, and the only use is to write it out during runtime, there is no need for `std::string`.	2017-03-22 17:45:36 +01:00
Kevin Ushey	e04dc5105b	use inline 'libraryVersion()' function (closes #858 )	2017-03-22 15:51:02 +01:00
Phil Nash	cffb031ce1	Added polymorphic_value to OSS users	2017-03-22 10:33:52 +00:00
Phil Nash	f3ec843ba6	Changed all internal forwarding macro usages to put macro name as first argument (and ‘expression’, if any, last) This is a first step towards allowing expression arguments to become variadic	2017-03-21 13:23:35 +00:00
Martin Hořeňovský	55ed17f97b	Removed stray define	2017-03-20 10:53:32 +01:00
Martin Hořeňovský	6a502cc2f5	Renamed licence file, license should now be detected by github	2017-03-20 08:59:25 +01:00
Martin Hořeňovský	6a009fabcb	Documented REQUIRE under CATCH_CONFIG_FAST_COMPILE	2017-03-17 17:02:39 +01:00
Martin Hořeňovský	7a8a0205b4	CATCH_CONFIG_FAST_COMPILE now disables trys in REQUIRE* This seems to give about 15% speedup when compiling tests using GCC. The tradeoff is that under certain circumstances, there is a chance for false negative result, when the expression under test throws exception and the test code catches it before it gets to the test runner. Example: ``` cpp TEST_CASE("False negative") { try { REQUIRE(throws() == ""); } catch (...) {} } ``` This test case will succeed, reporting no assertions checked, instead of failing as it would with `CATCH_CONFIG_FAST_COMPILE` disabled. However, just removing the try-catch block inside client's code will fix this, so it is worthwhile. This change does not apply to CHECK* macros, because these are currently specified as continuing on exception and thus need the local try-catch to work as intended.	2017-03-17 13:21:40 +01:00
Mickey Rose	4dc06bdb70	Use bulk vector::insert rather than back_inserter	2017-03-15 15:19:38 +00:00
Phil Nash	08b597b3e2	Merge pull request #856 from lightmare/script-exec-perm Set execute permission on runnable python scripts	2017-03-15 11:44:40 +00:00
Mickey Rose	46d166406d	Set execute permission on runnable python scripts	2017-03-15 12:24:18 +01:00
Phil Nash	4ec8d53e91	Tag Alias registry is part of registry hub instead of it’s own singleton - should now be cleaned up properly	2017-03-15 09:45:37 +00:00
Phil Nash	e7984e3711	Reorganised the readme/ ref docs TOC and added link to reporters docs	2017-03-15 09:08:20 +00:00
Phil Nash	90d89377ea	Added docs on reporters	2017-03-15 09:07:23 +00:00
Phil Nash	0692317bc5	Added Obj-C bindings fix to release notes	2017-03-15 09:04:09 +00:00
Martin Hořeňovský	95fc8d62a2	Fixed up old documentation links in release notes	2017-03-13 21:31:26 +01:00