v1.9.7

Fix issue with fatal errors and non-failing assertions
Fixes #990
2025-09-15 01:45:39 +02:00 · 2017-08-11 00:01:20 +02:00 · 2017-08-10 21:44:54 +02:00 · 2017-08-10 21:38:07 +02:00 · 2017-08-10 16:45:38 +02:00 · 2017-08-10 16:43:17 +02:00
82 changed files with 1354 additions and 365 deletions
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -2,6 +2,9 @@
 Please do not submit pull requests changing the `version.hpp`
 or the single-include `catch.hpp` file, these are changed
 only when a new release is made.
+
+Before submitting a PR you should probably read the contributor documentation
+at docs/contributing.md. It will tell you how to properly test your changes.
 -->


--- a/.travis.yml
+++ b/.travis.yml
@@ -192,15 +192,15 @@ matrix:
      env: COMPILER='g++-6' BUILD_TYPE='Debug' CPP14=1

    # 4b/ Linux C++14 Clang builds
-    - os: linux
-      compiler: clang
-      addons: *clang38
-      env: COMPILER='clang++-3.8' BUILD_TYPE='Release' CPP14=1
-
-    - os: linux
-      compiler: clang
-      addons: *clang38
-      env: COMPILER='clang++-3.8' BUILD_TYPE='Debug' CPP14=1
+#    - os: linux
+#      compiler: 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
--- 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}")
@@ -55,6 +59,7 @@ set(TEST_SOURCES
        ${SELF_TEST_DIR}/CmdLineTests.cpp
        ${SELF_TEST_DIR}/CompilationTests.cpp
        ${SELF_TEST_DIR}/ConditionTests.cpp
+        ${SELF_TEST_DIR}/DecompositionTests.cpp
        ${SELF_TEST_DIR}/EnumToString.cpp
        ${SELF_TEST_DIR}/ExceptionTests.cpp
        ${SELF_TEST_DIR}/GeneratorTests.cpp
@@ -245,28 +250,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")
+
+endif() # !NO_SELFTEST

-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")
--- a/README.md
+++ b/README.md
@@ -3,8 +3,9 @@
 [![Github Releases](https://img.shields.io/github/release/philsquared/catch.svg)](https://github.com/philsquared/catch/releases)
 [![Build Status](https://travis-ci.org/philsquared/Catch.svg?branch=master)](https://travis-ci.org/philsquared/Catch)
 [![Build status](https://ci.appveyor.com/api/projects/status/hrtk60hv6tw6fght/branch/master?svg=true)](https://ci.appveyor.com/project/philsquared/catch/branch/master)
+[![Try online](https://img.shields.io/badge/try-online-blue.svg)](https://wandbox.org/permlink/IJ0n8142H2DROPIm)

-<a href="https://github.com/philsquared/Catch/releases/download/v1.9.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.7/catch.hpp">The latest, single header, version can be downloaded directly using this link</a>

 ## What's the Catch?

@@ -21,3 +22,7 @@ This documentation comprises these three parts:
 * Issues and bugs can be raised on the [Issue tracker on GitHub](https://github.com/philsquared/Catch/issues)
 * For discussion or questions please use [the dedicated Google Groups forum](https://groups.google.com/forum/?fromgroups#!forum/catch-forum)
 * See [who else is using Catch](docs/opensource-users.md)
+
+## Help us out
+We're currently running [a survey](https://www.surveymonkey.co.uk/r/TLLYQJW) to help us shape the future of Catch.
+Please take a few moments to fill it out (there's only ten questions).
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -9,7 +9,13 @@ os:
 environment:
    matrix:
        - additional_flags: "/permissive- /std:c++latest"
+          wmain: 0
+
        - additional_flags: ""
+          wmain: 0
+
+        - additional_flags: "/D_UNICODE /DUNICODE"
+          wmain: 1

 matrix:
    exclude:
@@ -42,7 +48,7 @@ configuration:
 #Cmake will autodetect the compiler, but we set the arch
 before_build:
  - set CXXFLAGS=%additional_flags%
-  - cmake -H. -BBuild -A%PLATFORM%
+  - cmake -H. -BBuild -A%PLATFORM% -DUSE_WMAIN=%wmain%

 # build with MSBuild
 build:
--- a/conanfile.py
+++ b/conanfile.py
@@ -0,0 +1,16 @@
+#!/usr/bin/env python
+from conans import ConanFile
+
+
+class CatchConan(ConanFile):
+    name = "Catch"
+    version = "1.9.7"
+    description = "A modern, C++-native, header-only, framework for unit-tests, TDD and BDD"
+    author = "philsquared"
+    generators = "cmake"
+    exports_sources = "single_include/*"
+    url = "https://github.com/philsquared/Catch"
+    license = "Boost Software License - Version 1.0. http://www.boost.org/LICENSE_1_0.txt"
+
+    def package(self):
+        self.copy(pattern="catch.hpp", src="single_include", dst="include")
--- a/contrib/ParseAndAddCatchTests.cmake
+++ b/contrib/ParseAndAddCatchTests.cmake
@@ -25,13 +25,36 @@
 #                                                                                                  #
 #        include(ParseAndAddCatchTests)                                                            #
 #        ParseAndAddCatchTests(${PROJECT_NAME})                                                    #
+#                                                                                                  #
+# The following variables affect the behavior of the script:                                       #
+#                                                                                                  #
+#    PARSE_CATCH_TESTS_VERBOSE (Default OFF)                                                       #
+#    -- enables debug messages                                                                     #
+#    PARSE_CATCH_TESTS_NO_HIDDEN_TESTS (Default OFF)                                               #
+#    -- excludes tests marked with [!hide], [.] or [.foo] tags                                     #
+#    PARSE_CATCH_TESTS_ADD_FIXTURE_IN_TEST_NAME (Default ON)                                       #
+#    -- adds fixture class name to the test name                                                   #
+#    PARSE_CATCH_TESTS_ADD_TARGET_IN_TEST_NAME (Default ON)                                        #
+#    -- adds cmake target name to the test name                                                    #
+#                                                                                                  #
 #==================================================================================================#

 cmake_minimum_required(VERSION 2.8.8)

+option(PARSE_CATCH_TESTS_VERBOSE "Print Catch to CTest parser debug messages" OFF)
+option(PARSE_CATCH_TESTS_NO_HIDDEN_TESTS "Exclude tests with [!hide], [.] or [.foo] tags" OFF)
+option(PARSE_CATCH_TESTS_ADD_FIXTURE_IN_TEST_NAME "Add fixture class name to the test name" ON)
+option(PARSE_CATCH_TESTS_ADD_TARGET_IN_TEST_NAME "Add target name to the test name" ON)
+
+function(PrintDebugMessage)
+    if(PARSE_CATCH_TESTS_VERBOSE)
+            message(STATUS "ParseAndAddCatchTests: ${ARGV}")
+    endif()
+endfunction()
+
 # This removes the contents between
-#  - block comments (i.e. /* ... */) 
-#  - full line comments (i.e. // ... ) 
+#  - block comments (i.e. /* ... */)
+#  - full line comments (i.e. // ... )
 # contents have been read into '${CppCode}'.
 # !keep partial line comments
 function(RemoveComments CppCode)
@@ -47,9 +70,13 @@ endfunction()

 # Worker function
 function(ParseFile SourceFile TestTarget)
+    # According to CMake docs EXISTS behavior is well-defined only for full paths.
+    get_filename_component(SourceFile ${SourceFile} ABSOLUTE)
    if(NOT EXISTS ${SourceFile})
+        message(WARNING "Cannot find source file: ${SourceFile}")
        return()
    endif()
+    PrintDebugMessage("parsing ${SourceFile}")
    file(STRINGS ${SourceFile} Contents NEWLINE_CONSUME)

    # Remove block and fullline comments
@@ -85,30 +112,62 @@ function(ParseFile SourceFile TestTarget)
        if("${TestType}" STREQUAL "SCENARIO")
            set(Name "Scenario: ${Name}")
        endif()
-        if(TestFixture)
+        if(PARSE_CATCH_TESTS_ADD_FIXTURE_IN_TEST_NAME AND TestFixture)
            set(CTestName "${TestFixture}:${Name}")
        else()
            set(CTestName "${Name}")
        endif()
+        if(PARSE_CATCH_TESTS_ADD_TARGET_IN_TEST_NAME)
+            set(CTestName "${TestTarget}:${CTestName}")
+        endif()
+        # add target to labels to enable running all tests added from this target
+        set(Labels ${TestTarget})
        if(TestStringsLength EQUAL 2)
            list(GET TestStrings 1 Tags)
            string(TOLOWER "${Tags}" Tags)
+            # remove target from labels if the test is hidden
+            if("${Tags}" MATCHES ".*\\[!?(hide|\\.)\\].*")
+                list(REMOVE_ITEM Labels ${TestTarget})
+            endif()
            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}")
+        list(APPEND Labels ${Tags})
+
+        list(FIND Labels "!hide" IndexOfHideLabel)
+        set(HiddenTagFound OFF)
+        foreach(label ${Labels})
+            string(REGEX MATCH "^!hide|^\\." result ${label})
+            if(result)
+                set(HiddenTagFound ON)
+                break()
+            endif(result)
+        endforeach(label)
+        if(PARSE_CATCH_TESTS_NO_HIDDEN_TESTS AND ${HiddenTagFound})
+            PrintDebugMessage("Skipping test \"${CTestName}\" as it has [!hide], [.] or [.foo] label")
+        else()
+            PrintDebugMessage("Adding test \"${CTestName}\"")
+            if(Labels)
+                PrintDebugMessage("Setting labels to ${Labels}")
+            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 "${Labels}")
+        endif()

    endforeach()
 endfunction()

 # entry point
 function(ParseAndAddCatchTests TestTarget)
+    PrintDebugMessage("Started parsing ${TestTarget}")
    get_target_property(SourceFiles ${TestTarget} SOURCES)
+    PrintDebugMessage("Found the following sources: ${SourceFiles}")
    foreach(SourceFile ${SourceFiles})
        ParseFile(${SourceFile} ${TestTarget})
    endforeach()
-endfunction()
+    PrintDebugMessage("Finished parsing ${TestTarget}")
+endfunction()
--- a/docs/Readme.md
+++ b/docs/Readme.md
@@ -17,7 +17,7 @@ Fine tuning:

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

 FAQ:
 * [Why are my tests slow to compile?](slow-compiles.md)
--- a/docs/build-systems.md
+++ b/docs/build-systems.md
@@ -1,4 +1,4 @@
-# Integration with build systems
+# CI and build system integration

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

@@ -134,6 +134,10 @@ TEST_CASE("Test3", "[a][b][c]") {
 ```
 would be registered as 3 tests, `Test1`, `Test2` and `Test3`, and ctest 4 labels would be created, `a`, `b`, `c` and `unit`.

+### CodeCoverage module (GCOV, LCOV...)
+
+If you are using GCOV tool to get testing coverage of your code, and are not sure how to integrate it with CMake and Catch, there should be an external example over at https://github.com/fkromer/catch_cmake_coverage
+
 ---

-[Home](Readme.md)
+[Home](Readme.md)
--- a/docs/commercial-users.md
+++ b/docs/commercial-users.md
@@ -13,4 +13,4 @@ fact then please let us know - either directly, via a PR or
 
 - Bloomberg
 - NASA
- 
+ - [Inscopix Inc.](https://www.inscopix.com/)
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -43,12 +43,19 @@ By default a console width of 80 is assumed but this can be controlled by defini

 	CATCH_CONFIG_NOSTDOUT

-Catch does not use ```std::cout``` and ```std::cerr``` directly but gets them from ```Catch::cout()``` and ```Catch::cerr()``` respectively. If the above identifier is defined these functions are left unimplemented and you must implement them yourself. Their signatures are:
+Catch does not use ```std::cout```, ```std::cerr``` and ```std::clog``` directly but gets them from ```Catch::cout()```, ```Catch::cerr()``` and ```Catch::clog``` respectively. If the above identifier is defined these functions are left unimplemented and you must implement them yourself. Their signatures are:

    std::ostream& cout();
    std::ostream& cerr();
+    std::ostream& clog();

-This can be useful on certain platforms that do not provide ```std::cout``` and ```std::cerr```, such as certain embedded systems.
+This can be useful on certain platforms that do not provide the standard iostreams, such as certain embedded systems.
+
+# Default reporter
+
+    CATCH_CONFIG_DEFAULT_REPORTER <reporter>
+
+The default reporter (reporter used when no reporters are explicitly specified) can be overriden during compilation time by using the above macro. Note that desired value of the macro is a C string and quotes have to be escaped during compilation: `clang++ test.cpp -DCATCH_CONFIG_DEFAULT_REPORTER=\"xml\"`.

 # C++ conformance toggles

--- a/docs/contributing.md
+++ b/docs/contributing.md
@@ -18,8 +18,8 @@ Ongoing development is currently on _master_. At some point an integration branc
 _Users_ of Catch primarily use the single header version. _Maintainers_ should work with the full source (which is still, 
 primarily, in headers). This can be found in the `include` folder. There are a set of test files, currently under
 `projects/SelfTest`. The test app can be built via CMake from the `CMakeLists.txt` file in the root, or you can generate
-project files for Visual Studio, XCode, and others (instructions in the `projects` folder). If you have access to CLion
-that can work with the CMake file directly.
+project files for Visual Studio, XCode, and others (instructions in the `projects` folder). If you have access to CLion,
+it can work with the CMake file directly.

 As well as the runtime test files you'll also see a `SurrogateCpps` directory under `projects/SelfTest`.
 This contains a set of .cpp files that each `#include` a single header.
@@ -34,6 +34,25 @@ __When submitting a pull request please do not include changes to the single inc
 as these are managed by the scripts!__


+## Testing your changes
+
+Obviously all changes to Catch's code should be tested. If you added new functionality, you should add tests covering and
+showcasing it. Even if you have only made changes to Catch internals (ie you implemented some performance improvements),
+you should still test your changes.
+
+This means 3 things
+
+* Compiling Catch's SelfTest project -- code that does not compile is evidently incorrect. Obviously, you are not expected to
+have access to all compilers and platforms Catch supports, Catch's CI pipeline will compile your code using supported compilers
+once you open a PR.
+* Running the SelfTest binary. There should be no unexpected failures on simple run.
+* Running Catch's approval tests. Approval tests compare current output of the SelfTest binary in various configurations against
+known good output. Catch's repository provides utility scripts `approvalTests.py` to help you with this. It needs to be passed
+the SelfTest binary compiled with your changes, like so: `$ ./scripts/approvalTests.py clang-build/SelfTest`. The output should
+be fairly self-explanatory.
+
+
+
 *this document is still in-progress...*

 ---
--- a/docs/event-listeners.md
+++ b/docs/event-listeners.md
@@ -31,7 +31,7 @@ struct MyListener : Catch::TestEventListenerBase {
        // Perform some setup before a test case is run
    }
    
-    virtual void testCaseEnded( TestCaseStats const& testCaseStats ) override {
+    virtual void testCaseEnded( Catch::TestCaseStats const& testCaseStats ) override {
        // Tear-down after a test case is run
    }    
 };
@@ -70,4 +70,4 @@ just look in the source code to see what fields are available.

 ---

-[Home](Readme.md)
+[Home](Readme.md)
--- a/docs/logging.md
+++ b/docs/logging.md
@@ -1,6 +1,32 @@
 # Logging macros

-Additional messages can be logged during a test case.
+Additional messages can be logged during a test case. Note that the messages are scoped and thus will not be reported if failure occurs in scope preceding the message declaration. An example:
+
+```cpp
+TEST_CASE("Foo") {
+    INFO("Test case start");
+    for (int i = 0; i < 2; ++i) {
+        INFO("The number is " << i);
+        CHECK(i == 0);
+    }
+}
+
+TEST_CASE("Bar") {
+    INFO("Test case start");
+    for (int i = 0; i < 2; ++i) {
+        INFO("The number is " << i);
+        CHECK(i == i);
+    }
+    CHECK(false);
+}
+```
+When the `CHECK` fails in the "Foo" test case, then two messages will be printed.
+```
+Test case start
+The number is 1
+```
+When the last `CHECK` fails in the "Bar" test case, then only one message will be printed: `Test case start`.
+

 ## Streaming macros

--- a/docs/matchers.md
+++ b/docs/matchers.md
@@ -13,6 +13,7 @@ which consists of either a single matcher or one or more matchers combined using
 For example, to assert that a string ends with a certain substring:
 
 ```c++
+using Catch::Matchers::EndsWith; // or Catch::EndsWith
 std::string str = getStringFromSomewhere();
 REQUIRE_THAT( str, EndsWith( "as a service" ) ); 
 ```
@@ -34,7 +35,7 @@ REQUIRE_THAT( str,
 ```

 ## Built in matchers
-Currently Catch has some string matchers and some vector matchers.
+Currently Catch has some string matchers and some vector matchers. They are in the `Catch::Matchers` and `Catch` namespaces.
 The string matchers are `StartsWith`, `EndsWith`, `Contains` and `Equals`. Each of them also takes an optional second argument, that decides case sensitivity (by-default, they are case sensitive).
 The vector matchers are `Contains`, `VectorContains` and `Equals`. `VectorContains` looks for a single element in the matched vector, `Contains` looks for a set (vector) of elements inside the matched vector.

--- 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.
@@ -55,6 +55,9 @@ A library of algorithms for values-distributed-in-time
 ### [Trompeloeil](https://github.com/rollbear/trompeloeil)
 A thread safe header only mocking framework for C++14

+### [args](https://github.com/Taywee/args)
+A simple header-only C++ argument parser library.
+
 ## Applications & Tools

 ### [ArangoDB](https://github.com/arangodb/arangodb)
--- a/docs/release-notes.md
+++ b/docs/release-notes.md
@@ -1,3 +1,65 @@
+# 1.9.7
+
+### Fixes
+* Various warnings from clang-tidy, Resharper-C++ and PVS Studio have been addressed (#957)
+* Dynamically generated sections are now properly reported (#963)
+* Writes to `std::clog` are redirected for reporters (#989)
+  * Previously only `std::cerr` writes were redirected
+  * Interleaved writes to `std::cerr` and `std::clog` are combined properly
+* Assertions failed before signals/structured exceptions fails test case are properly reported as failed (#990)
+
+### Improvements
+* Catch's runtime overhead has been decreased further (#940)
+* Added support for IBM i ILE c++ compiler (#976)
+  * This means that AS/400 is now supported.
+* The default reporter can be configured at compile time (#978)
+  * That is, the reporter used if no reporter is explicitly specified
+
+### Other
+* `ParseAndAddCatchTests` cmake script has couple new customization options
+
+
+
+# 1.9.6
+
+### Improvements
+* Catch's runtime overhead has been significantly decreased (#937, #939)
+* Added `--list-extra-info` cli option (#934).
+  * It lists all tests together with extra information, ie filename, line number and description.
+
+
+
+# 1.9.5
+
+### Fixes
+* Truthy expressions are now reconstructed properly, not as booleans (#914)
+* Various warnings are no longer erroneously suppressed in test files (files that include `catch.hpp`, but do not define `CATCH_CONFIG_MAIN` or `CATCH_CONFIG_RUNNER`) (#871)
+* Catch no longer fails to link when main is compiled as C++, but linked against Objective-C (#855)
+* Fixed incorrect gcc version detection when deciding to use `__COUNTER__` (#928)
+  * Previously any GCC with minor version less than 3 would be incorrectly classified as not supporting `__COUNTER__`.
+* Suppressed C4996 warning caused by upcoming updated to MSVC 2017, marking `std::uncaught_exception` as deprecated. (#927)
+
+### Improvements
+* CMake integration script now incorporates debug messages and registers tests in an improved way (#911)
+* Various documentation improvements
+
+
+
+# 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
--- a/docs/release-process.md
+++ b/docs/release-process.md
@@ -0,0 +1,63 @@
+# How to release
+
+When enough changes have accumulated, it is time to release new version of Catch. This document describes the proces in doing so, that no steps are forgotten. Note that all referenced scripts can be found in the `scripts/` directory.
+
+## Neccessary steps
+
+These steps are neccessary and have to be performed before each new release. They serve to make sure that the new release is correct and linked-to from the standard places.
+
+
+### Approval testing
+
+Catch's releases are primarily validated against output from previous release, stored in `projects/SelfTest/Baselines`. To validate current sources, build the SelfTest binary and pass it to the `approvalTests.py` script: `approvalTests.py <path/to/SelfTest>`.
+
+There should be no differences, as Approval tests should be updated when changes to Catch are made, but if there are, then they need to be manually reviewed and either approved (using `approve.py`) or Catch requires other fixes.
+
+
+### Incrementing version number
+
+Catch uses a variant of [semantic versioning](http://semver.org/), with breaking API changes (and thus major version increments) being very rare. Thus, the release will usually increment the patch version, when it only contains couple of bugfixes, or minor version, when it contains new functionality, or larger changes in implementation of current functionality. 
+
+After deciding which part of version number should be incremented, you can use one of the `*Release.py` scripts to perform the required changes to Catch.
+
+
+### Generate updated single-include header
+
+After updating version number, regenerate single-include header using `generateSingleHeader.py`.
+
+
+### Release notes
+
+Once a release is ready, release notes need to be written. They should summarize changes done since last release. For rough idea of expected notes see previous releases. Once written, release notes should be placed in `docs/release-notes.md`.
+
+
+### Commit and push update to GitHub
+
+After version number is incremented, single-include header is regenerated and release notes are updated, changes should be commited and pushed to GitHub. 
+
+
+### Release on GitHub
+
+After pushing changes to GitHub, GitHub release *needs* to be created. Tag version and release title should be same as the new version, description should contain the release notes for the current release. Single header version of `catch.hpp` *needs* to be attached as a binary, as that is where the official download link links to. Preferably it should use linux line endings.
+
+## Optional steps
+
+The following steps are optional, and do not have to be performed when releasing new version of Catch. However, they are *should* happen, but they can happen the next day without losing anything significant.
+
+
+### vcpkg update
+
+Catch is maintaining its own port in Microsoft's package manager [vcpkg](https://github.com/Microsoft/vcpkg). This means that when new version of Catch is released, it should be posted there as well. `updateVcpkgPackage.py` can do a lot of neccessary work for you, it creates a branch and commits neccessary changes. You should review these changes, push and open a PR against vcpkg's upstream.
+
+Note that the script assumes you have your fork of vcpkg checked out in a directory next to the directory where you have checked out Catch, like so:
+```
+GitHub
+    Catch
+    vcpkg
+```
+
+
+### Wandbox update
+
+Recently we also included a link to wandbox with preloaded Catch on the main page. Strictly speaking it is unneccessary to update this after every release, Catch usually does not change that much between versions, but it should be kept up to date anyway.
+
--- a/docs/reporters.md
+++ b/docs/reporters.md
@@ -17,7 +17,7 @@ There are four reporters built in to the single include:

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

--- a/docs/test-cases-and-sections.md
+++ b/docs/test-cases-and-sections.md
@@ -28,7 +28,7 @@ The tag expression, ```"[widget]"``` selects A, B & D. ```"[gadget]"``` selects

 For more detail on command line selection see [the command line docs](command-line.md#specifying-which-tests-to-run)

-Tag names are not case sensitive.
+Tag names are not case sensitive and can contain any ASCII characters. This means that tags `[tag with spaces]` and `[I said "good day"]` are both allowed tags and can be filtered on. Escapes are not supported however and `[\]]` is not a valid tag.

 ### Special Tags

--- 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/docs/tutorial.md
+++ b/docs/tutorial.md
@@ -68,7 +68,7 @@ with expansion:
  0 == 1
 ```

-Note that we get the actual return value of Factorial(0) printed for us (0) - even though we used a natural expression with the == operator. That let's us immediately see what the problem is.
+Note that we get the actual return value of Factorial(0) printed for us (0) - even though we used a natural expression with the == operator. That lets us immediately see what the problem is.

 Let's change the factorial function to:

@@ -80,7 +80,7 @@ unsigned int Factorial( unsigned int number ) {

 Now all the tests pass.

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

 ## What did we do here?

--- a/include/catch.hpp
+++ b/include/catch.hpp
@@ -57,16 +57,16 @@
 #include <crtdbg.h>
 class LeakDetector {
 public:
-	LeakDetector() {
-		int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
-		flag |= _CRTDBG_LEAK_CHECK_DF;
-		flag |= _CRTDBG_ALLOC_MEM_DF;
-		_CrtSetDbgFlag(flag);
-		_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
-		_CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
-		// Change this to leaking allocation's number to break there
-		_CrtSetBreakAlloc(-1);
-	}
+    LeakDetector() {
+        int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
+        flag |= _CRTDBG_LEAK_CHECK_DF;
+        flag |= _CRTDBG_ALLOC_MEM_DF;
+        _CrtSetDbgFlag(flag);
+        _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
+        _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
+        // Change this to leaking allocation's number to break there
+        _CrtSetBreakAlloc(-1);
+    }
 };
 #else
 class LeakDetector {};
@@ -136,7 +136,7 @@ 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( ... ) 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
--- a/include/catch_session.hpp
+++ b/include/catch_session.hpp
@@ -31,10 +31,14 @@ namespace Catch {
        return reporter;
    }

+#if !defined(CATCH_CONFIG_DEFAULT_REPORTER)
+#define CATCH_CONFIG_DEFAULT_REPORTER "console"
+#endif
+
    Ptr<IStreamingReporter> makeReporter( Ptr<Config> const& config ) {
        std::vector<std::string> reporters = config->getReporterNames();
        if( reporters.empty() )
-            reporters.push_back( "console" );
+            reporters.push_back( CATCH_CONFIG_DEFAULT_REPORTER );

        Ptr<IStreamingReporter> reporter;
        for( std::vector<std::string>::const_iterator it = reporters.begin(), itEnd = reporters.end();
@@ -95,11 +99,11 @@ namespace Catch {
            if( lastSlash != std::string::npos )
                filename = filename.substr( lastSlash+1 );

-            std::string::size_type lastDot = filename.find_last_of( "." );
+            std::string::size_type lastDot = filename.find_last_of( '.' );
            if( lastDot != std::string::npos )
                filename = filename.substr( 0, lastDot );

-            tags.insert( "#" + filename );
+            tags.insert( '#' + filename );
            setTags( test, tags );
        }
    }
@@ -166,6 +170,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/external/clara.h
+++ b/include/external/clara.h
@@ -151,7 +151,7 @@ namespace Tbc {
            return oss.str();
        }

-        inline friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) {
+        friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) {
            for( Text::const_iterator it = _text.begin(), itEnd = _text.end();
                it != itEnd; ++it ) {
                if( it != _text.begin() )
--- a/include/internal/catch_approx.hpp
+++ b/include/internal/catch_approx.hpp
@@ -29,13 +29,6 @@ namespace Detail {
            m_value( value )
        {}

-        Approx( Approx const& other )
-        :   m_epsilon( other.m_epsilon ),
-            m_margin( other.m_margin ),
-            m_scale( other.m_scale ),
-            m_value( other.m_value )
-        {}
-
        static Approx custom() {
            return Approx( 0 );
        }
--- a/include/internal/catch_assertionresult.h
+++ b/include/internal/catch_assertionresult.h
@@ -33,22 +33,24 @@ namespace Catch {
        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator && ( T const& );
        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator || ( T const& );

-	private:
-		DecomposedExpression& operator = (DecomposedExpression const&);
+    private:
+        DecomposedExpression& operator = (DecomposedExpression const&);
    };

    struct AssertionInfo
    {
-        AssertionInfo() {}
-        AssertionInfo(  std::string const& _macroName,
+        AssertionInfo();
+        AssertionInfo(  char const * _macroName,
                        SourceLineInfo const& _lineInfo,
-                        std::string const& _capturedExpression,
-                        ResultDisposition::Flags _resultDisposition );
+                        char const * _capturedExpression,
+                        ResultDisposition::Flags _resultDisposition,
+                        char const * _secondArg = "");

-        std::string macroName;
+        char const * macroName;
        SourceLineInfo lineInfo;
-        std::string capturedExpression;
+        char const * capturedExpression;
        ResultDisposition::Flags resultDisposition;
+        char const * secondArg;
    };

    struct AssertionResultData
--- a/include/internal/catch_assertionresult.hpp
+++ b/include/internal/catch_assertionresult.hpp
@@ -13,14 +13,18 @@
 namespace Catch {


-    AssertionInfo::AssertionInfo(   std::string const& _macroName,
+    AssertionInfo::AssertionInfo():macroName(""), capturedExpression(""), resultDisposition(ResultDisposition::Normal), secondArg(""){}
+
+    AssertionInfo::AssertionInfo(   char const * _macroName,
                                    SourceLineInfo const& _lineInfo,
-                                    std::string const& _capturedExpression,
-                                    ResultDisposition::Flags _resultDisposition )
+                                    char const * _capturedExpression,
+                                    ResultDisposition::Flags _resultDisposition,
+                                    char const * _secondArg)
    :   macroName( _macroName ),
        lineInfo( _lineInfo ),
        capturedExpression( _capturedExpression ),
-        resultDisposition( _resultDisposition )
+        resultDisposition( _resultDisposition ),
+        secondArg( _secondArg )
    {}

    AssertionResult::AssertionResult() {}
@@ -47,24 +51,30 @@ namespace Catch {
    }

    bool AssertionResult::hasExpression() const {
-        return !m_info.capturedExpression.empty();
+        return m_info.capturedExpression[0] != 0;
    }

    bool AssertionResult::hasMessage() const {
        return !m_resultData.message.empty();
    }

+    std::string capturedExpressionWithSecondArgument( char const * capturedExpression, char const * secondArg ) {
+        return (secondArg[0] == 0 || secondArg[0] == '"' && secondArg[1] == '"')
+            ? capturedExpression
+            : std::string(capturedExpression) + ", " + secondArg;
+    }
+
    std::string AssertionResult::getExpression() const {
        if( isFalseTest( m_info.resultDisposition ) )
-            return '!' + m_info.capturedExpression;
+            return '!' + capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg);
        else
-            return m_info.capturedExpression;
+            return capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg);
    }
    std::string AssertionResult::getExpressionInMacro() const {
-        if( m_info.macroName.empty() )
-            return m_info.capturedExpression;
+        if( m_info.macroName[0] == 0 )
+            return capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg);
        else
-            return m_info.macroName + "( " + m_info.capturedExpression + " )";
+            return std::string(m_info.macroName) + "( " + capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg) + " )";
    }

    bool AssertionResult::hasExpandedExpression() const {
--- a/include/internal/catch_capture.hpp
+++ b/include/internal/catch_capture.hpp
@@ -60,7 +60,7 @@
 // source code rather than in Catch library code
 #define INTERNAL_CATCH_REACT( resultBuilder ) \
    if( resultBuilder.shouldDebugBreak() ) CATCH_BREAK_INTO_DEBUGGER(); \
-    resultBuilder.react(); 
+    resultBuilder.react();
 #endif


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

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

 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, expr ) \
@@ -152,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(); \
--- a/include/internal/catch_commandline.hpp
+++ b/include/internal/catch_commandline.hpp
@@ -187,6 +187,10 @@ namespace Catch {
            .describe( "list all/matching test cases names only" )
            .bind( &ConfigData::listTestNamesOnly );

+        cli["--list-extra-info"]
+            .describe( "list all/matching test cases with more info" )
+            .bind( &ConfigData::listExtraInfo );
+
        cli["--list-reporters"]
            .describe( "list all reporters" )
            .bind( &ConfigData::listReporters );
--- a/include/internal/catch_common.h
+++ b/include/internal/catch_common.h
@@ -61,14 +61,14 @@ namespace Catch {
    };

    template<typename ContainerT>
-    inline void deleteAll( ContainerT& container ) {
+    void deleteAll( ContainerT& container ) {
        typename ContainerT::const_iterator it = container.begin();
        typename ContainerT::const_iterator itEnd = container.end();
        for(; it != itEnd; ++it )
            delete *it;
    }
    template<typename AssociativeContainerT>
-    inline void deleteAllValues( AssociativeContainerT& container ) {
+    void deleteAllValues( AssociativeContainerT& container ) {
        typename AssociativeContainerT::const_iterator it = container.begin();
        typename AssociativeContainerT::const_iterator itEnd = container.end();
        for(; it != itEnd; ++it )
--- a/include/internal/catch_compiler_capabilities.h
+++ b/include/internal/catch_compiler_capabilities.h
@@ -89,6 +89,10 @@

 #endif

+#ifdef __OS400__
+#       define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
+#       define CATCH_CONFIG_COLOUR_NONE
+#endif

 ////////////////////////////////////////////////////////////////////////////////
 // Cygwin
@@ -170,7 +174,7 @@

 // Use __COUNTER__ if the compiler supports it
 #if ( defined _MSC_VER && _MSC_VER >= 1300 ) || \
-    ( defined __GNUC__  && __GNUC__ >= 4 && __GNUC_MINOR__ >= 3 ) || \
+    ( defined __GNUC__  && ( __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3 )) ) || \
    ( defined __clang__ && __clang_major__ >= 3 )

 #define CATCH_INTERNAL_CONFIG_COUNTER
--- a/include/internal/catch_config.hpp
+++ b/include/internal/catch_config.hpp
@@ -31,6 +31,7 @@ namespace Catch {
            listTags( false ),
            listReporters( false ),
            listTestNamesOnly( false ),
+            listExtraInfo( false ),
            showSuccessfulTests( false ),
            shouldDebugBreak( false ),
            noThrow( false ),
@@ -50,6 +51,7 @@ namespace Catch {
        bool listTags;
        bool listReporters;
        bool listTestNamesOnly;
+        bool listExtraInfo;

        bool showSuccessfulTests;
        bool shouldDebugBreak;
@@ -109,6 +111,7 @@ namespace Catch {
        bool listTestNamesOnly() const { return m_data.listTestNamesOnly; }
        bool listTags() const { return m_data.listTags; }
        bool listReporters() const { return m_data.listReporters; }
+        bool listExtraInfo() const { return m_data.listExtraInfo; }

        std::string getProcessName() const { return m_data.processName; }

--- a/include/internal/catch_debugger.h
+++ b/include/internal/catch_debugger.h
@@ -26,9 +26,9 @@ namespace Catch{
    #if defined(__ppc64__) || defined(__ppc__)
        #define CATCH_TRAP() \
                __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n" \
-                : : : "memory","r0","r3","r4" )
+                : : : "memory","r0","r3","r4" ) /* NOLINT */
    #else
-        #define CATCH_TRAP() __asm__("int $3\n" : : )
+        #define CATCH_TRAP() __asm__("int $3\n" : : /* NOLINT */ )
    #endif

 #elif defined(CATCH_PLATFORM_LINUX)
@@ -36,7 +36,7 @@ namespace Catch{
    // directly at the location of the failing check instead of breaking inside
    // raise() called from it, i.e. one stack frame below.
    #if defined(__GNUC__) && (defined(__i386) || defined(__x86_64))
-        #define CATCH_TRAP() asm volatile ("int $3")
+        #define CATCH_TRAP() asm volatile ("int $3") /* NOLINT */
    #else // Fall back to the generic way.
        #include <signal.h>

--- a/include/internal/catch_default_main.hpp
+++ b/include/internal/catch_default_main.hpp
@@ -10,9 +10,15 @@

 #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[]) {
-	int result = Catch::Session().run( argc, argv );
+#endif
+
+    int result = Catch::Session().run( argc, argv );
    return ( result < 0xff ? result : 0xff );
 }

--- a/include/internal/catch_evaluate.hpp
+++ b/include/internal/catch_evaluate.hpp
@@ -37,7 +37,7 @@ namespace Internal {
    template<> struct OperatorTraits<IsGreaterThanOrEqualTo>{ static const char* getName(){ return ">="; } };

    template<typename T>
-    inline T& opCast(T const& t) { return const_cast<T&>(t); }
+    T& opCast(T const& t) { return const_cast<T&>(t); }

 // nullptr_t support based on pull request #154 from Konstantin Baumann
 #ifdef CATCH_CONFIG_CPP11_NULLPTR
@@ -48,7 +48,7 @@ namespace Internal {
    // So the compare overloads can be operator agnostic we convey the operator as a template
    // enum, which is used to specialise an Evaluator for doing the comparison.
    template<typename T1, typename T2, Operator Op>
-    class Evaluator{};
+    struct Evaluator{};

    template<typename T1, typename T2>
    struct Evaluator<T1, T2, IsEqualTo> {
--- a/include/internal/catch_expression_lhs.hpp
+++ b/include/internal/catch_expression_lhs.hpp
@@ -81,7 +81,7 @@ public:
    }

    virtual void reconstructExpression( std::string& dest ) const CATCH_OVERRIDE {
-        dest = Catch::toString( m_truthy );
+        dest = Catch::toString( m_lhs );
    }

 private:
--- a/include/internal/catch_fatal_condition.hpp
+++ b/include/internal/catch_fatal_condition.hpp
@@ -28,7 +28,7 @@ namespace Catch {

 namespace Catch {
    struct FatalConditionHandler {
-        void reset() {}        
+        void reset() {}
    };
 }

@@ -106,7 +106,7 @@ namespace Catch {

 namespace Catch {
    struct FatalConditionHandler {
-        void reset() {}        
+        void reset() {}
    };
 }

--- a/include/internal/catch_interfaces_capture.h
+++ b/include/internal/catch_interfaces_capture.h
@@ -41,6 +41,10 @@ namespace Catch {
        virtual void exceptionEarlyReported() = 0;

        virtual void handleFatalErrorCondition( std::string const& message ) = 0;
+
+        virtual bool lastAssertionPassed() = 0;
+        virtual void assertionPassed() = 0;
+        virtual void assertionRun() = 0;
    };

    IResultCapture& getResultCapture();
--- a/include/internal/catch_list.hpp
+++ b/include/internal/catch_list.hpp
@@ -30,8 +30,9 @@ namespace Catch {
        }

        std::size_t matchedTests = 0;
-        TextAttributes nameAttr, tagsAttr;
+        TextAttributes nameAttr, descAttr, tagsAttr;
        nameAttr.setInitialIndent( 2 ).setIndent( 4 );
+        descAttr.setIndent( 4 );
        tagsAttr.setIndent( 6 );

        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
@@ -46,6 +47,13 @@ namespace Catch {
            Colour colourGuard( colour );

            Catch::cout() << Text( testCaseInfo.name, nameAttr ) << std::endl;
+            if( config.listExtraInfo() ) {
+                Catch::cout() << "    " << testCaseInfo.lineInfo << std::endl;
+                std::string description = testCaseInfo.description;
+                if( description.empty() )
+                    description = "(NO DESCRIPTION)";
+                Catch::cout() << Text( description, descAttr ) << std::endl;
+            }
            if( !testCaseInfo.tags.empty() )
                Catch::cout() << Text( testCaseInfo.tagsAsString, tagsAttr ) << std::endl;
        }
@@ -69,9 +77,12 @@ namespace Catch {
            matchedTests++;
            TestCaseInfo const& testCaseInfo = it->getTestCaseInfo();
            if( startsWith( testCaseInfo.name, '#' ) )
-               Catch::cout() << '"' << testCaseInfo.name << '"' << std::endl;
+               Catch::cout() << '"' << testCaseInfo.name << '"';
            else
-               Catch::cout() << testCaseInfo.name << std::endl;
+               Catch::cout() << testCaseInfo.name;
+            if ( config.listExtraInfo() )
+                Catch::cout() << "\t@" << testCaseInfo.lineInfo;
+            Catch::cout() << std::endl;
        }
        return matchedTests;
    }
@@ -163,7 +174,7 @@ namespace Catch {

    inline Option<std::size_t> list( Config const& config ) {
        Option<std::size_t> listedCount;
-        if( config.listTests() )
+        if( config.listTests() || ( config.listExtraInfo() && !config.listTestNamesOnly() ) )
            listedCount = listedCount.valueOr(0) + listTests( config );
        if( config.listTestNamesOnly() )
            listedCount = listedCount.valueOr(0) + listTestsNamesOnly( config );
--- a/include/internal/catch_matchers.hpp
+++ b/include/internal/catch_matchers.hpp
@@ -147,23 +147,23 @@ namespace Matchers {
    // This allows the types to be inferred
    // - deprecated: prefer ||, && and !
    template<typename T>
-    inline Impl::MatchNotOf<T> Not( Impl::MatcherBase<T> const& underlyingMatcher ) {
+    Impl::MatchNotOf<T> Not( Impl::MatcherBase<T> const& underlyingMatcher ) {
        return Impl::MatchNotOf<T>( underlyingMatcher );
    }
    template<typename T>
-    inline Impl::MatchAllOf<T> AllOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2 ) {
+    Impl::MatchAllOf<T> AllOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2 ) {
        return Impl::MatchAllOf<T>() && m1 && m2;
    }
    template<typename T>
-    inline Impl::MatchAllOf<T> AllOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2, Impl::MatcherBase<T> const& m3 ) {
+    Impl::MatchAllOf<T> AllOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2, Impl::MatcherBase<T> const& m3 ) {
        return Impl::MatchAllOf<T>() && m1 && m2 && m3;
    }
    template<typename T>
-    inline Impl::MatchAnyOf<T> AnyOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2 ) {
+    Impl::MatchAnyOf<T> AnyOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2 ) {
        return Impl::MatchAnyOf<T>() || m1 || m2;
    }
    template<typename T>
-    inline Impl::MatchAnyOf<T> AnyOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2, Impl::MatcherBase<T> const& m3 ) {
+    Impl::MatchAnyOf<T> AnyOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2, Impl::MatcherBase<T> const& m3 ) {
        return Impl::MatchAnyOf<T>() || m1 || m2 || m3;
    }

--- a/include/internal/catch_notimplemented_exception.h
+++ b/include/internal/catch_notimplemented_exception.h
@@ -16,7 +16,6 @@ namespace Catch {
    {
    public:
        NotImplementedException( SourceLineInfo const& lineInfo );
-        NotImplementedException( NotImplementedException const& ) {}

        virtual ~NotImplementedException() CATCH_NOEXCEPT {}

--- a/include/internal/catch_objc.hpp
+++ b/include/internal/catch_objc.hpp
@@ -104,7 +104,7 @@ namespace Catch {
    namespace Matchers {
        namespace Impl {
        namespace NSStringMatchers {
-           
+
            struct StringHolder : MatcherBase<NSString*>{
                StringHolder( NSString* substr ) : m_substr( [substr copy] ){}
                StringHolder( StringHolder const& other ) : m_substr( [other.m_substr copy] ){}
--- a/include/internal/catch_option.hpp
+++ b/include/internal/catch_option.hpp
@@ -69,7 +69,7 @@ namespace Catch {
        T *nullableValue;
        union {
            char storage[sizeof(T)];
-    
+
            // These are here to force alignment for the storage
            long double dummy1;
            void (*dummy2)();
--- a/include/internal/catch_result_builder.h
+++ b/include/internal/catch_result_builder.h
@@ -47,7 +47,7 @@ namespace Catch {

        template<typename T>
        ResultBuilder& operator << ( T const& value ) {
-            m_stream.oss << value;
+            stream().oss << value;
            return *this;
        }

@@ -80,11 +80,27 @@ namespace Catch {
    private:
        AssertionInfo m_assertionInfo;
        AssertionResultData m_data;
-        CopyableStream m_stream;
+
+        CopyableStream &stream()
+        {
+            if(!m_usedStream)
+            {
+                m_usedStream = true;
+                m_stream().oss.str("");
+            }
+            return m_stream();
+        }
+
+        static CopyableStream &m_stream()
+        {
+            static CopyableStream s;
+            return s;
+        }

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

 } // namespace Catch
@@ -95,7 +111,7 @@ namespace Catch {
 namespace Catch {

    template<typename T>
-    inline ExpressionLhs<T const&> ResultBuilder::operator <= ( T const& operand ) {
+    ExpressionLhs<T const&> ResultBuilder::operator <= ( T const& operand ) {
        return ExpressionLhs<T const&>( *this, operand );
    }

@@ -104,7 +120,7 @@ namespace Catch {
    }

    template<typename ArgT, typename MatcherT>
-    inline void ResultBuilder::captureMatch( ArgT const& arg, MatcherT const& matcher,
+    void ResultBuilder::captureMatch( ArgT const& arg, MatcherT const& matcher,
                                             char const* matcherString ) {
        MatchExpression<ArgT const&, MatcherT const&> expr( arg, matcher, matcherString );
        setResultType( matcher.match( arg ) );
--- a/include/internal/catch_result_builder.hpp
+++ b/include/internal/catch_result_builder.hpp
@@ -18,26 +18,22 @@

 namespace Catch {

-    std::string capturedExpressionWithSecondArgument( std::string const& capturedExpression, std::string const& secondArg ) {
-        return secondArg.empty() || secondArg == "\"\""
-            ? capturedExpression
-            : capturedExpression + ", " + secondArg;
-    }
    ResultBuilder::ResultBuilder(   char const* macroName,
                                    SourceLineInfo const& lineInfo,
                                    char const* capturedExpression,
                                    ResultDisposition::Flags resultDisposition,
                                    char const* secondArg )
-    :   m_assertionInfo( macroName, lineInfo, capturedExpressionWithSecondArgument( capturedExpression, secondArg ), resultDisposition ),
+    :   m_assertionInfo( macroName, lineInfo, capturedExpression, resultDisposition, secondArg ),
        m_shouldDebugBreak( false ),
        m_shouldThrow( false ),
-        m_guardException( false )
+        m_guardException( false ),
+        m_usedStream( false )
    {}

    ResultBuilder::~ResultBuilder() {
 #if defined(CATCH_CONFIG_FAST_COMPILE)
        if ( m_guardException ) {
-            m_stream.oss << "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE";
+            stream().oss << "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE";
            captureResult( ResultWas::ThrewException );
            getCurrentContext().getResultCapture()->exceptionEarlyReported();
        }
@@ -54,13 +50,25 @@ namespace Catch {
    }

    void ResultBuilder::endExpression( DecomposedExpression const& expr ) {
-        AssertionResult result = build( expr );
-        handleResult( result );
+        // Flip bool results if FalseTest flag is set
+        if( isFalseTest( m_assertionInfo.resultDisposition ) ) {
+            m_data.negate( expr.isBinaryExpression() );
+        }
+
+        getResultCapture().assertionRun();
+
+        if(getCurrentContext().getConfig()->includeSuccessfulResults() || m_data.resultType != ResultWas::Ok)
+        {
+            AssertionResult result = build( expr );
+            handleResult( result );
+        }
+        else
+            getResultCapture().assertionPassed();
    }

    void ResultBuilder::useActiveException( ResultDisposition::Flags resultDisposition ) {
        m_assertionInfo.resultDisposition = resultDisposition;
-        m_stream.oss << Catch::translateActiveException();
+        stream().oss << Catch::translateActiveException();
        captureResult( ResultWas::ThrewException );
    }

@@ -82,7 +90,7 @@ namespace Catch {
        assert( !isFalseTest( m_assertionInfo.resultDisposition ) );
        AssertionResultData data = m_data;
        data.resultType = ResultWas::Ok;
-        data.reconstructedExpression = m_assertionInfo.capturedExpression;
+        data.reconstructedExpression = capturedExpressionWithSecondArgument(m_assertionInfo.capturedExpression, m_assertionInfo.secondArg);

        std::string actualMessage = Catch::translateActiveException();
        if( !matcher.match( actualMessage ) ) {
@@ -143,18 +151,14 @@ namespace Catch {
        assert( m_data.resultType != ResultWas::Unknown );
        AssertionResultData data = m_data;

-        // Flip bool results if FalseTest flag is set
-        if( isFalseTest( m_assertionInfo.resultDisposition ) ) {
-            data.negate( expr.isBinaryExpression() );
-        }
-
-        data.message = m_stream.oss.str();
+        if(m_usedStream)
+            data.message = m_stream().oss.str();
        data.decomposedExpression = &expr; // for lazy reconstruction
        return AssertionResult( m_assertionInfo, data );
    }

    void ResultBuilder::reconstructExpression( std::string& dest ) const {
-        dest = m_assertionInfo.capturedExpression;
+        dest = capturedExpressionWithSecondArgument(m_assertionInfo.capturedExpression, m_assertionInfo.secondArg);
    }

    void ResultBuilder::setExceptionGuard() {
--- a/include/internal/catch_run_context.hpp
+++ b/include/internal/catch_run_context.hpp
@@ -22,6 +22,7 @@
 #include "catch_result_builder.h"
 #include "catch_fatal_condition.hpp"

+
 #include <set>
 #include <string>

@@ -50,6 +51,29 @@ namespace Catch {
        std::string& m_targetString;
    };

+    // StdErr has two constituent streams in C++, std::cerr and std::clog
+    // This means that we need to redirect 2 streams into 1 to keep proper
+    // order of writes and cannot use StreamRedirect on its own
+    class StdErrRedirect {
+    public:
+        StdErrRedirect(std::string& targetString)
+        :m_cerrBuf( cerr().rdbuf() ), m_clogBuf(clog().rdbuf()),
+        m_targetString(targetString){
+            cerr().rdbuf(m_oss.rdbuf());
+            clog().rdbuf(m_oss.rdbuf());
+        }
+        ~StdErrRedirect() {
+            m_targetString += m_oss.str();
+            cerr().rdbuf(m_cerrBuf);
+            clog().rdbuf(m_clogBuf);
+        }
+    private:
+        std::streambuf* m_cerrBuf;
+        std::streambuf* m_clogBuf;
+        std::ostringstream m_oss;
+        std::string& m_targetString;
+    };
+
    ///////////////////////////////////////////////////////////////////////////

    class RunContext : public IResultCapture, public IRunner {
@@ -145,14 +169,32 @@ 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 );
+            m_lastAssertionInfo = AssertionInfo( "", m_lastAssertionInfo.lineInfo, "{Unknown expression after the reported line}" , m_lastAssertionInfo.resultDisposition );
            m_lastResult = result;
        }

+        virtual bool lastAssertionPassed()
+        {
+            return m_totals.assertions.passed == (m_prevPassed + 1);
+        }
+
+        virtual void assertionPassed()
+        {
+            m_totals.assertions.passed++;
+            m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}";
+            m_lastAssertionInfo.macroName = "";
+        }
+
+        virtual void assertionRun()
+        {
+            m_prevPassed = m_totals.assertions.passed;
+        }
+
        virtual bool sectionStarted (
            SectionInfo const& sectionInfo,
            Counts& assertions
@@ -253,6 +295,7 @@ namespace Catch {

            Totals deltaTotals;
            deltaTotals.testCases.failed = 1;
+            deltaTotals.assertions.failed = 1;
            m_reporter->testCaseEnded( TestCaseStats(   testInfo,
                                                        deltaTotals,
                                                        std::string(),
@@ -279,7 +322,7 @@ namespace Catch {
            double duration = 0;
            m_shouldReportUnexpected = true;
            try {
-                m_lastAssertionInfo = AssertionInfo( "TEST_CASE", testCaseInfo.lineInfo, std::string(), ResultDisposition::Normal );
+                m_lastAssertionInfo = AssertionInfo( "TEST_CASE", testCaseInfo.lineInfo, "", ResultDisposition::Normal );

                seedRng( *m_config );

@@ -287,7 +330,7 @@ namespace Catch {
                timer.start();
                if( m_reporter->getPreferences().shouldRedirectStdOut ) {
                    StreamRedirect coutRedir( Catch::cout(), redirectedCout );
-                    StreamRedirect cerrRedir( Catch::cerr(), redirectedCerr );
+                    StdErrRedirect errRedir( redirectedCerr );
                    invokeActiveTestCase();
                }
                else {
@@ -299,7 +342,7 @@ namespace Catch {
                // This just means the test was aborted due to failure
            }
            catch(...) {
-                // Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions 
+                // Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions
                // are reported without translation at the point of origin.
                if (m_shouldReportUnexpected) {
                    makeUnexpectedResultBuilder().useActiveException();
@@ -331,9 +374,9 @@ namespace Catch {
    private:

        ResultBuilder makeUnexpectedResultBuilder() const {
-            return ResultBuilder(   m_lastAssertionInfo.macroName.c_str(),
+            return ResultBuilder(   m_lastAssertionInfo.macroName,
                                    m_lastAssertionInfo.lineInfo,
-                                    m_lastAssertionInfo.capturedExpression.c_str(),
+                                    m_lastAssertionInfo.capturedExpression,
                                    m_lastAssertionInfo.resultDisposition );
        }

@@ -363,6 +406,7 @@ namespace Catch {
        std::vector<SectionEndInfo> m_unfinishedSections;
        std::vector<ITracker*> m_activeSections;
        TrackerContext m_trackerContext;
+        size_t m_prevPassed;
        bool m_shouldReportUnexpected;
    };

--- a/include/internal/catch_section.hpp
+++ b/include/internal/catch_section.hpp
@@ -30,6 +30,10 @@ namespace Catch {
        m_timer.start();
    }

+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4996) // std::uncaught_exception is deprecated in C++17
+#endif
    Section::~Section() {
        if( m_sectionIncluded ) {
            SectionEndInfo endInfo( m_info, m_assertions, m_timer.getElapsedSeconds() );
@@ -39,6 +43,9 @@ namespace Catch {
                getResultCapture().sectionEnded( endInfo );
        }
    }
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif

    // This indicates whether the section should be executed or not
    Section::operator bool() const {
--- a/include/internal/catch_stream.h
+++ b/include/internal/catch_stream.h
@@ -21,6 +21,7 @@ namespace Catch {

    std::ostream& cout();
    std::ostream& cerr();
+    std::ostream& clog();


    struct IStream {
--- a/include/internal/catch_stream.hpp
+++ b/include/internal/catch_stream.hpp
@@ -103,6 +103,9 @@ namespace Catch {
    std::ostream& cerr() {
        return std::cerr;
    }
+    std::ostream& clog() {
+        return std::clog;
+    }
 #endif
 }

--- a/include/internal/catch_test_registry.hpp
+++ b/include/internal/catch_test_registry.hpp
@@ -88,7 +88,7 @@ void registerTestCaseFunction
    #define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \
        static void TestName(); \
        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &TestName, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); } \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &TestName, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); } /* NOLINT */ \
        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
        static void TestName()
    #define INTERNAL_CATCH_TESTCASE( ... ) \
@@ -97,7 +97,7 @@ void registerTestCaseFunction
    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); } \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); } /* NOLINT */ \
        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS

    ///////////////////////////////////////////////////////////////////////////////
@@ -107,7 +107,7 @@ void registerTestCaseFunction
            struct TestName : ClassName{ \
                void test(); \
            }; \
-            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &TestName::test, #ClassName, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); \
+            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &TestName::test, #ClassName, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); /* NOLINT */ \
        } \
        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
        void TestName::test()
@@ -117,7 +117,7 @@ void registerTestCaseFunction
    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \
        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
-        Catch::AutoReg( Function, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); \
+        Catch::AutoReg( Function, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); /* NOLINT */ \
        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS

 #else
@@ -125,7 +125,7 @@ void registerTestCaseFunction
    #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 ) ); }\
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &TestName, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) ); } /* NOLINT */ \
        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
        static void TestName()
    #define INTERNAL_CATCH_TESTCASE( Name, Desc ) \
@@ -134,7 +134,7 @@ void registerTestCaseFunction
    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, Name, Desc ) \
        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( Name, Desc ), CATCH_INTERNAL_LINEINFO ); } \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( Name, Desc ), CATCH_INTERNAL_LINEINFO ); } /* NOLINT */ \
        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS

    ///////////////////////////////////////////////////////////////////////////////
@@ -144,7 +144,7 @@ void registerTestCaseFunction
            struct TestCaseName : ClassName{ \
                void test(); \
            }; \
-            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &TestCaseName::test, #ClassName, Catch::NameAndDesc( TestName, Desc ), CATCH_INTERNAL_LINEINFO ); \
+            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &TestCaseName::test, #ClassName, Catch::NameAndDesc( TestName, Desc ), CATCH_INTERNAL_LINEINFO ); /* NOLINT */ \
        } \
        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
        void TestCaseName::test()
@@ -154,7 +154,7 @@ void registerTestCaseFunction
    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, Name, Desc ) \
        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
-        Catch::AutoReg( Function, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) ); \
+        Catch::AutoReg( Function, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) ); /* NOLINT */ \
        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS

 #endif
--- a/include/internal/catch_test_spec_parser.hpp
+++ b/include/internal/catch_test_spec_parser.hpp
@@ -30,7 +30,7 @@ namespace Catch {
        ITagAliasRegistry const* m_tagAliases;

    public:
-        TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {}
+        TestSpecParser( ITagAliasRegistry const& tagAliases ) :m_mode(None), m_exclusion(false), m_start(0), m_pos(0), m_tagAliases( &tagAliases ) {}

        TestSpecParser& parse( std::string const& arg ) {
            m_mode = None;
--- 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
@@ -63,7 +63,7 @@ std::string toString( std::nullptr_t );

 #ifdef __OBJC__
    std::string toString( NSString const * const& nsstring );
-    std::string toString( NSString * CATCH_ARC_STRONG const& nsstring );
+    std::string toString( NSString * CATCH_ARC_STRONG & nsstring );
    std::string toString( NSObject* const& nsObject );
 #endif

@@ -153,7 +153,7 @@ namespace Detail {
    std::string rawMemoryToString( const void *object, std::size_t size );

    template<typename T>
-    inline std::string rawMemoryToString( const T& object ) {
+    std::string rawMemoryToString( const T& object ) {
      return rawMemoryToString( &object, sizeof(object) );
    }

--- a/include/internal/catch_tostring.hpp
+++ b/include/internal/catch_tostring.hpp
@@ -198,7 +198,7 @@ std::string toString( std::nullptr_t ) {
            return "nil";
        return "@" + toString([nsstring UTF8String]);
    }
-    std::string toString( NSString * CATCH_ARC_STRONG const& nsstring ) {
+    std::string toString( NSString * CATCH_ARC_STRONG & nsstring ) {
        if( !nsstring )
            return "nil";
        return "@" + toString([nsstring UTF8String]);
--- a/include/internal/catch_type_traits.hpp
+++ b/include/internal/catch_type_traits.hpp
@@ -25,7 +25,7 @@ namespace Catch {
 #else

    template <typename T>
-    struct add_const { 
+    struct add_const {
        typedef const T type;
    };

--- a/include/internal/catch_version.hpp
+++ b/include/internal/catch_version.hpp
@@ -38,7 +38,7 @@ namespace Catch {
    }

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

--- a/include/internal/catch_xmlwriter.hpp
+++ b/include/internal/catch_xmlwriter.hpp
@@ -10,7 +10,6 @@

 #include "catch_stream.h"
 #include "catch_compiler_capabilities.h"
-#include "catch_suppress_warnings.h"

 #include <sstream>
 #include <string>
@@ -241,6 +240,5 @@ namespace Catch {
    };

 }
-#include "catch_reenable_warnings.h"

 #endif // TWOBLUECUBES_CATCH_XMLWRITER_HPP_INCLUDED
--- a/include/reporters/catch_reporter_bases.hpp
+++ b/include/reporters/catch_reporter_bases.hpp
@@ -28,7 +28,7 @@ namespace Catch {
            // + 1 for null terminator
            const size_t maxDoubleSize = DBL_MAX_10_EXP + 1 + 1 + 3 + 1;
            char buffer[maxDoubleSize];
-            
+
            // Save previous errno, to prevent sprintf from overwriting it
            ErrnoGuard guard;
 #ifdef _MSC_VER
@@ -137,7 +137,8 @@ namespace Catch {
            BySectionInfo( SectionInfo const& other ) : m_other( other ) {}
            BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {}
            bool operator() ( Ptr<SectionNode> const& node ) const {
-                return node->stats.sectionInfo.lineInfo == m_other.lineInfo;
+                return ((node->stats.sectionInfo.name == m_other.name) &&
+                        (node->stats.sectionInfo.lineInfo == m_other.lineInfo));
            }
        private:
            void operator=( BySectionInfo const& );
--- a/include/reporters/catch_reporter_junit.hpp
+++ b/include/reporters/catch_reporter_junit.hpp
@@ -52,6 +52,7 @@ namespace Catch {
        JunitReporter( ReporterConfig const& _config )
        :   CumulativeReporterBase( _config ),
            xml( _config.stream() ),
+            unexpectedExceptions( 0 ),
            m_okToFail( false )
        {
            m_reporterPrefs.shouldRedirectStdOut = true;
--- a/include/reporters/catch_reporter_teamcity.hpp
+++ b/include/reporters/catch_reporter_teamcity.hpp
@@ -150,6 +150,7 @@ namespace Catch {
        }

        virtual void testCaseStarting( TestCaseInfo const& testInfo ) CATCH_OVERRIDE {
+            m_testTimer.start();
            StreamingReporterBase::testCaseStarting( testInfo );
            stream << "##teamcity[testStarted name='"
                << escape( testInfo.name ) << "']\n";
@@ -166,7 +167,8 @@ namespace Catch {
                    << escape( testCaseStats.testInfo.name )
                    << "' out='" << escape( testCaseStats.stdErr ) << "']\n";
            stream << "##teamcity[testFinished name='"
-                << escape( testCaseStats.testInfo.name ) << "']\n";
+                    << escape( testCaseStats.testInfo.name ) << "' duration='"
+                    << m_testTimer.getElapsedMilliseconds() << "']\n";
        }

    private:
@@ -205,6 +207,7 @@ namespace Catch {
        }
    private:
        bool m_headerPrintedForThisSection;
+        Timer m_testTimer;
    };

 #ifdef CATCH_IMPL
--- a/projects/SelfTest/Baselines/console.std.approved.txt
+++ b/projects/SelfTest/Baselines/console.std.approved.txt
@@ -368,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

 -------------------------------------------------------------------------------
@@ -593,6 +595,17 @@ MessageTests.cpp:<line number>:
 warning:
  toString(p): 0x<hex digits>

+-------------------------------------------------------------------------------
+Reconstruction should be based on stringification: #914
+-------------------------------------------------------------------------------
+DecompositionTests.cpp:<line number>
+...............................................................................
+
+DecompositionTests.cpp:<line number>: FAILED:
+  CHECK( truthy(false) )
+with expansion:
+  Hey, its truthy!
+
 -------------------------------------------------------------------------------
 SCOPED_INFO is reset for each loop
 -------------------------------------------------------------------------------
@@ -609,6 +622,9 @@ with messages:

 A string sent directly to stdout
 A string sent directly to stderr
+Write to std::cerr
+Write to std::clog
+Interleaved writes to error streams
 Message from section one
 Message from section two
 -------------------------------------------------------------------------------
@@ -940,6 +956,6 @@ with expansion:
  "first" == "second"

 ===============================================================================
-test cases: 167 | 119 passed | 44 failed |  4 failed as expected
-assertions: 967 | 859 passed | 87 failed | 21 failed as expected
+test cases: 170 | 121 passed | 45 failed |  4 failed as expected
+assertions: 973 | 864 passed | 88 failed | 21 failed as expected

--- a/projects/SelfTest/Baselines/console.sw.approved.txt
+++ b/projects/SelfTest/Baselines/console.sw.approved.txt
@@ -119,10 +119,70 @@ with expansion:

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

+-------------------------------------------------------------------------------
+#961 -- Dynamically created sections should all be reported
+  Looped section 0
+-------------------------------------------------------------------------------
+MiscTests.cpp:<line number>
+...............................................................................
+
+MiscTests.cpp:<line number>:
+PASSED:
+with message:
+  Everything is OK
+
+-------------------------------------------------------------------------------
+#961 -- Dynamically created sections should all be reported
+  Looped section 1
+-------------------------------------------------------------------------------
+MiscTests.cpp:<line number>
+...............................................................................
+
+MiscTests.cpp:<line number>:
+PASSED:
+with message:
+  Everything is OK
+
+-------------------------------------------------------------------------------
+#961 -- Dynamically created sections should all be reported
+  Looped section 2
+-------------------------------------------------------------------------------
+MiscTests.cpp:<line number>
+...............................................................................
+
+MiscTests.cpp:<line number>:
+PASSED:
+with message:
+  Everything is OK
+
+-------------------------------------------------------------------------------
+#961 -- Dynamically created sections should all be reported
+  Looped section 3
+-------------------------------------------------------------------------------
+MiscTests.cpp:<line number>
+...............................................................................
+
+MiscTests.cpp:<line number>:
+PASSED:
+with message:
+  Everything is OK
+
+-------------------------------------------------------------------------------
+#961 -- Dynamically created sections should all be reported
+  Looped section 4
+-------------------------------------------------------------------------------
+MiscTests.cpp:<line number>
+...............................................................................
+
+MiscTests.cpp:<line number>:
+PASSED:
+with message:
+  Everything is OK
+
 -------------------------------------------------------------------------------
 'Not' checks that should fail
 -------------------------------------------------------------------------------
@@ -819,7 +879,7 @@ TrickyTests.cpp:<line number>:
 PASSED:
  REQUIRE( a )
 with expansion:
-  true
+  0x<hex digits>

 TrickyTests.cpp:<line number>:
 PASSED:
@@ -2717,14 +2777,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>:
@@ -2732,7 +2795,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

 -------------------------------------------------------------------------------
@@ -4565,7 +4631,7 @@ TrickyTests.cpp:<line number>:
 PASSED:
  CHECK( True )
 with expansion:
-  true
+  1

 TrickyTests.cpp:<line number>:
 PASSED:
@@ -4577,7 +4643,7 @@ TrickyTests.cpp:<line number>:
 PASSED:
  CHECK_FALSE( False )
 with expansion:
-  !false
+  !0

 -------------------------------------------------------------------------------
 Operators at different namespace levels not hijacked by Koenig lookup
@@ -6431,6 +6497,17 @@ TestMain.cpp:<line number>:
 PASSED:
  REQUIRE_THROWS_WITH( parseIntoConfig( argv, config ), Contains( "colour mode must be one of" ) )

+-------------------------------------------------------------------------------
+Reconstruction should be based on stringification: #914
+-------------------------------------------------------------------------------
+DecompositionTests.cpp:<line number>
+...............................................................................
+
+DecompositionTests.cpp:<line number>: FAILED:
+  CHECK( truthy(false) )
+with expansion:
+  Hey, its truthy!
+
 -------------------------------------------------------------------------------
 SCOPED_INFO is reset for each loop
 -------------------------------------------------------------------------------
@@ -6769,6 +6846,39 @@ PASSED:
 with expansion:
  Approx( 1.23 ) != 1.24

+Write to std::cerr
+-------------------------------------------------------------------------------
+Standard error is reported and redirected
+  std::cerr
+-------------------------------------------------------------------------------
+MessageTests.cpp:<line number>
+...............................................................................
+
+
+No assertions in section 'std::cerr'
+
+Write to std::clog
+-------------------------------------------------------------------------------
+Standard error is reported and redirected
+  std::clog
+-------------------------------------------------------------------------------
+MessageTests.cpp:<line number>
+...............................................................................
+
+
+No assertions in section 'std::clog'
+
+Interleaved writes to error streams
+-------------------------------------------------------------------------------
+Standard error is reported and redirected
+  Interleaved writes to cerr and clog
+-------------------------------------------------------------------------------
+MessageTests.cpp:<line number>
+...............................................................................
+
+
+No assertions in section 'Interleaved writes to cerr and clog'
+
 Message from section one
 -------------------------------------------------------------------------------
 Standard output from all sections is reported
@@ -9466,6 +9576,6 @@ MiscTests.cpp:<line number>:
 PASSED:

 ===============================================================================
-test cases: 167 | 118 passed | 45 failed |  4 failed as expected
-assertions: 969 | 859 passed | 89 failed | 21 failed as expected
+test cases: 170 | 119 passed | 47 failed |  4 failed as expected
+assertions: 978 | 864 passed | 93 failed | 21 failed as expected

--- a/projects/SelfTest/Baselines/console.swa4.approved.txt
+++ b/projects/SelfTest/Baselines/console.swa4.approved.txt
@@ -119,10 +119,70 @@ with expansion:

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

+-------------------------------------------------------------------------------
+#961 -- Dynamically created sections should all be reported
+  Looped section 0
+-------------------------------------------------------------------------------
+MiscTests.cpp:<line number>
+...............................................................................
+
+MiscTests.cpp:<line number>:
+PASSED:
+with message:
+  Everything is OK
+
+-------------------------------------------------------------------------------
+#961 -- Dynamically created sections should all be reported
+  Looped section 1
+-------------------------------------------------------------------------------
+MiscTests.cpp:<line number>
+...............................................................................
+
+MiscTests.cpp:<line number>:
+PASSED:
+with message:
+  Everything is OK
+
+-------------------------------------------------------------------------------
+#961 -- Dynamically created sections should all be reported
+  Looped section 2
+-------------------------------------------------------------------------------
+MiscTests.cpp:<line number>
+...............................................................................
+
+MiscTests.cpp:<line number>:
+PASSED:
+with message:
+  Everything is OK
+
+-------------------------------------------------------------------------------
+#961 -- Dynamically created sections should all be reported
+  Looped section 3
+-------------------------------------------------------------------------------
+MiscTests.cpp:<line number>
+...............................................................................
+
+MiscTests.cpp:<line number>:
+PASSED:
+with message:
+  Everything is OK
+
+-------------------------------------------------------------------------------
+#961 -- Dynamically created sections should all be reported
+  Looped section 4
+-------------------------------------------------------------------------------
+MiscTests.cpp:<line number>
+...............................................................................
+
+MiscTests.cpp:<line number>:
+PASSED:
+with message:
+  Everything is OK
+
 -------------------------------------------------------------------------------
 'Not' checks that should fail
 -------------------------------------------------------------------------------
@@ -144,6 +204,6 @@ ConditionTests.cpp:<line number>: FAILED:
  CHECK_FALSE( true )

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

--- a/projects/SelfTest/Baselines/junit.sw.approved.txt
+++ b/projects/SelfTest/Baselines/junit.sw.approved.txt
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <testsuitesspanner>
-  <testsuite name="<exe-name>" errors="13" failures="77" tests="970" hostname="tbd" time="{duration}" timestamp="{iso8601-timestamp}">
+  <testsuite name="<exe-name>" errors="13" failures="81" tests="979" hostname="tbd" time="{duration}" timestamp="{iso8601-timestamp}">
    <testcase classname="global" name="# A test name that starts with a #" time="{duration}"/>
    <testcase classname="#748 - captures with unexpected exceptions" name="outside assertions" time="{duration}">
      <error type="TEST_CASE">
@@ -24,6 +24,11 @@ ExceptionTests.cpp:<line number>
 MiscTests.cpp:<line number>
      </failure>
    </testcase>
+    <testcase classname="#961 -- Dynamically created sections should all be reported" name="Looped section 0" time="{duration}"/>
+    <testcase classname="#961 -- Dynamically created sections should all be reported" name="Looped section 1" time="{duration}"/>
+    <testcase classname="#961 -- Dynamically created sections should all be reported" name="Looped section 2" time="{duration}"/>
+    <testcase classname="#961 -- Dynamically created sections should all be reported" name="Looped section 3" time="{duration}"/>
+    <testcase classname="#961 -- Dynamically created sections should all be reported" name="Looped section 4" time="{duration}"/>
    <testcase classname="global" name="'Not' checks that should fail" time="{duration}">
      <failure message="false != false" type="CHECK">
 ConditionTests.cpp:<line number>
@@ -237,10 +242,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>
@@ -440,6 +448,11 @@ MessageTests.cpp:<line number>
    <testcase classname="Process can be configured on command line" name="use-colour/yes" time="{duration}"/>
    <testcase classname="Process can be configured on command line" name="use-colour/no" time="{duration}"/>
    <testcase classname="Process can be configured on command line" name="use-colour/error" time="{duration}"/>
+    <testcase classname="global" name="Reconstruction should be based on stringification: #914" time="{duration}">
+      <failure message="Hey, its truthy!" type="CHECK">
+DecompositionTests.cpp:<line number>
+      </failure>
+    </testcase>
    <testcase classname="global" name="SCOPED_INFO is reset for each loop" time="{duration}">
      <failure message="10 &lt; 10" type="REQUIRE">
 current counter 10
@@ -467,6 +480,13 @@ A string sent directly to stderr
      </system-err>
    </testcase>
    <testcase classname="global" name="Some simple comparisons between doubles" time="{duration}"/>
+    <testcase classname="Standard error is reported and redirected" name="Interleaved writes to cerr and clog" time="{duration}">
+      <system-err>
+Write to std::cerr
+Write to std::clog
+Interleaved writes to error streams
+      </system-err>
+    </testcase>
    <testcase classname="Standard output from all sections is reported" name="two" time="{duration}">
      <system-out>
 Message from section one
@@ -742,6 +762,9 @@ hello
    </system-out>
    <system-err>
 A string sent directly to stderr
+Write to std::cerr
+Write to std::clog
+Interleaved writes to error streams
    </system-err>
  </testsuite>
 </testsuites>
--- a/projects/SelfTest/Baselines/xml.sw.approved.txt
+++ b/projects/SelfTest/Baselines/xml.sw.approved.txt
@@ -128,7 +128,7 @@
      </Expression>
      <Expression success="true" type="REQUIRE" filename="projects/<exe-name>/MiscTests.cpp" >
        <Original>
-          (*__error()) == 1
+          errno == 1
        </Original>
        <Expanded>
          1 == 1
@@ -136,6 +136,24 @@
      </Expression>
      <OverallResult success="true"/>
    </TestCase>
+    <TestCase name="#961 -- Dynamically created sections should all be reported" tags="[.][hide]" filename="projects/<exe-name>/MiscTests.cpp" >
+      <Section name="Looped section 0" filename="projects/<exe-name>/MiscTests.cpp" >
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <Section name="Looped section 1" filename="projects/<exe-name>/MiscTests.cpp" >
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <Section name="Looped section 2" filename="projects/<exe-name>/MiscTests.cpp" >
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <Section name="Looped section 3" filename="projects/<exe-name>/MiscTests.cpp" >
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <Section name="Looped section 4" filename="projects/<exe-name>/MiscTests.cpp" >
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResult success="true"/>
+    </TestCase>
    <TestCase name="'Not' checks that should fail" tags="[.][failing][hide]" filename="projects/<exe-name>/ConditionTests.cpp" >
      <Expression success="false" type="CHECK" filename="projects/<exe-name>/ConditionTests.cpp" >
        <Original>
@@ -890,7 +908,7 @@
          a
        </Original>
        <Expanded>
-          true
+          0x<hex digits>
        </Expanded>
      </Expression>
      <Expression success="true" type="REQUIRE" filename="projects/<exe-name>/TrickyTests.cpp" >
@@ -2744,6 +2762,9 @@
          2 == 2
        </Expanded>
      </Expression>
+      <Info>
+        this message may be logged later
+      </Info>
      <Info>
        this message should be logged
      </Info>
@@ -2755,6 +2776,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>
@@ -2766,6 +2793,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>
@@ -4677,7 +4713,7 @@ re>"
          True
        </Original>
        <Expanded>
-          true
+          1
        </Expanded>
      </Expression>
      <Expression success="true" type="CHECK" filename="projects/<exe-name>/TrickyTests.cpp" >
@@ -4693,7 +4729,7 @@ re>"
          !False
        </Original>
        <Expanded>
-          !false
+          !0
        </Expanded>
      </Expression>
      <OverallResult success="true"/>
@@ -6894,6 +6930,17 @@ re>"
      </Section>
      <OverallResult success="true"/>
    </TestCase>
+    <TestCase name="Reconstruction should be based on stringification: #914" tags="[.][Decomposition][failing][hide]" filename="projects/<exe-name>/DecompositionTests.cpp" >
+      <Expression success="false" type="CHECK" filename="projects/<exe-name>/DecompositionTests.cpp" >
+        <Original>
+          truthy(false)
+        </Original>
+        <Expanded>
+          Hey, its truthy!
+        </Expanded>
+      </Expression>
+      <OverallResult success="false"/>
+    </TestCase>
    <TestCase name="SCOPED_INFO is reset for each loop" tags="[.][failing][hide][messages]" filename="projects/<exe-name>/MessageTests.cpp" >
      <Info>
        current counter 0
@@ -7280,6 +7327,24 @@ A string sent directly to stderr
      </Expression>
      <OverallResult success="true"/>
    </TestCase>
+    <TestCase name="Standard error is reported and redirected" tags="[.][hide][messages]" filename="projects/<exe-name>/MessageTests.cpp" >
+      <Section name="std::cerr" filename="projects/<exe-name>/MessageTests.cpp" >
+        <OverallResults successes="0" failures="1" expectedFailures="0"/>
+      </Section>
+      <Section name="std::clog" filename="projects/<exe-name>/MessageTests.cpp" >
+        <OverallResults successes="0" failures="1" expectedFailures="0"/>
+      </Section>
+      <Section name="Interleaved writes to cerr and clog" filename="projects/<exe-name>/MessageTests.cpp" >
+        <OverallResults successes="0" failures="1" expectedFailures="0"/>
+      </Section>
+      <OverallResult success="false">
+        <StdErr>
+Write to std::cerr
+Write to std::clog
+Interleaved writes to error streams
+        </StdErr>
+      </OverallResult>
+    </TestCase>
    <TestCase name="Standard output from all sections is reported" tags="[.][hide][messages]" filename="projects/<exe-name>/MessageTests.cpp" >
      <Section name="one" filename="projects/<exe-name>/MessageTests.cpp" >
        <OverallResults successes="0" failures="1" expectedFailures="0"/>
@@ -10114,7 +10179,7 @@ spanner      <OverallResult success="true"/>
      </Section>
      <OverallResult success="true"/>
    </TestCase>
-    <OverallResults successes="859" failures="90" expectedFailures="21"/>
+    <OverallResults successes="864" failures="94" expectedFailures="21"/>
  </Group>
-  <OverallResults successes="859" failures="89" expectedFailures="21"/>
+  <OverallResults successes="864" failures="93" expectedFailures="21"/>
 </Catch>
--- a/projects/SelfTest/DecompositionTests.cpp
+++ b/projects/SelfTest/DecompositionTests.cpp
@@ -0,0 +1,28 @@
+/*
+ *  Created by Martin on 27/5/2017.
+ *  Copyright 2017 Two Blue Cubes Ltd. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#include <iostream>
+
+struct truthy {
+    truthy(bool b):m_value(b){}
+    operator bool() const {
+        return false;
+    }
+    bool m_value;
+};
+
+std::ostream& operator<<(std::ostream& o, truthy) {
+    o << "Hey, its truthy!";
+    return o;
+}
+
+#include "catch.hpp"
+
+TEST_CASE( "Reconstruction should be based on stringification: #914" , "[Decomposition][failing][.]") {
+    CHECK(truthy(false));
+}
--- a/projects/SelfTest/MessageTests.cpp
+++ b/projects/SelfTest/MessageTests.cpp
@@ -99,6 +99,23 @@ TEST_CASE( "Standard output from all sections is reported", "[messages][.]" )
    }
 }

+TEST_CASE( "Standard error is reported and redirected", "[messages][.]" ) {
+    SECTION( "std::cerr" ) {
+        std::cerr << "Write to std::cerr" << std::endl;
+    }
+    SECTION( "std::clog" ) {
+        std::clog << "Write to std::clog" << std::endl;
+    }
+    SECTION( "Interleaved writes to cerr and clog" ) {
+        std::cerr << "Inter";
+        std::clog << "leaved";
+        std::cerr << ' ';
+        std::clog << "writes";
+        std::cerr << " to error";
+        std::clog << " streams\n";
+    }
+}
+
 TEST_CASE( "SCOPED_INFO is reset for each loop", "[messages][failing][.]" )
 {
    for( int i=0; i<100; i++ )
--- a/projects/SelfTest/MiscTests.cpp
+++ b/projects/SelfTest/MiscTests.cpp
@@ -403,5 +403,13 @@ static int f() {
 TEST_CASE( "#835 -- errno should not be touched by Catch", "[!shouldfail]" ) {
    errno = 1;
    CHECK(f() == 0);
-    REQUIRE(errno == 1); // Check that f() doesn't touch errno.    
+    REQUIRE(errno == 1); // Check that f() doesn't touch errno.
+}
+
+TEST_CASE( "#961 -- Dynamically created sections should all be reported", "[.]" ) {
+    for (char i = '0'; i < '5'; ++i) {
+        SECTION(std::string("Looped section ") + i) {
+            SUCCEED( "Everything is OK" );
+        }
+    }
 }
--- a/projects/SelfTest/ToStringGeneralTests.cpp
+++ b/projects/SelfTest/ToStringGeneralTests.cpp
@@ -9,7 +9,6 @@


 TEST_CASE( "Character pretty printing" ){
-    // 
    SECTION("Specifically escaped"){
        char tab = '\t';
        char newline = '\n';
@@ -36,7 +35,7 @@ TEST_CASE( "Character pretty printing" ){
            char c = static_cast<char>(i);
            REQUIRE(c == i);
        }
-    }    
+    }
 }


--- a/projects/SelfTest/TrickyTests.cpp
+++ b/projects/SelfTest/TrickyTests.cpp
@@ -407,3 +407,9 @@ TEST_CASE( "has printf", "" ) {
    // This can cause problems as, currently, stdout itself is not redirect - only the cout (and cerr) buffer
    printf( "spanner" );
 }
+
+TEST_CASE( "null deref", "[.][failing][!nonportable]" ) {
+    CHECK( false );
+    int *x = NULL;
+    *x = 1;
+}
--- 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
@@ -7,5 +7,7 @@ v = Version()
 v.incrementBuildNumber()
 v.updateVersionFile()
 v.updateReadmeFile()
+v.updateConanFile()
+v.updateConanTestFile()

-print( "Updated Version.hpp and README to v{0}".format( v.getVersionString() ) )
+print( "Updated Version.hpp, README and Conan to v{0}".format( v.getVersionString() ) )
--- a/scripts/majorRelease.py
+++ b/scripts/majorRelease.py
@@ -7,5 +7,7 @@ v = Version()
 v.incrementMajorVersion()
 v.updateVersionFile()
 v.updateReadmeFile()
+v.updateConanFile()
+v.updateConanTestFile()

-print( "Updated Version.hpp and README to v{0}".format( v.getVersionString() ) )
+print( "Updated Version.hpp, README and Conan to v{0}".format( v.getVersionString() ) )
--- a/scripts/minorRelease.py
+++ b/scripts/minorRelease.py
@@ -7,5 +7,7 @@ v = Version()
 v.incrementMinorVersion()
 v.updateVersionFile()
 v.updateReadmeFile()
+v.updateConanFile()
+v.updateConanTestFile()

-print( "Updated Version.hpp and README to v{0}".format( v.getVersionString() ) )
+print( "Updated Version.hpp, README and Conan to v{0}".format( v.getVersionString() ) )
--- a/scripts/patchRelease.py
+++ b/scripts/patchRelease.py
@@ -7,5 +7,7 @@ v = Version()
 v.incrementPatchNumber()
 v.updateVersionFile()
 v.updateReadmeFile()
+v.updateConanFile()
+v.updateConanTestFile()

-print( "Updated Version.hpp and README to v{0}".format( v.getVersionString() ) )
+print( "Updated Version.hpp, README and Conan to v{0}".format( v.getVersionString() ) )
--- a/scripts/releaseCommon.py
+++ b/scripts/releaseCommon.py
@@ -11,6 +11,8 @@ versionParser = re.compile( r'(\s*static\sVersion\sversion)\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" )
+conanPath = os.path.join(catchPath, 'conanfile.py')
+conanTestPath = os.path.join(catchPath, 'test_package', 'conanfile.py')

 class Version:
    def __init__(self):
@@ -86,3 +88,32 @@ class Version:
            line = downloadParser.sub( r'<a href="https://github.com/philsquared/Catch/releases/download/v{0}/catch.hpp">'.format(self.getVersionString()) , line)
            f.write( line + "\n" )

+    def updateConanFile(self):
+        conanParser = re.compile( r'    version = "\d+\.\d+\.\d+.*"')
+        f = open( conanPath, 'r' )
+        lines = []
+        for line in f:
+            m = conanParser.match( line )
+            if m:
+                lines.append( '    version = "{0}"'.format(format(self.getVersionString())) )
+            else:
+                lines.append( line.rstrip() )
+        f.close()
+        f = open( conanPath, 'w' )
+        for line in lines:
+            f.write( line + "\n" )
+
+    def updateConanTestFile(self):
+        conanParser = re.compile( r'    requires = \"Catch\/\d+\.\d+\.\d+.*@%s\/%s\" % \(username, channel\)')
+        f = open( conanTestPath, 'r' )
+        lines = []
+        for line in f:
+            m = conanParser.match( line )
+            if m:
+                lines.append( '    requires = "Catch/{0}@%s/%s" % (username, channel)'.format(format(self.getVersionString())) )
+            else:
+                lines.append( line.rstrip() )
+        f.close()
+        f = open( conanTestPath, 'w' )
+        for line in lines:
+            f.write( line + "\n" )
--- a/scripts/updateVcpkgPackage.py
+++ b/scripts/updateVcpkgPackage.py
@@ -57,24 +57,21 @@ def update_portfile(path, header_hash, licence_hash):
        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
+        # There are three things we need to change/update
+        # 1) CATCH_VERSION cmake variable
+        # 2) Hash of header
+        # 3) 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
+            # Update the version
+            if 'set(CATCH_VERSION' in line:
+                line = 'set(CATCH_VERSION v{})'.format(v.getVersionString())
+
+            # Determine which file 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
+            # Update the hashes
            if 'SHA512' in line and kind == 'HEADER':
                line = '    SHA512 {}\n'.format(header_hash)
            if 'SHA512' in line and kind == 'LICENSE':
@@ -86,8 +83,6 @@ 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
@@ -96,6 +91,7 @@ def git_push(path_to_repo):
    
    # Update repo to current master, so we don't work off old version of the portsfile 
    subprocess.call('git pull Microsoft master', shell=True)
+    subprocess.call('git push', shell=True)

    # Create a new branch for the update
    subprocess.call('git checkout -b catch-{}'.format(ver_string), shell=True)
--- a/single_include/catch.hpp
+++ b/single_include/catch.hpp
@@ -1,6 +1,6 @@
 /*
- *  Catch v1.9.2
- *  Generated: 2017-04-25 10:41:53.040184
+ *  Catch v1.9.7
+ *  Generated: 2017-08-10 23:49:15.233907
 *  ----------------------------------------------------------
 *  This file has been merged from multiple headers. Please don't edit it directly
 *  Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved.
@@ -145,6 +145,11 @@

 #endif

+#ifdef __OS400__
+#       define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
+#       define CATCH_CONFIG_COLOUR_NONE
+#endif
+
 ////////////////////////////////////////////////////////////////////////////////
 // Cygwin
 #ifdef __CYGWIN__
@@ -220,7 +225,7 @@

 // Use __COUNTER__ if the compiler supports it
 #if ( defined _MSC_VER && _MSC_VER >= 1300 ) || \
-    ( defined __GNUC__  && __GNUC__ >= 4 && __GNUC_MINOR__ >= 3 ) || \
+    ( defined __GNUC__  && ( __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3 )) ) || \
    ( defined __clang__ && __clang_major__ >= 3 )

 #define CATCH_INTERNAL_CONFIG_COUNTER
@@ -414,14 +419,14 @@ namespace Catch {
    };

    template<typename ContainerT>
-    inline void deleteAll( ContainerT& container ) {
+    void deleteAll( ContainerT& container ) {
        typename ContainerT::const_iterator it = container.begin();
        typename ContainerT::const_iterator itEnd = container.end();
        for(; it != itEnd; ++it )
            delete *it;
    }
    template<typename AssociativeContainerT>
-    inline void deleteAllValues( AssociativeContainerT& container ) {
+    void deleteAllValues( AssociativeContainerT& container ) {
        typename AssociativeContainerT::const_iterator it = container.begin();
        typename AssociativeContainerT::const_iterator itEnd = container.end();
        for(; it != itEnd; ++it )
@@ -501,7 +506,6 @@ namespace Catch {
    {
    public:
        NotImplementedException( SourceLineInfo const& lineInfo );
-        NotImplementedException( NotImplementedException const& ) {}

        virtual ~NotImplementedException() CATCH_NOEXCEPT {}

@@ -771,7 +775,7 @@ void registerTestCaseFunction
    #define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \
        static void TestName(); \
        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &TestName, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); } \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &TestName, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); } /* NOLINT */ \
        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
        static void TestName()
    #define INTERNAL_CATCH_TESTCASE( ... ) \
@@ -780,7 +784,7 @@ void registerTestCaseFunction
    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); } \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); } /* NOLINT */ \
        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS

    ///////////////////////////////////////////////////////////////////////////////
@@ -790,7 +794,7 @@ void registerTestCaseFunction
            struct TestName : ClassName{ \
                void test(); \
            }; \
-            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &TestName::test, #ClassName, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); \
+            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &TestName::test, #ClassName, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); /* NOLINT */ \
        } \
        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
        void TestName::test()
@@ -800,7 +804,7 @@ void registerTestCaseFunction
    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \
        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
-        Catch::AutoReg( Function, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); \
+        Catch::AutoReg( Function, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); /* NOLINT */ \
        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS

 #else
@@ -808,7 +812,7 @@ void registerTestCaseFunction
    #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 ) ); }\
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &TestName, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) ); } /* NOLINT */ \
        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
        static void TestName()
    #define INTERNAL_CATCH_TESTCASE( Name, Desc ) \
@@ -817,7 +821,7 @@ void registerTestCaseFunction
    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, Name, Desc ) \
        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( Name, Desc ), CATCH_INTERNAL_LINEINFO ); } \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( Name, Desc ), CATCH_INTERNAL_LINEINFO ); } /* NOLINT */ \
        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS

    ///////////////////////////////////////////////////////////////////////////////
@@ -827,7 +831,7 @@ void registerTestCaseFunction
            struct TestCaseName : ClassName{ \
                void test(); \
            }; \
-            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &TestCaseName::test, #ClassName, Catch::NameAndDesc( TestName, Desc ), CATCH_INTERNAL_LINEINFO ); \
+            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &TestCaseName::test, #ClassName, Catch::NameAndDesc( TestName, Desc ), CATCH_INTERNAL_LINEINFO ); /* NOLINT */ \
        } \
        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
        void TestCaseName::test()
@@ -837,7 +841,7 @@ void registerTestCaseFunction
    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, Name, Desc ) \
        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
-        Catch::AutoReg( Function, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) ); \
+        Catch::AutoReg( Function, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) ); /* NOLINT */ \
        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS

 #endif
@@ -927,22 +931,24 @@ namespace Catch {
        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator && ( T const& );
        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator || ( T const& );

-	private:
-		DecomposedExpression& operator = (DecomposedExpression const&);
+    private:
+        DecomposedExpression& operator = (DecomposedExpression const&);
    };

    struct AssertionInfo
    {
-        AssertionInfo() {}
-        AssertionInfo(  std::string const& _macroName,
+        AssertionInfo();
+        AssertionInfo(  char const * _macroName,
                        SourceLineInfo const& _lineInfo,
-                        std::string const& _capturedExpression,
-                        ResultDisposition::Flags _resultDisposition );
+                        char const * _capturedExpression,
+                        ResultDisposition::Flags _resultDisposition,
+                        char const * _secondArg = "");

-        std::string macroName;
+        char const * macroName;
        SourceLineInfo lineInfo;
-        std::string capturedExpression;
+        char const * capturedExpression;
        ResultDisposition::Flags resultDisposition;
+        char const * secondArg;
    };

    struct AssertionResultData
@@ -1156,23 +1162,23 @@ namespace Matchers {
    // This allows the types to be inferred
    // - deprecated: prefer ||, && and !
    template<typename T>
-    inline Impl::MatchNotOf<T> Not( Impl::MatcherBase<T> const& underlyingMatcher ) {
+    Impl::MatchNotOf<T> Not( Impl::MatcherBase<T> const& underlyingMatcher ) {
        return Impl::MatchNotOf<T>( underlyingMatcher );
    }
    template<typename T>
-    inline Impl::MatchAllOf<T> AllOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2 ) {
+    Impl::MatchAllOf<T> AllOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2 ) {
        return Impl::MatchAllOf<T>() && m1 && m2;
    }
    template<typename T>
-    inline Impl::MatchAllOf<T> AllOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2, Impl::MatcherBase<T> const& m3 ) {
+    Impl::MatchAllOf<T> AllOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2, Impl::MatcherBase<T> const& m3 ) {
        return Impl::MatchAllOf<T>() && m1 && m2 && m3;
    }
    template<typename T>
-    inline Impl::MatchAnyOf<T> AnyOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2 ) {
+    Impl::MatchAnyOf<T> AnyOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2 ) {
        return Impl::MatchAnyOf<T>() || m1 || m2;
    }
    template<typename T>
-    inline Impl::MatchAnyOf<T> AnyOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2, Impl::MatcherBase<T> const& m3 ) {
+    Impl::MatchAnyOf<T> AnyOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2, Impl::MatcherBase<T> const& m3 ) {
        return Impl::MatchAnyOf<T>() || m1 || m2 || m3;
    }

@@ -1217,7 +1223,7 @@ namespace Catch {

        template<typename T>
        ResultBuilder& operator << ( T const& value ) {
-            m_stream.oss << value;
+            stream().oss << value;
            return *this;
        }

@@ -1250,11 +1256,27 @@ namespace Catch {
    private:
        AssertionInfo m_assertionInfo;
        AssertionResultData m_data;
-        CopyableStream m_stream;
+
+        CopyableStream &stream()
+        {
+            if(!m_usedStream)
+            {
+                m_usedStream = true;
+                m_stream().oss.str("");
+            }
+            return m_stream();
+        }
+
+        static CopyableStream &m_stream()
+        {
+            static CopyableStream s;
+            return s;
+        }

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

 } // namespace Catch
@@ -1295,7 +1317,7 @@ namespace Internal {
    template<> struct OperatorTraits<IsGreaterThanOrEqualTo>{ static const char* getName(){ return ">="; } };

    template<typename T>
-    inline T& opCast(T const& t) { return const_cast<T&>(t); }
+    T& opCast(T const& t) { return const_cast<T&>(t); }

 // nullptr_t support based on pull request #154 from Konstantin Baumann
 #ifdef CATCH_CONFIG_CPP11_NULLPTR
@@ -1305,7 +1327,7 @@ namespace Internal {
    // So the compare overloads can be operator agnostic we convey the operator as a template
    // enum, which is used to specialise an Evaluator for doing the comparison.
    template<typename T1, typename T2, Operator Op>
-    class Evaluator{};
+    struct Evaluator{};

    template<typename T1, typename T2>
    struct Evaluator<T1, T2, IsEqualTo> {
@@ -1571,7 +1593,7 @@ std::string toString( std::nullptr_t );

 #ifdef __OBJC__
    std::string toString( NSString const * const& nsstring );
-    std::string toString( NSString * CATCH_ARC_STRONG const& nsstring );
+    std::string toString( NSString * CATCH_ARC_STRONG & nsstring );
    std::string toString( NSObject* const& nsObject );
 #endif

@@ -1660,7 +1682,7 @@ namespace Detail {
    std::string rawMemoryToString( const void *object, std::size_t size );

    template<typename T>
-    inline std::string rawMemoryToString( const T& object ) {
+    std::string rawMemoryToString( const T& object ) {
      return rawMemoryToString( &object, sizeof(object) );
    }

@@ -1855,7 +1877,7 @@ public:
    }

    virtual void reconstructExpression( std::string& dest ) const CATCH_OVERRIDE {
-        dest = Catch::toString( m_truthy );
+        dest = Catch::toString( m_lhs );
    }

 private:
@@ -1949,7 +1971,7 @@ private:
 namespace Catch {

    template<typename T>
-    inline ExpressionLhs<T const&> ResultBuilder::operator <= ( T const& operand ) {
+    ExpressionLhs<T const&> ResultBuilder::operator <= ( T const& operand ) {
        return ExpressionLhs<T const&>( *this, operand );
    }

@@ -1958,7 +1980,7 @@ namespace Catch {
    }

    template<typename ArgT, typename MatcherT>
-    inline void ResultBuilder::captureMatch( ArgT const& arg, MatcherT const& matcher,
+    void ResultBuilder::captureMatch( ArgT const& arg, MatcherT const& matcher,
                                             char const* matcherString ) {
        MatchExpression<ArgT const&, MatcherT const&> expr( arg, matcher, matcherString );
        setResultType( matcher.match( arg ) );
@@ -2057,6 +2079,10 @@ namespace Catch {
        virtual void exceptionEarlyReported() = 0;

        virtual void handleFatalErrorCondition( std::string const& message ) = 0;
+
+        virtual bool lastAssertionPassed() = 0;
+        virtual void assertionPassed() = 0;
+        virtual void assertionRun() = 0;
    };

    IResultCapture& getResultCapture();
@@ -2099,9 +2125,9 @@ namespace Catch{
    #if defined(__ppc64__) || defined(__ppc__)
        #define CATCH_TRAP() \
                __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n" \
-                : : : "memory","r0","r3","r4" )
+                : : : "memory","r0","r3","r4" ) /* NOLINT */
    #else
-        #define CATCH_TRAP() __asm__("int $3\n" : : )
+        #define CATCH_TRAP() __asm__("int $3\n" : : /* NOLINT */ )
    #endif

 #elif defined(CATCH_PLATFORM_LINUX)
@@ -2109,7 +2135,7 @@ namespace Catch{
    // directly at the location of the failing check instead of breaking inside
    // raise() called from it, i.e. one stack frame below.
    #if defined(__GNUC__) && (defined(__i386) || defined(__x86_64))
-        #define CATCH_TRAP() asm volatile ("int $3")
+        #define CATCH_TRAP() asm volatile ("int $3") /* NOLINT */
    #else // Fall back to the generic way.
        #include <signal.h>

@@ -2204,12 +2230,12 @@ namespace Catch {
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_IF( macroName, resultDisposition, expr ) \
    INTERNAL_CATCH_TEST( macroName, resultDisposition, expr ); \
-    if( Catch::getResultCapture().getLastResult()->succeeded() )
+    if( Catch::getResultCapture().lastAssertionPassed() )

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

 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, expr ) \
@@ -2272,7 +2298,7 @@ namespace Catch {
            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(); \
@@ -2769,13 +2795,6 @@ namespace Detail {
            m_value( value )
        {}

-        Approx( Approx const& other )
-        :   m_epsilon( other.m_epsilon ),
-            m_margin( other.m_margin ),
-            m_scale( other.m_scale ),
-            m_value( other.m_value )
-        {}
-
        static Approx custom() {
            return Approx( 0 );
        }
@@ -3490,16 +3509,16 @@ return @ desc; \
 #include <crtdbg.h>
 class LeakDetector {
 public:
-	LeakDetector() {
-		int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
-		flag |= _CRTDBG_LEAK_CHECK_DF;
-		flag |= _CRTDBG_ALLOC_MEM_DF;
-		_CrtSetDbgFlag(flag);
-		_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
-		_CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
-		// Change this to leaking allocation's number to break there
-		_CrtSetBreakAlloc(-1);
-	}
+    LeakDetector() {
+        int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
+        flag |= _CRTDBG_LEAK_CHECK_DF;
+        flag |= _CRTDBG_ALLOC_MEM_DF;
+        _CrtSetDbgFlag(flag);
+        _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
+        _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
+        // Change this to leaking allocation's number to break there
+        _CrtSetBreakAlloc(-1);
+    }
 };
 #else
 class LeakDetector {};
@@ -3699,7 +3718,7 @@ namespace Catch {
        ITagAliasRegistry const* m_tagAliases;

    public:
-        TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {}
+        TestSpecParser( ITagAliasRegistry const& tagAliases ) :m_mode(None), m_exclusion(false), m_start(0), m_pos(0), m_tagAliases( &tagAliases ) {}

        TestSpecParser& parse( std::string const& arg ) {
            m_mode = None;
@@ -3883,6 +3902,7 @@ namespace Catch {

    std::ostream& cout();
    std::ostream& cerr();
+    std::ostream& clog();

    struct IStream {
        virtual ~IStream() CATCH_NOEXCEPT;
@@ -3938,6 +3958,7 @@ namespace Catch {
            listTags( false ),
            listReporters( false ),
            listTestNamesOnly( false ),
+            listExtraInfo( false ),
            showSuccessfulTests( false ),
            shouldDebugBreak( false ),
            noThrow( false ),
@@ -3957,6 +3978,7 @@ namespace Catch {
        bool listTags;
        bool listReporters;
        bool listTestNamesOnly;
+        bool listExtraInfo;

        bool showSuccessfulTests;
        bool shouldDebugBreak;
@@ -4015,6 +4037,7 @@ namespace Catch {
        bool listTestNamesOnly() const { return m_data.listTestNamesOnly; }
        bool listTags() const { return m_data.listTags; }
        bool listReporters() const { return m_data.listReporters; }
+        bool listExtraInfo() const { return m_data.listExtraInfo; }

        std::string getProcessName() const { return m_data.processName; }

@@ -4212,7 +4235,7 @@ namespace Tbc {
            return oss.str();
        }

-        inline friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) {
+        friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) {
            for( Text::const_iterator it = _text.begin(), itEnd = _text.end();
                it != itEnd; ++it ) {
                if( it != _text.begin() )
@@ -5276,6 +5299,10 @@ namespace Catch {
            .describe( "list all/matching test cases names only" )
            .bind( &ConfigData::listTestNamesOnly );

+        cli["--list-extra-info"]
+            .describe( "list all/matching test cases with more info" )
+            .bind( &ConfigData::listExtraInfo );
+
        cli["--list-reporters"]
            .describe( "list all reporters" )
            .bind( &ConfigData::listReporters );
@@ -5804,8 +5831,9 @@ namespace Catch {
        }

        std::size_t matchedTests = 0;
-        TextAttributes nameAttr, tagsAttr;
+        TextAttributes nameAttr, descAttr, tagsAttr;
        nameAttr.setInitialIndent( 2 ).setIndent( 4 );
+        descAttr.setIndent( 4 );
        tagsAttr.setIndent( 6 );

        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
@@ -5820,6 +5848,13 @@ namespace Catch {
            Colour colourGuard( colour );

            Catch::cout() << Text( testCaseInfo.name, nameAttr ) << std::endl;
+            if( config.listExtraInfo() ) {
+                Catch::cout() << "    " << testCaseInfo.lineInfo << std::endl;
+                std::string description = testCaseInfo.description;
+                if( description.empty() )
+                    description = "(NO DESCRIPTION)";
+                Catch::cout() << Text( description, descAttr ) << std::endl;
+            }
            if( !testCaseInfo.tags.empty() )
                Catch::cout() << Text( testCaseInfo.tagsAsString, tagsAttr ) << std::endl;
        }
@@ -5843,9 +5878,12 @@ namespace Catch {
            matchedTests++;
            TestCaseInfo const& testCaseInfo = it->getTestCaseInfo();
            if( startsWith( testCaseInfo.name, '#' ) )
-               Catch::cout() << '"' << testCaseInfo.name << '"' << std::endl;
+               Catch::cout() << '"' << testCaseInfo.name << '"';
            else
-               Catch::cout() << testCaseInfo.name << std::endl;
+               Catch::cout() << testCaseInfo.name;
+            if ( config.listExtraInfo() )
+                Catch::cout() << "\t@" << testCaseInfo.lineInfo;
+            Catch::cout() << std::endl;
        }
        return matchedTests;
    }
@@ -5937,7 +5975,7 @@ namespace Catch {

    inline Option<std::size_t> list( Config const& config ) {
        Option<std::size_t> listedCount;
-        if( config.listTests() )
+        if( config.listTests() || ( config.listExtraInfo() && !config.listTestNamesOnly() ) )
            listedCount = listedCount.valueOr(0) + listTests( config );
        if( config.listTestNamesOnly() )
            listedCount = listedCount.valueOr(0) + listTestsNamesOnly( config );
@@ -6549,6 +6587,29 @@ namespace Catch {
        std::string& m_targetString;
    };

+    // StdErr has two constituent streams in C++, std::cerr and std::clog
+    // This means that we need to redirect 2 streams into 1 to keep proper
+    // order of writes and cannot use StreamRedirect on its own
+    class StdErrRedirect {
+    public:
+        StdErrRedirect(std::string& targetString)
+        :m_cerrBuf( cerr().rdbuf() ), m_clogBuf(clog().rdbuf()),
+        m_targetString(targetString){
+            cerr().rdbuf(m_oss.rdbuf());
+            clog().rdbuf(m_oss.rdbuf());
+        }
+        ~StdErrRedirect() {
+            m_targetString += m_oss.str();
+            cerr().rdbuf(m_cerrBuf);
+            clog().rdbuf(m_clogBuf);
+        }
+    private:
+        std::streambuf* m_cerrBuf;
+        std::streambuf* m_clogBuf;
+        std::ostringstream m_oss;
+        std::string& m_targetString;
+    };
+
    ///////////////////////////////////////////////////////////////////////////

    class RunContext : public IResultCapture, public IRunner {
@@ -6642,14 +6703,32 @@ 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 );
+            m_lastAssertionInfo = AssertionInfo( "", m_lastAssertionInfo.lineInfo, "{Unknown expression after the reported line}" , m_lastAssertionInfo.resultDisposition );
            m_lastResult = result;
        }

+        virtual bool lastAssertionPassed()
+        {
+            return m_totals.assertions.passed == (m_prevPassed + 1);
+        }
+
+        virtual void assertionPassed()
+        {
+            m_totals.assertions.passed++;
+            m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}";
+            m_lastAssertionInfo.macroName = "";
+        }
+
+        virtual void assertionRun()
+        {
+            m_prevPassed = m_totals.assertions.passed;
+        }
+
        virtual bool sectionStarted (
            SectionInfo const& sectionInfo,
            Counts& assertions
@@ -6750,6 +6829,7 @@ namespace Catch {

            Totals deltaTotals;
            deltaTotals.testCases.failed = 1;
+            deltaTotals.assertions.failed = 1;
            m_reporter->testCaseEnded( TestCaseStats(   testInfo,
                                                        deltaTotals,
                                                        std::string(),
@@ -6776,7 +6856,7 @@ namespace Catch {
            double duration = 0;
            m_shouldReportUnexpected = true;
            try {
-                m_lastAssertionInfo = AssertionInfo( "TEST_CASE", testCaseInfo.lineInfo, std::string(), ResultDisposition::Normal );
+                m_lastAssertionInfo = AssertionInfo( "TEST_CASE", testCaseInfo.lineInfo, "", ResultDisposition::Normal );

                seedRng( *m_config );

@@ -6784,7 +6864,7 @@ namespace Catch {
                timer.start();
                if( m_reporter->getPreferences().shouldRedirectStdOut ) {
                    StreamRedirect coutRedir( Catch::cout(), redirectedCout );
-                    StreamRedirect cerrRedir( Catch::cerr(), redirectedCerr );
+                    StdErrRedirect errRedir( redirectedCerr );
                    invokeActiveTestCase();
                }
                else {
@@ -6828,9 +6908,9 @@ namespace Catch {
    private:

        ResultBuilder makeUnexpectedResultBuilder() const {
-            return ResultBuilder(   m_lastAssertionInfo.macroName.c_str(),
+            return ResultBuilder(   m_lastAssertionInfo.macroName,
                                    m_lastAssertionInfo.lineInfo,
-                                    m_lastAssertionInfo.capturedExpression.c_str(),
+                                    m_lastAssertionInfo.capturedExpression,
                                    m_lastAssertionInfo.resultDisposition );
        }

@@ -6860,6 +6940,7 @@ namespace Catch {
        std::vector<SectionEndInfo> m_unfinishedSections;
        std::vector<ITracker*> m_activeSections;
        TrackerContext m_trackerContext;
+        size_t m_prevPassed;
        bool m_shouldReportUnexpected;
    };

@@ -6918,10 +6999,14 @@ namespace Catch {
        return reporter;
    }

+#if !defined(CATCH_CONFIG_DEFAULT_REPORTER)
+#define CATCH_CONFIG_DEFAULT_REPORTER "console"
+#endif
+
    Ptr<IStreamingReporter> makeReporter( Ptr<Config> const& config ) {
        std::vector<std::string> reporters = config->getReporterNames();
        if( reporters.empty() )
-            reporters.push_back( "console" );
+            reporters.push_back( CATCH_CONFIG_DEFAULT_REPORTER );

        Ptr<IStreamingReporter> reporter;
        for( std::vector<std::string>::const_iterator it = reporters.begin(), itEnd = reporters.end();
@@ -6981,11 +7066,11 @@ namespace Catch {
            if( lastSlash != std::string::npos )
                filename = filename.substr( lastSlash+1 );

-            std::string::size_type lastDot = filename.find_last_of( "." );
+            std::string::size_type lastDot = filename.find_last_of( '.' );
            if( lastDot != std::string::npos )
                filename = filename.substr( 0, lastDot );

-            tags.insert( "#" + filename );
+            tags.insert( '#' + filename );
            setTags( test, tags );
        }
    }
@@ -7052,6 +7137,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;
@@ -7611,6 +7722,9 @@ namespace Catch {
    std::ostream& cerr() {
        return std::cerr;
    }
+    std::ostream& clog() {
+        return std::clog;
+    }
 #endif
 }

@@ -7981,14 +8095,18 @@ namespace Catch {

 namespace Catch {

-    AssertionInfo::AssertionInfo(   std::string const& _macroName,
+    AssertionInfo::AssertionInfo():macroName(""), capturedExpression(""), resultDisposition(ResultDisposition::Normal), secondArg(""){}
+
+    AssertionInfo::AssertionInfo(   char const * _macroName,
                                    SourceLineInfo const& _lineInfo,
-                                    std::string const& _capturedExpression,
-                                    ResultDisposition::Flags _resultDisposition )
+                                    char const * _capturedExpression,
+                                    ResultDisposition::Flags _resultDisposition,
+                                    char const * _secondArg)
    :   macroName( _macroName ),
        lineInfo( _lineInfo ),
        capturedExpression( _capturedExpression ),
-        resultDisposition( _resultDisposition )
+        resultDisposition( _resultDisposition ),
+        secondArg( _secondArg )
    {}

    AssertionResult::AssertionResult() {}
@@ -8015,24 +8133,30 @@ namespace Catch {
    }

    bool AssertionResult::hasExpression() const {
-        return !m_info.capturedExpression.empty();
+        return m_info.capturedExpression[0] != 0;
    }

    bool AssertionResult::hasMessage() const {
        return !m_resultData.message.empty();
    }

+    std::string capturedExpressionWithSecondArgument( char const * capturedExpression, char const * secondArg ) {
+        return (secondArg[0] == 0 || secondArg[0] == '"' && secondArg[1] == '"')
+            ? capturedExpression
+            : std::string(capturedExpression) + ", " + secondArg;
+    }
+
    std::string AssertionResult::getExpression() const {
        if( isFalseTest( m_info.resultDisposition ) )
-            return '!' + m_info.capturedExpression;
+            return '!' + capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg);
        else
-            return m_info.capturedExpression;
+            return capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg);
    }
    std::string AssertionResult::getExpressionInMacro() const {
-        if( m_info.macroName.empty() )
-            return m_info.capturedExpression;
+        if( m_info.macroName[0] == 0 )
+            return capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg);
        else
-            return m_info.macroName + "( " + m_info.capturedExpression + " )";
+            return std::string(m_info.macroName) + "( " + capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg) + " )";
    }

    bool AssertionResult::hasExpandedExpression() const {
@@ -8282,7 +8406,7 @@ namespace Catch {
    }

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

@@ -8468,21 +8592,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
    }
@@ -8634,6 +8758,10 @@ namespace Catch {
        m_timer.start();
    }

+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4996) // std::uncaught_exception is deprecated in C++17
+#endif
    Section::~Section() {
        if( m_sectionIncluded ) {
            SectionEndInfo endInfo( m_info, m_assertions, m_timer.getElapsedSeconds() );
@@ -8643,6 +8771,9 @@ namespace Catch {
                getResultCapture().sectionEnded( endInfo );
        }
    }
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif

    // This indicates whether the section should be executed or not
    Section::operator bool() const {
@@ -8958,7 +9089,7 @@ std::string toString( std::nullptr_t ) {
            return "nil";
        return "@" + toString([nsstring UTF8String]);
    }
-    std::string toString( NSString * CATCH_ARC_STRONG const& nsstring ) {
+    std::string toString( NSString * CATCH_ARC_STRONG & nsstring ) {
        if( !nsstring )
            return "nil";
        return "@" + toString([nsstring UTF8String]);
@@ -8975,26 +9106,22 @@ std::string toString( std::nullptr_t ) {

 namespace Catch {

-    std::string capturedExpressionWithSecondArgument( std::string const& capturedExpression, std::string const& secondArg ) {
-        return secondArg.empty() || secondArg == "\"\""
-            ? capturedExpression
-            : capturedExpression + ", " + secondArg;
-    }
    ResultBuilder::ResultBuilder(   char const* macroName,
                                    SourceLineInfo const& lineInfo,
                                    char const* capturedExpression,
                                    ResultDisposition::Flags resultDisposition,
                                    char const* secondArg )
-    :   m_assertionInfo( macroName, lineInfo, capturedExpressionWithSecondArgument( capturedExpression, secondArg ), resultDisposition ),
+    :   m_assertionInfo( macroName, lineInfo, capturedExpression, resultDisposition, secondArg ),
        m_shouldDebugBreak( false ),
        m_shouldThrow( false ),
-        m_guardException( false )
+        m_guardException( false ),
+        m_usedStream( false )
    {}

    ResultBuilder::~ResultBuilder() {
 #if defined(CATCH_CONFIG_FAST_COMPILE)
        if ( m_guardException ) {
-            m_stream.oss << "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE";
+            stream().oss << "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE";
            captureResult( ResultWas::ThrewException );
            getCurrentContext().getResultCapture()->exceptionEarlyReported();
        }
@@ -9011,13 +9138,25 @@ namespace Catch {
    }

    void ResultBuilder::endExpression( DecomposedExpression const& expr ) {
-        AssertionResult result = build( expr );
-        handleResult( result );
+        // Flip bool results if FalseTest flag is set
+        if( isFalseTest( m_assertionInfo.resultDisposition ) ) {
+            m_data.negate( expr.isBinaryExpression() );
+        }
+
+        getResultCapture().assertionRun();
+
+        if(getCurrentContext().getConfig()->includeSuccessfulResults() || m_data.resultType != ResultWas::Ok)
+        {
+            AssertionResult result = build( expr );
+            handleResult( result );
+        }
+        else
+            getResultCapture().assertionPassed();
    }

    void ResultBuilder::useActiveException( ResultDisposition::Flags resultDisposition ) {
        m_assertionInfo.resultDisposition = resultDisposition;
-        m_stream.oss << Catch::translateActiveException();
+        stream().oss << Catch::translateActiveException();
        captureResult( ResultWas::ThrewException );
    }

@@ -9038,7 +9177,7 @@ namespace Catch {
        assert( !isFalseTest( m_assertionInfo.resultDisposition ) );
        AssertionResultData data = m_data;
        data.resultType = ResultWas::Ok;
-        data.reconstructedExpression = m_assertionInfo.capturedExpression;
+        data.reconstructedExpression = capturedExpressionWithSecondArgument(m_assertionInfo.capturedExpression, m_assertionInfo.secondArg);

        std::string actualMessage = Catch::translateActiveException();
        if( !matcher.match( actualMessage ) ) {
@@ -9099,18 +9238,14 @@ namespace Catch {
        assert( m_data.resultType != ResultWas::Unknown );
        AssertionResultData data = m_data;

-        // Flip bool results if FalseTest flag is set
-        if( isFalseTest( m_assertionInfo.resultDisposition ) ) {
-            data.negate( expr.isBinaryExpression() );
-        }
-
-        data.message = m_stream.oss.str();
+        if(m_usedStream)
+            data.message = m_stream().oss.str();
        data.decomposedExpression = &expr; // for lazy reconstruction
        return AssertionResult( m_assertionInfo, data );
    }

    void ResultBuilder::reconstructExpression( std::string& dest ) const {
-        dest = m_assertionInfo.capturedExpression;
+        dest = capturedExpressionWithSecondArgument(m_assertionInfo.capturedExpression, m_assertionInfo.secondArg);
    }

    void ResultBuilder::setExceptionGuard() {
@@ -9533,7 +9668,8 @@ namespace Catch {
            BySectionInfo( SectionInfo const& other ) : m_other( other ) {}
            BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {}
            bool operator() ( Ptr<SectionNode> const& node ) const {
-                return node->stats.sectionInfo.lineInfo == m_other.lineInfo;
+                return ((node->stats.sectionInfo.name == m_other.name) &&
+                        (node->stats.sectionInfo.lineInfo == m_other.lineInfo));
            }
        private:
            void operator=( BySectionInfo const& );
@@ -10001,20 +10137,6 @@ namespace Catch {
    };

 }
-// #included from: catch_reenable_warnings.h
-
-#define TWOBLUECUBES_CATCH_REENABLE_WARNINGS_H_INCLUDED
-
-#ifdef __clang__
-#    ifdef __ICC // icpc defines the __clang__ macro
-#        pragma warning(pop)
-#    else
-#        pragma clang diagnostic pop
-#    endif
-#elif defined __GNUC__
-#    pragma GCC diagnostic pop
-#endif
-

 namespace Catch {
    class XmlReporter : public StreamingReporterBase {
@@ -10269,6 +10391,7 @@ namespace Catch {
        JunitReporter( ReporterConfig const& _config )
        :   CumulativeReporterBase( _config ),
            xml( _config.stream() ),
+            unexpectedExceptions( 0 ),
            m_okToFail( false )
        {
            m_reporterPrefs.shouldRedirectStdOut = true;
@@ -11268,9 +11391,15 @@ namespace Catch {

 #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[]) {
-	int result = Catch::Session().run( argc, argv );
+#endif
+
+    int result = Catch::Session().run( argc, argv );
    return ( result < 0xff ? result : 0xff );
 }

@@ -11349,7 +11478,7 @@ int main (int argc, char * const argv[]) {
    #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( ... ) 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
@@ -11471,5 +11600,19 @@ int main (int argc, char * const argv[]) {

 using Catch::Detail::Approx;

+// #included from: internal/catch_reenable_warnings.h
+
+#define TWOBLUECUBES_CATCH_REENABLE_WARNINGS_H_INCLUDED
+
+#ifdef __clang__
+#    ifdef __ICC // icpc defines the __clang__ macro
+#        pragma warning(pop)
+#    else
+#        pragma clang diagnostic pop
+#    endif
+#elif defined __GNUC__
+#    pragma GCC diagnostic pop
+#endif
+
 #endif // TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED

--- a/test_package/CMakeLists.txt
+++ b/test_package/CMakeLists.txt
@@ -0,0 +1,7 @@
+cmake_minimum_required(VERSION 3.0)
+project(CatchTest CXX)
+
+include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
+conan_basic_setup()
+
+add_executable(${CMAKE_PROJECT_NAME} MainTest.cpp)
--- a/test_package/MainTest.cpp
+++ b/test_package/MainTest.cpp
@@ -0,0 +1,21 @@
+/*
+ *  Created by Phil on 22/10/2010.
+ *  Copyright 2010 Two Blue Cubes Ltd
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"
+
+unsigned int Factorial( unsigned int number ) {
+  return number > 1 ? Factorial(number-1)*number : 1;
+}
+
+TEST_CASE( "Factorials are computed", "[factorial]" ) {
+    REQUIRE( Factorial(0) == 1 );
+    REQUIRE( Factorial(1) == 1 );
+    REQUIRE( Factorial(2) == 2 );
+    REQUIRE( Factorial(3) == 6 );
+    REQUIRE( Factorial(10) == 3628800 );
+}
--- a/test_package/conanfile.py
+++ b/test_package/conanfile.py
@@ -0,0 +1,21 @@
+#!/usr/bin/env python
+from os import getenv
+from os import path
+from conans import ConanFile
+from conans import CMake
+
+
+class CatchConanTest(ConanFile):
+    generators = "cmake"
+    settings = "os", "compiler", "arch", "build_type"
+    username = getenv("CONAN_USERNAME", "philsquared")
+    channel = getenv("CONAN_CHANNEL", "testing")
+    requires = "Catch/1.9.7@%s/%s" % (username, channel)
+
+    def build(self):
+        cmake = CMake(self)
+        cmake.configure(build_dir="./")
+        cmake.build()
+
+    def test(self):
+        self.run(path.join("bin", "CatchTest"))
Author	SHA1	Message	Date
Martin Hořeňovský	2ce6c74f8f	v1.9.7	2017-08-11 00:01:20 +02:00
Phil Nash	9688891868	Fix issue with fatal errors and non-failing assertions Fixes #990	2017-08-10 21:44:54 +02:00
Martin Hořeňovský	4f21bb72ff	Add tests for #961	2017-08-10 21:38:07 +02:00
Martin Hořeňovský	b435e0d7c7	Make default reporter configurable at compile time Closes #978	2017-08-10 16:45:38 +02:00
Martin Hořeňovský	ba0a09fd9e	Update documentation with changes from `7e4038d`	2017-08-10 16:43:17 +02:00
Martin Hořeňovský	7e4038d848	Capture std::clog writes and combine them with std::cerr writes (#989 ) This also introduces Catch::clog() method to allow embedded targets to override std::clog usage with their own stream (presumably null-sink), similarly to how Catch::cout() and Catch::cerr() are used. Fixes #989	2017-08-09 15:28:40 +02:00
Martin Hořeňovský	92d714ee12	Update `updateVcpkgPackage` script for the new port format	2017-08-08 23:04:39 +02:00
Martin Hořeňovský	705a1bf527	Add wandbox to release process documentation Also some formatting and wording changes.	2017-08-08 23:04:10 +02:00
Cody Han	d5613fb18a	Update matchers docs to reflect namespace usage	2017-08-03 19:11:21 +02:00
Martin Hořeňovský	62875c857e	Add a landing page link to wandbox with catch preloaded Idea shamelessly stolen from nlohmann/json	2017-08-01 23:45:35 +02:00
Danila Sukharev	ec2074e558	Adding more flexibility into the cmake catch parsing script (#971 ) * Adding more flexibility into the cmake catch parsing script	2017-08-01 17:33:53 +02:00
Martin Hořeňovský	7575749e56	Fix compilation error on older compilers	2017-08-01 17:21:06 +02:00
Martin Hořeňovský	8a2ff20982	Address some of the Resharper finds for Catch 1 Closes #957 as the other findings are mostly noise that is pointless to fix in a branch that will be soon EoLd.	2017-07-31 12:31:45 +02:00
Anton Vorobyev	d3377c791d	Initial support for native IBM i ILE C++ (#976 ) * - Initial support for native IBM i ILE C++ Signed-off-by: zeromem <zeromem2@gmail.com>	2017-07-31 10:47:42 +02:00
Martin Hořeňovský	c5dfa73d56	Disable build broken by travis changes It should be reenabled later, but I don't have time to investigate right now.	2017-07-29 08:45:52 +02:00
Fran García Salomón	d65091fa06	Fix for JUnit reporter when using dynamically generated sections (#963 ) * BySectionInfo should also take into account the section name in addition to the source code line	2017-07-23 17:13:44 +02:00
Martin Hořeňovský	7a22bad763	Addressed some static analysis warnings Based on findings in #957	2017-07-19 09:50:08 +02:00
Phil Nash	8ebe94ca2e	Added NOLINT annotations to selectively suppress clang_tidy warnings	2017-07-10 18:43:07 +01:00
Martin Hořeňovský	106d7e2a74	Initialize JunitReporter::unexpectedExceptions in constructor This is not needed for correctness, but will prevent PVS warning from triggering, and there is basically no performance difference. Closes #951	2017-07-10 10:30:17 +02:00
Neal Coombes	a53ea30723	Eliminate some work when results won't be reported.	2017-07-07 01:34:12 +02:00
Ivan Kush	8d380a7399	added 'args' argument parser library	2017-07-05 15:55:28 +02:00
Martin Hořeňovský	3083de9ea6	Fix typo in README	2017-07-05 15:54:38 +02:00
Phil Nash	431e8d06e7	Added survey monkey link	2017-07-04 09:10:36 +01:00
Markus Werle	6f32db35af	Update tutorial.md	2017-06-28 20:54:31 +02:00
Uilian Ries	7013e388f7	#926 Update Conan test version by release Signed-off-by: Uilian Ries <uilianries@gmail.com>	2017-06-28 16:45:42 +01:00
Phil Nash	0270afb21b	Updated license	2017-06-28 16:44:46 +01:00
Phil Nash	df7c5622b9	Merge branch 'feature/conan' of https://github.com/uilianries/Catch	2017-06-27 11:48:55 +01:00
Martin Hořeňovský	ee67ac6b7c	v1.9.6	2017-06-27 12:21:48 +02:00
Baruch Burstein	8a14af701e	If --list-extra-info is specified with --list-test-names-only, only output one list	2017-06-25 17:12:29 +02:00
Martin Hořeňovský	07c6bfc3b9	--extra-info -> --list-extra-info, behaves like other --list-* flags	2017-06-25 17:12:29 +02:00
Baruch Burstein	616f7235ef	add --extra-info flag this will add line info to test lists, and test descriptions to the long form of the test list	2017-06-25 17:12:29 +02:00
Neal Coombes	396ecf6021	Cache std::ostringstream between assertions. This is not thread safe, but I think that was already true of Catch. The construction/destruction of the std::ostringstream is where the vast majority of time is spent per assertion. A simple test of 100000000 CHECK()s is reduced from around 60s to 7.4s	2017-06-25 15:53:59 +02:00
Uilian Ries	3491804598	#926 Update Conan version by release - Update release scripts to increment Conan version Signed-off-by: Uilian Ries <uilianries@gmail.com>	2017-06-23 16:03:36 -03:00
Uilian Ries	6234e3d54d	#926 Conan recipe for Catch single header - Insert catch.hpp (single header) to package - Copy BDDTests and TrickyTest to validate Catch package Signed-off-by: Uilian Ries <uilianries@gmail.com>	2017-06-23 10:34:56 -03:00
Martin Hořeňovský	a6cdcd43aa	Added "How to test changes in PR" section to documentation Also linked it from PR template. Closes #936	2017-06-22 18:56:10 +02:00
Neal Coombes	dcab8a5971	Performance improvement in AssertionInfo. By using char const * instead of std::string we avoid significant copying per assertion. In a simple loop with 10000000 CHECKS on my system, this reduces the run time from 9.8s to 6s.	2017-06-22 18:03:47 +02:00
Martin Hořeňovský	017a63da62	v1.9.5	2017-06-15 13:08:26 +02:00
Martin Hořeňovský	b90d0b7267	Disable deprecation warning of std::uncaught_exception We might prefer to use `std::uncaught_exceptions` in the future, but I would prefer not to bring in more configuration into Catch Classic Closes #927	2017-06-15 11:43:31 +02:00
Martin Hořeňovský	efba988ccc	Fix how GCC version is detected when checking for __COUNTER__ Fixes #928	2017-06-13 18:20:59 +02:00
Phil Nash	004228efb2	Merge pull request #855 from kainjow/objc-tostring-link Fix Catch::toString() linker error when main() is compiled as C++	2017-06-11 23:06:38 +01:00
Martin Hořeňovský	e0aaba6cf8	Actually link #923 from the documentation	2017-06-06 16:46:46 +02:00
Martin Hořeňovský	a09bef23ed	Refer to #923 in reporter documentation	2017-06-06 16:43:14 +02:00
Martin Hořeňovský	3e018ef131	Add link to external gcov/lcov example to documentation An alternate take on #916, that better slots into the existing documentation. Closes #916	2017-06-04 12:17:59 +02:00
Martin Hořeňovský	adb66f55a7	Don't include warning headers from catch_xmlwriter.hpp This prevents Catch from disabling `Wpadded` for Clang inside test files (files that do not define either `CATCH_CONFIG_MAIN` or `CATCH_CONFIG_RUNNER`). catch_suppress_warnings.h and catch_reenable_warnings.h should be included only once, so that the stitching script includes them as the first and last header respectively, since it only includes each header once. This caused a bug, where the first one was included properly, but the second one was included prematurely, from catch_xmlwriter.hpp, and thus was guarded by `CATCH_IMPL`. At least until the stitching script is changed to accomodate common warning disabling header. Fixes #871	2017-06-02 19:10:57 +02:00
Martin Hořeňovský	377c9a746d	Cosmetic fixes (whitespace and spelling)	2017-05-27 14:42:54 +02:00
Martin Hořeňovský	ea48ae0f75	Add test for #914 (stringify truthy exprs in standard way)	2017-05-27 14:42:05 +02:00
twhittock	2d1739b429	ExpressionLhs reconstruction based on value, not truthiness (#914 ) Types which are truthy, but have more information than the truthiness in their string conversion were showing up as 'true' or 'false' instead of showing the underlying type's string value.	2017-05-27 14:09:43 +02:00
Martin Hořeňovský	1c59034be4	Merge pull request #911 from dvirtz/master CTest integration script enhancements	2017-05-27 13:52:55 +02:00
Martin Hořeňovský	52a84788e0	Add Inscopix to commercial users Closes #918	2017-05-27 12:23:35 +02:00
Martin Hořeňovský	3e328f55fc	Merge pull request #913 from Carrotstrip/master fixed spelling error in tutorial.md	2017-05-21 11:17:25 +02:00
Austin L Wolfgram	b18e67522f	fixed spelling error	2017-05-20 15:10:42 -04:00
dvirtz	4b086bd5b5	added target name to test name and labels	2017-05-18 16:00:18 +03:00
dvirtz	aac594aae3	add option to print debug messages	2017-05-18 15:53:35 +03:00
dvirtz	a49fa0edbe	use absolute path to test files - accroding to CMake docs EXISTS behavior is well-defined only for full paths.	2017-05-18 15:51:44 +03:00
Martin Hořeňovský	d271683c14	Added release process notes/checklist/explanation	2017-05-16 21:33:58 +02:00
Martin Hořeňovský	0bb8e1247e	Merge branch 'master' of https://github.com/awglyde/Catch	2017-05-16 16:09:51 +02:00
Martin Hořeňovský	32d97caf42	Fixed missing ` in tag documentation	2017-05-16 15:45:44 +02:00
Martin Hořeňovský	bc93b29789	Expanded tag documentation It now mentions that most characters are valid as part of tag and other details. Closes #909	2017-05-16 15:28:53 +02:00
Martin Hořeňovský	df5cf2d323	Minor fixup in updateVcpkgPackage.py	2017-05-16 14:34:55 +02:00
Martin Hořeňovský	b62c0256b2	Merge branch 'master' of https://github.com/philsquared/Catch	2017-05-16 14:34:27 +02:00
Martin Hořeňovský	1ea84cb734	Expanded logging documentation Closes #884	2017-05-16 14:34:20 +02:00
Martin Hořeňovský	2a5d3736e8	Merge pull request #908 from pJunger/patch-1 Typo: Added namespace in method testCaseEnded	2017-05-16 14:05:31 +02:00
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
Patrick Junger	d4e0b1d093	Added namespace in method testCaseEnded Did not compile as is	2017-05-14 14:11:47 +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
Kevin Wojniak	e8b31108d6	Fix Catch::toString() linker error when main() is compiled as C++ Fixes #278	2017-03-14 11:54:14 -07:00
Alex Glyde	d8f45cd5f1	changing tabs to spaces	2017-03-06 10:55:00 -05:00
Alex Glyde	3afd077b55	teamcity reporter should time durations explicitly	2017-03-06 10:35:03 -05:00