Big merge from Integration

- now v1.0 build 1

.gitignore

@@ -15,7 +15,10 @@ projects/VS2010/TestCatch/_UpgradeReport_Files/
 projects/VS2010/TestCatch/TestCatch/TestCatch.vcxproj.filters
 projects/VisualStudio/TestCatch/UpgradeLog.XML
 UpgradeLog.XML
+projects/XCode4/iOSTest/Build/Intermediates/PrecompiledHeaders
+projects/XCode4/iOSTest/Build/Products/Debug-iphonesimulator/iOSTest.app.dSYM/Contents/Resources/DWARF
+projects/XCode4/iOSTest/Build
 projects/XCode4/CatchSelfTest/DerivedData
 projects/XCode4/OCTest/DerivedData
-projects/XCode4/iOSTest/Build
+*.pyc
 projects/XCode4/iOSTest/DerivedData

README

@@ -1,7 +0,0 @@
-CATCH is an automated test framework for C, C++ and Objective-C.
-
-The latest stable version can be found here: https://raw.github.com/philsquared/Catch/master/single_include/catch.hpp
-
-For documentation see the wiki at: https://github.com/philsquared/Catch/wiki
-
-Maintainers: Please now work off the Integration branch and target any pull requests there.

README.md

@@ -0,0 +1,24 @@
+![catch logo](catch-logo-small.png)
+
+*v1.0 build 1 (master branch)*
+
+# New release with significant changes
+
+[Please see this page for details - including some breaking changes](docs/whats-changed.md)
+
+## What's the Catch?
+
+Catch stands for C++ Automated Test Cases in Headers and is a multi-paradigm automated test framework for C++ and Objective-C (and, maybe, C). It is implemented entirely in a set of header files, but is packaged up as a single header for extra convenience.
+
+## How to use it
+This documentation comprises these three parts:
+
+* [Why do we need yet another C++ Test Framework?](docs/why-catch.md)
+* [Tutorial](docs/tutorial.md) - getting started
+* [Reference section](docs/reference-index.md) - all the details
+
+The documentation will continue until morale improves
+
+## More
+* Issues and bugs can be raised on the [Issue tracker on GitHub](https://github.com/philsquared/Catch/issues)
+* For discussion or questions please use [the dedicated Google Groups forum](https://groups.google.com/forum/?fromgroups#!forum/catch-forum)

docs/assertions.md

@@ -0,0 +1,59 @@
+# Assertion Macros
+
+Most test frameworks have a large collection of assertion macros to capture all possible conditional forms (_EQUALS, _NOTEQUALS, _GREATER_THAN etc).
+
+Catch is different. Because it decomposes natural C-style conditional expressions most of these forms are reduced to one or two that you will use all the time. That said there are a rich set of auxilliary macros as well. We'll describe all of these here.
+
+Most of these macros come in two forms:
+
+## Natural Expressions
+
+The REQUIRE family of macros tests an expression and aborts the test case if it fails.
+The CHECK family are equivalent but execution continues in the same test case even if the assertion fails. This is useful if you have a series of essentially orthoginal assertions and it is useful to see all the results rather than stopping at the first failure.
+
+**REQUIRE(** _expression_ **)** and  
+**CHECK(** _expression_ **)**  
+Evaluates the expression and records the result. If an exception is thrown it is caught, reported, and counted as a failure. These are the macros you will use most of  the time
+
+Examples:
+
+```c++
+CHECK( str == "string value" );
+CHECK( thisReturnsTrue() );
+REQUIRE( i == 42 );
+```
+**REQUIRE_FALSE(** _expression_ **)** and  
+**CHECK_FALSE(** _expression_ **)**  
+Evaluates the expression and records the _logical NOT_ of the result. If an exception is thrown it is caught, reported, and counted as a failure.
+(these forms exist as a workaround for the fact that ! prefixed expressions cannot be decomposed).
+
+Example:
+```c++
+REQUIRE_FALSE( thisReturnsFalse() );
+```
+
+## Exceptions
+
+**REQUIRE_THROWS(** _expression_ **)** and  
+**CHECK_THROWS(** _expression_ **)**  
+Expects that an exception (of any type) is be thrown during evaluation of the expression.
+
+**REQUIRE_THROWS_AS(** _expression_ and _exception type_ **)** and  
+**CHECK_THROWS_AS(** _expression_, _exception type_ **)**  
+Expects that an exception of the _specified type_ is thrown during evaluation of the expression.
+
+**REQUIRE_NOTHROW(** _expression_ **)** and  
+**CHECK_NOTHROW(** _expression_ **)**  
+Expects that no exception is thrown during evaluation of the expression.
+
+## Matcher expressions
+
+To support Matchers a slightly different form is used. Matchers will be more fully documented elsewhere. *Note that Matchers are still at early stage development and are subject to change.*
+
+**REQUIRE_THAT(** _lhs_, __matcher call__ **)** and  
+**CHECK_THAT(** _lhs_, __matcher call__ **)**  
+
+
+---
+
+[Home](../README.md)

docs/command-line.md

@@ -0,0 +1,137 @@
+CATCH works quite nicely without any command line options at all - but for those times when you want greater control the following options are available.
+Note that options are described according to the following pattern:
+
+<a href="#test">     `    <test-spec> ...`</a><br />
+<a href="#reporter"> `    -r, --reporter`</a><br />
+<a href="#break">    `    -b, --break`</a><br />
+<a href="#success">  `    -s, --success`</a><br />
+<a href="#abort">    `    -a, --abort`</a><br />
+<a href="#list">     `    -l, --list`</a><br />
+<a href="#output">   `    -o, --out`</a><br />
+<a href="#name">     `    -n, --name`</a><br />
+<a href="#nothrow">  `    -e, --nothrow`</a><br />
+<a href="#usage">    `    -h, -?, --help`</a><br />
+
+<a name="test" />
+## Specifying which tests to run
+
+<pre>&lt;test-spec> ...</pre>
+
+Test cases, wildcarded test cases, tags and tag expressions are all passed directly as arguments. Tags are distinguished by being enclosed in square brackets.
+
+If no test specs are supplied then all test cases, except "hidden" tests (tagged ```[hide]``` or, in the legacy case, prefixed by `'./'`) are run
+
+Specs must be enclosed in quotes if they contain spaces. If they do not contain spaces the quotes are optional.
+
+Wildcards consist of the `*` character at the beginning and/or end of test case names and can substitute for any number of any characters (including none).
+
+Test specs are case insensitive.
+
+If a spec is prefixed with `exclude:` or the `~` character then the pattern matches an exclusion. This means that tests matching the pattern are excluded from the set - even if a prior inclusion spec included them. Subsequent inclusion specs will take precendence, however.
+Inclusions and exclusions are evaluated in left-to-right order.
+
+Test case examples:
+
+<pre>thisTestOnly            Matches the test case called, 'thisTestOnly'
+"this test only"        Matches the test case called, 'this test only'
+these*                  Matches all cases starting with 'these'
+exclude:notThis         Matches all tests except, 'notThis'
+~notThis                Matches all tests except, 'notThis'
+~*private*              Matches all tests except those that contain 'private'
+a* ~ab* abc             Matches all tests that start with 'a', except those that
+                        start with 'ab', except 'abc', which is included
+</pre>
+
+Names within square brackets are interpreted as tags.
+A series of tags form an AND expression wheras a comma seperated sequence forms an OR expression. e.g.:
+
+<pre>[one][two],[three]</pre>
+This matches all tests tagged `[one]` and `[two]`, as well as all tests tagged `[three]`
+
+
+<a name="reporter" />
+## Choosing a reporter to use
+
+<pre>-r, --reporter &lt;reporter></pre>
+
+A reporter is an object that formats and structures the output of running tests, and potentially summarises the results. By default a console reporter is used that writes, IDE friendly, textual output. Catch comes bundled with some alternative reporters, but more can be added in client code.<br />
+The bundled reporters are:
+
+<pre>-r console
+-r xml
+-r junit
+</pre>
+
+The JUnit reporter is an xml format that follows the structure of the JUnit XML Report ANT task, as consumed by a number of third-party tools, including Continuous Integration servers such as Hudson. If not otherwise needed, the standard XML reporter is preferred as this is a streaming reporter, whereas the Junit reporter needs to hold all its results until the end so it can write the overall results into attributes of the root node.
+
+<a name="break" />
+## Breaking into the debugger
+<pre>-b, --break</pre>
+
+In some IDEs (currently XCode and Visual Studio) it is possible for Catch to break into the debugger on a test failure. This can be very helpful during debug sessions - especially when there is more than one path through a particular test.
+In addition to the command line option, ensure you have built your code with the DEBUG preprocessor symbol
+
+<a name="success" />
+## Showing results for successful tests
+<pre>-s, --success</pre>
+
+Usually you only want to see reporting for failed tests. Sometimes it's useful to see *all* the output (especially when you don't trust that that test you just added worked first time!).
+To see successul, as well as failing, test results just pass this option. Note that each reporter may treat this option differently. The Junit reporter, for example, logs all results regardless.
+
+<a name="abort" />
+## Aborting after a certain number of failures
+<pre>-a, --abort
+-x, --abortx [&lt;failure threshold>]
+</pre>
+
+If a ```REQUIRE``` assertion fails the test case aborts, but subsequent test cases are still run.
+If a ```CHECK``` assertion fails even the current test case is not aborted.
+
+Sometimes this results in a flood of failure messages and you'd rather just see the first few. Specifying ```-a``` or ```--abort``` on its own will abort the whole test run on the first failed assertion of any kind. Use ```-x``` or ```--abortx``` followed by a number to abort after that number of assertion failures.
+
+<a name="list" />
+## Listing available tests, tags or reporters
+<pre>-l, --list-tests
+-t, --list-tags
+--list-reporters
+</pre>
+
+```-l``` or ```--list-tests`` will list all registered tests, along with any tags.
+If one or more test-specs have been supplied too then only the matching tests will be listed.
+
+```-t``` or ```--list-tags``` lists all available tags, along with the number of test cases they match. Again, supplying test specs limits the tags that match.
+
+```--list-reporters``` lists the available reporters.
+
+<a name="output" />
+## Sending output to a file
+<pre>-o, --out &lt;filename>
+</pre>
+
+Use this option to send all output to a file. By default output is sent to stdout (note that uses of stdout and stderr *from within test cases* are redirected and included in the report - so even stderr will effectively end up on stdout).
+
+<a name="name" />
+## Naming a test run
+<pre>-n, --name &lt;name for test run></pre>
+
+If a name is supplied it will be used by the reporter to provide an overall name for the test run. This can be useful if you are sending to a file, for example, and need to distinguish different test runs - either from different Catch executables or runs of the same executable with different options. If not supplied the name is defaulted to the name of the executable.
+
+<a name="nothrow" />
+## Eliding assertions expected to throw
+<pre>-e, --nothrow</pre>
+
+Skips all assertions that test that an exception is thrown, e.g. ```REQUIRE_THROWS```.
+
+These can be a nuisance in certain debugging environments that may break when exceptions are thrown (while this is usually optional for handled exceptions, it can be useful to have enabled if you are trying to track down something unexpected).
+
+When running with this option any throw checking assertions are skipped so as not to contribute additional noise. Be careful if this affects the behaviour of subsequent tests.
+
+<a name="usage" />
+## Usage
+<pre>-h, -?, --help</pre>
+
+Prints the command line arguments to stdout
+
+---
+
+[Home](../README.md)

docs/logging.md

@@ -0,0 +1,50 @@
+# Logging macros
+
+Additional messages can be logged during a test case.
+
+## Streaming macros
+
+All these macros allow heterogenous sequences of values to be streaming using the insertion operator (```<<```) in the same way that std::ostream, std::cout, etc support it.
+
+E.g.:
+```c++
+INFO( "The number is " << i );
+```
+
+(Note that there is no initial ```<<``` - instead the insertion sequence is placed in parentheses.)
+These macros come in three forms:
+
+**INFO(** _message expression_ **)**
+
+The message is logged to a buffer, but only reported if a subsequent failure occurs within the same test case. This allows you to log contextual information in case of failures which is not shown during a successful test run. The buffer is cleared on the next successful assertion.
+
+**SCOPED_INFO(** _message expression_ **)**
+
+As INFO, but is only in effect during the current scope. If a failure occurs beyond the end of the scope the message is not logged. In a looped block the message is reset on each iteration.
+
+**WARN(** _message expression_ **)**
+
+The message is always reported.
+
+**FAIL(** _message expression_ **)**
+
+The message is reported and the test case fails.
+
+## Quickly capture a variable value
+
+**CAPTURE(** _expression_ **)**
+
+Sometimes you just want to log the name and value of a variable. While you can easily do this with the INFO macro, above, as a convenience the CAPTURE macro handles the stringising of the variable name for you (actually it works with any expression, not just variables).
+
+E.g.
+```c++
+CAPTURE( theAnswer );
+```
+
+This would log something like:
+
+<pre>"theAnswer := 42"</pre>
+
+---
+
+[Home](../README.md)

docs/own-main.md

@@ -0,0 +1,66 @@
+# Supplying main() yourself
+
+The easiest way to use Catch is to let it supply ```main()``` for you and handle configuring itself from the command line.
+
+This is achieved by writing ```#define CATCH_CONFIG_MAIN``` before the ```#include "catch.hpp"``` in *exactly one* source file.
+
+Sometimes, though, you need to write your own version of main(). You can do this by writing ```#define CATCH_CONFIG_RUNNER``` instead. Now you are free to write ```main()``` as normal and call into Catch yourself manually.
+
+You now have a lot of flexibility - but here are three recipes to get your started:
+
+## Let Catch take full control of args and config
+
+If you just need to have code that executes before and/ or after Catch this is the simplest option.
+
+```c++
+#define CATCH_CONFIG_RUNNER
+#include "catch.hpp"
+
+int main( int argc, char* const argv[] )
+{
+  // global setup...
+
+  int result = Catch::Session().run( argc, argv );
+
+  // global clean-up...
+
+  return result;
+}
+```
+
+## Amending the config
+
+If you still want Catch to process the command line, but you want to programatically tweak the config, you can do so in one of two ways:
+
+```c++
+#define CATCH_CONFIG_RUNNER
+#include "catch.hpp"
+
+int main( int argc, char* const argv[] )
+{
+  Catch::Session session; // There must be exactly once instance
+
+  // writing to session.configData() here sets defaults
+
+  int returnCode = session.applyCommandLine( argc, argv );
+  if( returnCode != 0 ) // Indicates a command line error
+  	return returnCode;
+
+  // writing to session.configData() or session.Config() here 
+  // overrides command line args
+
+  return session.run();
+}
+```
+
+Take a look at the definitions of Config and ConfigData to see what you can do with them.
+
+To take full control of the config simply omit the call to ```applyCommandLine()```.
+
+## Adding your own command line options
+
+Catch embeds a powerful command line parser which you can also use to parse your own options out. This capability is still in active development but will be documented here when it is ready.
+
+---
+
+[Home](../README.md)

docs/reference-index.md

@@ -0,0 +1,12 @@
+These are the currently documented areas of the framework. There is more to come.
+
+Before looking at this material be sure to read the [tutorial](tutorial.md)
+
+* [Command Line](command-line.md)
+* [Assertion Macros](assertions.md)
+* [Logging Macros](logging.md)
+* [Supplying your own main()](own-main.md)
+
+---
+
+[Home](../README.md)

docs/tutorial.md

@@ -0,0 +1,100 @@
+# Getting Catch
+
+The simplest way to get Catch is to download the single header version from [http://builds.catch-lib.net](builds.catch-lib.net). Don't be put off by the word "builds" there. The single header is generated by merging a set of individual headers but it is still just normal source code in a header file.
+
+The full source for Catch, including test projects, documentation, and other things, is hosted on GitHub. [http://catch-lib.net](catch-lib.net) will redirect you there.
+
+
+## Where to put it?
+
+Catch is header only. All you need to do is drop the file(s) somewhere reachable from your project - either in some central location you can set your header search path to find, or directly into your project tree itself! This is a particularly good option for other Open-Source projects that want to use Catch for their test suite. See [this blog entry for more on that](http://www.levelofindirection.com/journal/2011/5/27/unit-testing-in-c-and-objective-c-just-got-ridiculously-easi-1.html). 
+
+The rest of this tutorial will assume that the Catch single-include header (or the include folder) is available unqualified - but you may need to prefix it with a folder name if necessary.
+
+# Writing tests
+
+Let's start with a really simple example. Say you have written a function to calculate factorials and now you want to test it (let's leave aside TDD for now). 
+
+```c++
+unsigned int Factorial( unsigned int number ) {
+    return number <= 1 ? number : Factorial(number-1)*number;
+}
+```
+
+To keep things simple we'll put everything in a single file.
+
+```c++
+#define CATCH_CONFIG_MAIN  // This tells Catch to provide a main() - only do this in one cpp file
+#include "catch.hpp"
+
+unsigned int Factorial( unsigned int number ) {
+    return number <= 1 ? number : Factorial(number-1)*number;
+}
+
+TEST_CASE( "Factorials are computed", "[factorial]" ) {
+    REQUIRE( Factorial(1) == 1 );
+    REQUIRE( Factorial(2) == 2 );
+    REQUIRE( Factorial(3) == 6 );
+    REQUIRE( Factorial(10) == 3628800 );
+}
+```
+
+This will compile to a complete executable which responds to [command line arguments](command-line.md). If you just run it with no arguments it will execute all test cases (in this case there is just one), report any failures, report a summary of how many tests passed and failed and return the number of failed tests (useful for if you just want a yes/ no answer to: "did it work").
+
+If you run this as written it will pass. Everything is good. Right?
+Well, there is still a bug here. In fact the first version of this tutorial I posted here genuinely had the bug in! So it's not completely contrived (thanks to Daryle Walker (```@CTMacUser```) for pointing this out).
+
+What is the bug? Well what is the factorial of zero?
+[The factorial of zero is one](http://mathforum.org/library/drmath/view/57128.html) - which is just one of those things you have to know (and remember!).
+
+Let's add that to the test case:
+
+```c++
+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 );
+}
+```
+
+Now we get a failure - something like:
+
+```
+Example.cpp:9: FAILED:
+  REQUIRE( Factorial(0) == 1 )
+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.
+
+Let's change the factorial function to:
+
+```c++
+unsigned int Factorial( unsigned int number ) {
+  return number > 1 ? Factorial(number-1)*number : 1;
+}
+```
+
+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.
+
+## What did we do here?
+
+Although this was a simple test it's been enough to demonstrate a few things about how Catch is used. Let's take moment to consider those before we move on.
+
+1. All we did was ```#define``` one identifier and ```#include``` one header and we got everything - even an implementation of ```main()``` that will [respond to command line arguments](command-line.md). You can only use that ```#define``` in one implementation file, for (hopefully) obvious reasons. Once you have more than one file with unit tests in you'll just ```#include "catch.hpp"``` and go. Usually it's a good idea to have a dedicated implementation file that just has ```#define CATCH_CONFIG_MAIN``` and ```#include "catch.hpp"```. You can also provide your own implementation of main and drive Catch yourself (see [Supplying-your-own-main()](own-main.md).
+2. We introduce test cases with the TEST_CASE macro. This macro takes two arguments - a hierarchical test name (forward slash separated, by convention) and a free-form description. The test name should be unique - and ideally will logically group related tests together like folders in a file system. You can run sets of tests by specifying a wildcarded test name.
+3. The name and description arguments are just strings. We haven't had to declare a function or method - or explicitly register the test case anywhere. Behind the scenes a function with a generated name is defined for you, and automatically registered using static registry classes. By abstracting the function name away we can name our tests without the constraints of identifier names.
+4. We write our individual test assertions using the REQUIRE macro. Rather than a separate macro for each type of condition we express the condition naturally using C/C++ syntax. Behind the scenes a simple set of expression templates captures the left-hand-side and right-hand-side of the expression so we can display the values in our test report. As we'll see later there _are_ other assertion macros - but because of this technique the number of them is drastically reduced.
+
+## Next steps
+For more specific information see the [Reference pages](reference-index.md)
+
+
+---
+
+[Home](../README.md)

docs/whats-changed.md

@@ -0,0 +1,22 @@
+## What's new in Catch
+
+This page has been added following quite a large (hopefully the last such) merge from the integration branch. Please read this summary through so you know what to expect (and whether any changes - breaking in some cases - will affect you).
+
+* Calling Catch from your own ```main()``` has changed - please review [the updated docs](own-main.md)
+* The command line has changed. The biggest change is that test case names and tags should now only be supplied as primary arguments - in fact the ```-t``` option has been repurposed to mean "list tags". There are [updated docs for this too](command-line.md)
+* There is a new reporter interface. If you have written a custom reporter you can use the ```LegacyReporterAdapter``` to minimise any differences. Ideally you should update to the new interface - especially as it has been designed to be more robust in the face of future changes (which should be minimal).
+* The docs have moved from the wiki to the repository itself. They consist of a set of markdown files in the docs folder and are referenced directly from the README in the root. You can still read them online from GitHub.
+* Lots of new goodness - more documentation for which is coming. The existing docs have been updated to account for some of the changes already (e.g. variadic macros). A quick rundown:
+	* Variadic macros are used, where possible, so that, e.g. you can write a ```TEST_CASE``` with just a name - or even no name at all (making it an anonymous test case).
+	* The hierarchical naming convention is deprecated in favour of using tags (see next)
+	* ```TEST_CASE```s (but not ```SECTION```s) can now be tagged by placing keywords in square brackets in the second argument - e.g.: ```TEST_CASE( "A nice name", "[tag1][tag2]")```. The old style is still supported but please consider using this new style.
+	* Tests can still be "hidden" using the ```./``` prefix as before, but the preferred way now is to give it the ```[hide]``` tag (hidden tests are skipped if you run the test process without specifying any test specs).
+	* As well as ```TEST_CASE```s and ```SECTION```s you can now also use BDD-style ```SCENARIO``` (in place of ```TEST_CASE```) and ```GIVEN```, ```WHEN``` and ```THEN``` macros (in place of ```SECTION```s).
+	* New command line parser. Under the hood it is a complete rewrite - now powered by a command line library that will soon be spun out as a separate project: Clara. The options themselves are largely the same but there are some notable differences (as already discussed).
+	* Completely overhauled output from the textual reporter (now the Console reporter). This now features a much clearer, cleaner format, including good use of indentation.
+
+If you find any issues please raise issue tickets on the [issue tracker on GitHub](https://github.com/philsquared/Catch/issues) as before. For general questions, comments and suggestions, though, please use the [new forums on Google Groups](https://groups.google.com/forum/?fromgroups#!forum/catch-forum).
+
+---
+
+[Home](../README.md)

docs/why-catch.md

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

glueHeaders.py

@@ -1,54 +0,0 @@
-import os
-import sys
-import re
-import datetime
-
-includesParser = re.compile( r'\s*#include\s*"(.*)"' )
-guardParser = re.compile( r'\s*#.*_INCLUDED')
-defineParser = re.compile( r'\s*#define')
-commentParser1 = re.compile( r'^\s*/\*')
-commentParser2 = re.compile( r'^\s*\*')
-blankParser = re.compile( r'^\s*$')
-seenHeaders = set([])
-rootPath = os.path.join( os.path.realpath(os.path.dirname(sys.argv[0])), 'include/' )
-
-def parseFile( path, filename ):
-	f = open( path + filename, 'r' )
-	blanks = 0
-	for line in f:
-		m = includesParser.match( line )
-		if m:
-			header = m.group(1)
-			headerPath, sep, headerFile = header.rpartition( "/" )
-			if not headerFile in seenHeaders:
-				seenHeaders.add( headerFile )
-				print "// #included from: " + header
-				if( headerPath == "internal" and path.endswith( "internal/" ) ):
-					headerPath = ""
-					sep = ""
-				if os.path.exists( path + headerPath + sep + headerFile ):
-					parseFile( path + headerPath + sep, headerFile )
-				else:
-					parseFile( rootPath + headerPath + sep, headerFile )
-		elif (not guardParser.match( line ) or defineParser.match( line ) ) and not commentParser1.match( line )and not commentParser2.match( line ):
-			if blankParser.match( line ):
-				blanks = blanks + 1
-			else:
-				blanks = 0
-			if blanks < 2:
-				print line.rstrip()
-
-print "/*"
-print " *  Generated: " + str( datetime.datetime.now() )
-print " *  ----------------------------------------------------------"
-print " *  This file has been merged from multiple headers. Please don't edit it directly"
-print " *  Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved."
-print " *"
-print " *  Distributed under the Boost Software License, Version 1.0. (See accompanying"
-print " *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)"
-print " */"
-print '#ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED'
-print '#define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED'
-parseFile( rootPath, 'catch.hpp' )
-print '#endif // TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED'
-print

include/catch.hpp

@@ -11,6 +11,7 @@
 
 #ifdef __clang__
 #pragma clang diagnostic ignored "-Wglobal-constructors"
+#pragma clang diagnostic ignored "-Wvariadic-macros"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wpadded"
@@ -25,6 +26,7 @@
 #include "internal/catch_interfaces_exception.h"
 #include "internal/catch_approx.hpp"
 #include "internal/catch_matchers.hpp"
+#include "internal/catch_compiler_capabilities.h"
 
 // These files are included here so the single_include script doesn't put them
 // in the conditionally compiled sections
@@ -68,25 +70,44 @@
 #define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THAT" )
 #define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_THAT" )
 
-#define CATCH_INFO( msg ) INTERNAL_CATCH_MSG( msg, Catch::ResultWas::Info, Catch::ResultDisposition::ContinueOnFailure, "CATCH_INFO" )
+#define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( msg, "CATCH_INFO" )
 #define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( msg, Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, "CATCH_WARN" )
 #define CATCH_FAIL( msg ) INTERNAL_CATCH_MSG( msg, Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "CATCH_FAIL" )
 #define CATCH_SUCCEED( msg ) INTERNAL_CATCH_MSG( msg, Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "CATCH_SUCCEED" )
 #define CATCH_SCOPED_INFO( msg ) INTERNAL_CATCH_SCOPED_INFO( msg, "CATCH_SCOPED_INFO" )
-#define CATCH_CAPTURE( msg ) INTERNAL_CATCH_MSG( #msg " := " << msg, Catch::ResultWas::Info, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CAPTURE" )
+#define CATCH_CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CATCH_CAPTURE" )
 #define CATCH_SCOPED_CAPTURE( msg ) INTERNAL_CATCH_SCOPED_INFO( #msg " := " << msg, "CATCH_SCOPED_CAPTURE" )
 
-#define CATCH_SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description )
-
-#define CATCH_TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description )
-#define CATCH_TEST_CASE_NORETURN( name, description ) INTERNAL_CATCH_TESTCASE_NORETURN( name, description )
-#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "Anonymous test case" )
-#define CATCH_METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description )
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+    #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
+    #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
+    #define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+    #define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
+#else
+    #define CATCH_TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description )
+    #define CATCH_TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description )
+    #define CATCH_METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description )
+    #define CATCH_SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description )
+#endif
+#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" )
 
 #define CATCH_REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType )
+#define CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType )
 
 #define CATCH_GENERATE( expr) INTERNAL_CATCH_GENERATE( expr )
 
+// "BDD-style" convenience wrappers
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+#define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ )
+#else
+#define CATCH_SCENARIO( name, tags ) CATCH_TEST_CASE( "Scenario: " name, tags )
+#endif
+#define CATCH_GIVEN( desc )    CATCH_SECTION( "Given: " desc, "" )
+#define CATCH_WHEN( desc )     CATCH_SECTION( " When: " desc, "" )
+#define CATCH_AND_WHEN( desc ) CATCH_SECTION( "  And: " desc, "" )
+#define CATCH_THEN( desc )     CATCH_SECTION( " Then: " desc, "" )
+#define CATCH_AND_THEN( desc ) CATCH_SECTION( "  And: " desc, "" )
+
 // If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
 #else
 
@@ -110,22 +131,29 @@
 #define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::ContinueOnFailure, "CHECK_THAT" )
 #define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::Normal, "REQUIRE_THAT" )
 
-#define INFO( msg ) INTERNAL_CATCH_MSG( msg, Catch::ResultWas::Info, Catch::ResultDisposition::ContinueOnFailure, "INFO" )
+#define INFO( msg ) INTERNAL_CATCH_INFO( msg, "INFO" )
 #define WARN( msg ) INTERNAL_CATCH_MSG( msg, Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, "WARN" )
 #define FAIL( msg ) INTERNAL_CATCH_MSG( msg, Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "FAIL" )
 #define SUCCEED( msg ) INTERNAL_CATCH_MSG( msg, Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "SUCCEED" )
 #define SCOPED_INFO( msg ) INTERNAL_CATCH_SCOPED_INFO( msg, "SCOPED_INFO" )
-#define CAPTURE( msg ) INTERNAL_CATCH_MSG( #msg " := " << msg, Catch::ResultWas::Info, Catch::ResultDisposition::ContinueOnFailure, "CAPTURE" )
+#define CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CAPTURE" )
 #define SCOPED_CAPTURE( msg ) INTERNAL_CATCH_SCOPED_INFO( #msg " := " << msg, "SCOPED_CAPTURE" )
 
-#define SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description )
-
-#define TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description )
-#define TEST_CASE_NORETURN( name, description ) INTERNAL_CATCH_TESTCASE_NORETURN( name, description )
-#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "Anonymous test case" )
-#define METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description )
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+    #define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
+    #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
+    #define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+    #define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
+#else
+    #define TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description )
+    #define TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description )
+    #define METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description )
+    #define SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description )
+#endif
+#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" )
 
 #define REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType )
+#define REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType )
 
 #define GENERATE( expr) INTERNAL_CATCH_GENERATE( expr )
 
@@ -133,6 +161,18 @@
 
 #define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
 
+// "BDD-style" convenience wrappers
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+#define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
+#else
+#define SCENARIO( name, tags ) TEST_CASE( "Scenario: " name, tags )
+#endif
+#define GIVEN( desc )    SECTION( "   Given: " desc, "" )
+#define WHEN( desc )     SECTION( "    When: " desc, "" )
+#define AND_WHEN( desc ) SECTION( "And when: " desc, "" )
+#define THEN( desc )     SECTION( "    Then: " desc, "" )
+#define AND_THEN( desc ) SECTION( "     And: " desc, "" )
+
 using Catch::Detail::Approx;
 
 #ifdef __clang__

include/catch_runner.hpp

@@ -12,6 +12,8 @@
 #include "internal/catch_list.hpp"
 #include "internal/catch_runner_impl.hpp"
 #include "internal/catch_test_spec.h"
+#include "internal/catch_version.h"
+#include "internal/catch_text.h"
 
 #include <fstream>
 #include <stdlib.h>
@@ -19,12 +21,11 @@
 
 namespace Catch {
 
-    class Runner2 { // This will become Runner when Runner becomes Context
+    class Runner {
 
     public:
-        Runner2( Config& configWrapper )
-        :   m_configWrapper( configWrapper ),
-            m_config( configWrapper.data() )
+        Runner( Ptr<Config> const& config )
+        :   m_config( config )
         {
             openStream();
             makeReporter();
@@ -32,31 +33,28 @@ namespace Catch {
 
         Totals runTests() {
 
-            std::vector<TestCaseFilters> filterGroups = m_config.filters;
+            std::vector<TestCaseFilters> filterGroups = m_config->filters();
             if( filterGroups.empty() ) {
                 TestCaseFilters filterGroup( "" );
                 filterGroups.push_back( filterGroup );
             }
 
-            Runner context( m_configWrapper, m_reporter ); // This Runner will be renamed Context
+            RunContext context( m_config.get(), m_reporter );
+
             Totals totals;
 
-            std::vector<TestCaseFilters>::const_iterator it = filterGroups.begin();
-            std::vector<TestCaseFilters>::const_iterator itEnd = filterGroups.end();
-            for(; it != itEnd && !context.aborting(); ++it ) {
-                m_reporter->StartGroup( it->getName() );
-                totals += runTestsForGroup( context, *it );
-                if( context.aborting() )
-                    m_reporter->Aborted();
-                m_reporter->EndGroup( it->getName(), totals );
+            for( std::size_t i=0; i < filterGroups.size() && !context.aborting(); ++i ) {
+                context.testGroupStarting( filterGroups[i].getName(), i, filterGroups.size() );
+                totals += runTestsForGroup( context, filterGroups[i] );
+                context.testGroupEnded( filterGroups[i].getName(), totals, i, filterGroups.size() );
             }
             return totals;
         }
 
-        Totals runTestsForGroup( Runner& context, const TestCaseFilters& filterGroup ) {
+        Totals runTestsForGroup( RunContext& context, const TestCaseFilters& filterGroup ) {
             Totals totals;
-            std::vector<TestCaseInfo>::const_iterator it = getRegistryHub().getTestCaseRegistry().getAllTests().begin();
-            std::vector<TestCaseInfo>::const_iterator itEnd = getRegistryHub().getTestCaseRegistry().getAllTests().end();
+            std::vector<TestCase>::const_iterator it = getRegistryHub().getTestCaseRegistry().getAllTests().begin();
+            std::vector<TestCase>::const_iterator itEnd = getRegistryHub().getTestCaseRegistry().getAllTests().end();
             int testsRunForGroup = 0;
             for(; it != itEnd; ++it ) {
                 if( filterGroup.shouldInclude( *it ) ) {
@@ -71,36 +69,31 @@ namespace Catch {
                     }
                 }
             }
-            if( testsRunForGroup == 0 )
-                std::cerr << "\n[No test cases matched with: " << filterGroup.getName() << "]" << std::endl;
+            if( testsRunForGroup == 0 && !filterGroup.getName().empty() )
+                m_reporter->noMatchingTestCases( filterGroup.getName() );
             return totals;
             
         }
 
     private:
         void openStream() {
-            if( !m_config.stream.empty() )
-                m_configWrapper.useStream( m_config.stream );
-
             // Open output file, if specified
-            if( !m_config.outputFilename.empty() ) {
-                m_ofs.open( m_config.outputFilename.c_str() );
+            if( !m_config->getFilename().empty() ) {
+                m_ofs.open( m_config->getFilename().c_str() );
                 if( m_ofs.fail() ) {
                     std::ostringstream oss;
-                    oss << "Unable to open file: '" << m_config.outputFilename << "'";
+                    oss << "Unable to open file: '" << m_config->getFilename() << "'";
                     throw std::domain_error( oss.str() );
                 }
-                m_configWrapper.setStreamBuf( m_ofs.rdbuf() );
+                m_config->setStreamBuf( m_ofs.rdbuf() );
             }
         }
         void makeReporter() {
-            std::string reporterName = m_config.reporter.empty()
-            ? "basic"
-            : m_config.reporter;
+            std::string reporterName = m_config->getReporterName().empty()
+                ? "console"
+                : m_config->getReporterName();
 
-            ReporterConfig reporterConfig( m_config.name, m_configWrapper.stream(), m_config.includeWhichResults == Include::SuccessfulResults, m_config );
-
-            m_reporter = getRegistryHub().getReporterRegistry().create( reporterName, reporterConfig );
+            m_reporter = getRegistryHub().getReporterRegistry().create( reporterName, m_config.get() );
             if( !m_reporter ) {
                 std::ostringstream oss;
                 oss << "No reporter registered with name: '" << reporterName << "'";
@@ -109,156 +102,134 @@ namespace Catch {
         }
         
     private:
-        Config& m_configWrapper;
-        const ConfigData& m_config;
+        Ptr<Config> m_config;
         std::ofstream m_ofs;
-        Ptr<IReporter> m_reporter;
-        std::set<TestCaseInfo> m_testsAlreadyRun;
+        Ptr<IStreamingReporter> m_reporter;
+        std::set<TestCase> m_testsAlreadyRun;
     };
 
-    inline int Main( Config& configWrapper ) {
-        int result = 0;
-        try
-        {
-            Runner2 runner( configWrapper );
+    class Session {
+        static bool alreadyInstantiated;
         
-            const ConfigData& config = configWrapper.data();
+    public:
     
-            // Handle list request
-            if( config.listSpec != List::None ) {
-                List( config );
-                Catch::cleanUp();
-                return 0;
+        struct OnUnusedOptions { enum DoWhat { Ignore, Fail }; };
+
+        Session()
+        : m_cli( makeCommandLineParser() ) {
+            if( alreadyInstantiated ) {
+                std::string msg = "Only one instance of Catch::Session can ever be used";
+                std::cerr << msg << std::endl;
+                throw std::logic_error( msg );
             }
-
-            result = static_cast<int>( runner.runTests().assertions.failed );
-
+            alreadyInstantiated = true;
         }
-        catch( std::exception& ex ) {
-            std::cerr << ex.what() << std::endl;
-            result = (std::numeric_limits<int>::max)();
-        }
-
-        Catch::cleanUp();
-        return result;
-    }
-
-    inline void showUsage( std::ostream& os ) {
-        AllOptions options;
-
-        for( AllOptions::const_iterator it = options.begin(); it != options.end(); ++it ) {
-            OptionParser& opt = **it;
-            os << "  " << opt.optionNames() << " " << opt.argsSynopsis() << "\n";
-        }
-        os << "\nFor more detail usage please see: https://github.com/philsquared/Catch/wiki/Command-line\n" << std::endl;
-    }
-
-    inline void addIndent( std::ostream& os, std::size_t indent ) {
-        while( indent-- > 0 )
-            os << ' ';
-    }
-
-    inline void recursivelyWrapLine( std::ostream& os, std::string paragraph, std::size_t columns, std::size_t indent ) {
-        std::size_t width = columns-indent;
-        std::size_t tab = 0;
-        std::size_t wrapPoint = width;
-        for( std::size_t pos = 0; pos < paragraph.size(); ++pos ) {
-            if( pos == width ) {
-                addIndent( os, indent );
-                os << paragraph.substr( 0, wrapPoint ) << "\n";
-                return recursivelyWrapLine( os, paragraph.substr( wrapPoint+1 ), columns, indent+tab );
-            }
-            if( paragraph[pos] == '\t' ) {
-                    tab = pos;
-                    paragraph = paragraph.substr( 0, tab ) + paragraph.substr( tab+1 );
-                    pos--;
-            }
-            else if( paragraph[pos] == ' ' ) {
-                wrapPoint = pos;
-            }
-        }
-        addIndent( os, indent );
-        os << paragraph << "\n";
-    }
-
-    inline std::string addLineBreaks( const std::string& str, std::size_t columns, std::size_t indent = 0 ) {
-        std::ostringstream oss;
-        std::string::size_type pos = 0;
-        std::string::size_type newline = str.find_first_of( '\n' );
-        while( newline != std::string::npos ) {
-            std::string paragraph = str.substr( pos, newline-pos );
-            recursivelyWrapLine( oss, paragraph, columns, indent );
-            pos = newline+1;
-            newline = str.find_first_of( '\n', pos );
-        }
-        if( pos != str.size() )
-            recursivelyWrapLine( oss, str.substr( pos, str.size()-pos ), columns, indent );
-
-        return oss.str();
-    }
-
-    inline void showHelp( const CommandParser& parser ) {
-        std::string exeName = parser.exeName();
-        std::string::size_type pos = exeName.find_last_of( "/\\" );
-        if( pos != std::string::npos ) {
-            exeName = exeName.substr( pos+1 );
-        }
-
-        AllOptions options;
-        Options::HelpOptionParser helpOpt;
-        bool displayedSpecificOption = false;
-        for( AllOptions::const_iterator it = options.begin(); it != options.end(); ++it ) {
-            OptionParser& opt = **it;
-            if( opt.find( parser ) && opt.optionNames() != helpOpt.optionNames() ) {
-                displayedSpecificOption = true;
-                std::cout   << "\n" << opt.optionNames() << " " << opt.argsSynopsis() << "\n\n"
-                            << opt.optionSummary() << "\n\n"
-
-                << addLineBreaks( opt.optionDescription(), 80, 2 ) << "\n" << std::endl;
-            }
-        }
-
-        if( !displayedSpecificOption ) {
-            std::cout << exeName << " is a CATCH host application. Options are as follows:\n\n";
-            showUsage( std::cout );
-        }
-    }
-    
-    inline int Main( int argc, char* const argv[], Config& config ) {
-
-        try {
-            CommandParser parser( argc, argv );
-
-            if( Command cmd = Options::HelpOptionParser().find( parser ) ) {
-                if( cmd.argsCount() != 0 )
-                    cmd.raiseError( "Does not accept arguments" );
-
-                showHelp( parser );
-                Catch::cleanUp();        
-                return 0;
-            }
-
-            AllOptions options;
-
-            options.parseIntoConfig( parser, config.data() );
-        }
-        catch( std::exception& ex ) {
-            std::cerr << ex.what() << "\n\nUsage: ...\n\n";
-            showUsage( std::cerr );
+        ~Session() {
             Catch::cleanUp();
-            return (std::numeric_limits<int>::max)();
         }
         
-        return Main( config );
-    }
+        void showHelp( std::string const& processName ) {
+            std::cout << "\nCatch v"    << libraryVersion.majorVersion << "."
+                                        << libraryVersion.minorVersion << " build "
+                                        << libraryVersion.buildNumber;
+            if( libraryVersion.branchName != "master" )
+                std::cout << " (" << libraryVersion.branchName << " branch)";
+            std::cout << "\n";
 
-    inline int Main( int argc, char* const argv[] ) {
-        Config config;
-// !TBD: This doesn't always work, for some reason
-//        if( isDebuggerActive() )
-//            config.useStream( "debug" );
-        return Main( argc, argv, config );
-    }
+            m_cli.usage( std::cout, processName );
+            std::cout << "For more detail usage please see the project docs\n" << std::endl;
+        }
+        
+        int applyCommandLine( int argc, char* const argv[], OnUnusedOptions::DoWhat unusedOptionBehaviour = OnUnusedOptions::Fail ) {
+            try {
+                m_unusedTokens = m_cli.parseInto( argc, argv, m_configData );
+                if( unusedOptionBehaviour == OnUnusedOptions::Fail )
+                    enforceNoUsedTokens();
+                if( m_configData.showHelp )
+                    showHelp( m_configData.processName );
+                m_config.reset();
+            }
+            catch( std::exception& ex ) {
+                std::cerr   << "\nError in input:\n"
+                            << Text( ex.what(), TextAttributes()
+                                                    .setInitialIndent(2)
+                                                    .setIndent(4) )
+                            << "\n\n";
+                m_cli.usage( std::cout, m_configData.processName );
+                return (std::numeric_limits<int>::max)();
+            }
+            return 0;
+        }
+
+        void useConfigData( ConfigData const& _configData ) {
+            m_configData = _configData;
+            m_config.reset();
+        }
+
+        void enforceNoUsedTokens() const {
+            if( !m_unusedTokens.empty() ) {
+                std::vector<Clara::Parser::Token>::const_iterator
+                    it = m_unusedTokens.begin(),
+                    itEnd = m_unusedTokens.end();
+                std::string msg;
+                for(; it != itEnd; ++it )
+                    msg += "  unrecognised option: " + it->data + "\n";
+                throw std::runtime_error( msg.substr( 0, msg.size()-1 ) );
+            }
+        }
+        
+        int run( int argc, char* const argv[] ) {
+
+            int returnCode = applyCommandLine( argc, argv );
+            if( returnCode == 0 )
+                returnCode = run();
+            return returnCode;
+        }
+
+        int run() {
+            if( m_configData.showHelp )
+                return 0;
+
+            try
+            {
+                config(); // Force config to be constructed
+                Runner runner( m_config );
+
+                // Handle list request
+                if( Option<std::size_t> listed = list( config() ) )
+                    return static_cast<int>( *listed );
+
+                return static_cast<int>( runner.runTests().assertions.failed );
+            }
+            catch( std::exception& ex ) {
+                std::cerr << ex.what() << std::endl;
+                return (std::numeric_limits<int>::max)();
+            }
+        }
+        
+        Clara::CommandLine<ConfigData> const& cli() const {
+            return m_cli;
+        }
+        std::vector<Clara::Parser::Token> const& unusedTokens() const {
+            return m_unusedTokens;
+        }
+        ConfigData& configData() {
+            return m_configData;
+        }
+        Config& config() {
+            if( !m_config )
+                m_config = new Config( m_configData );
+            return *m_config;
+        }
+        
+    private:        
+        Clara::CommandLine<ConfigData> m_cli;
+        std::vector<Clara::Parser::Token> m_unusedTokens;
+        ConfigData m_configData;
+        Ptr<Config> m_config;
+    };
+
+    bool Session::alreadyInstantiated = false;
     
 } // end namespace Catch
 

include/internal/catch_approx.hpp

@@ -24,7 +24,7 @@ namespace Detail {
             m_value( value )
         {}
         
-        Approx( const Approx& other )
+        Approx( Approx const& other )
         :   m_epsilon( other.m_epsilon ),
             m_scale( other.m_scale ),
             m_value( other.m_value )
@@ -41,20 +41,20 @@ namespace Detail {
             return approx;
         }
         
-        friend bool operator == ( double lhs, const Approx& rhs ) {
+        friend bool operator == ( double lhs, Approx const& rhs ) {
             // Thanks to Richard Harris for his help refining this formula
             return fabs( lhs - rhs.m_value ) < rhs.m_epsilon * (rhs.m_scale + (std::max)( fabs(lhs), fabs(rhs.m_value) ) );
         }
         
-        friend bool operator == ( const Approx& lhs, double rhs ) {
+        friend bool operator == ( Approx const& lhs, double rhs ) {
             return operator==( rhs, lhs );
         }
         
-        friend bool operator != ( double lhs, const Approx& rhs ) {
+        friend bool operator != ( double lhs, Approx const& rhs ) {
             return !operator==( lhs, rhs );
         }
 
-        friend bool operator != ( const Approx& lhs, double rhs ) {
+        friend bool operator != ( Approx const& lhs, double rhs ) {
             return !operator==( rhs, lhs );
         }
         
@@ -82,7 +82,7 @@ namespace Detail {
 }
 
 template<>
-inline std::string toString<Detail::Approx>( const Detail::Approx& value ) {
+inline std::string toString<Detail::Approx>( Detail::Approx const& value ) {
     return value.toString();
 }
     

include/internal/catch_assertionresult.h

@@ -16,9 +16,9 @@ namespace Catch {
     struct AssertionInfo
     {
         AssertionInfo() {}
-        AssertionInfo(  const std::string& _macroName,
-                        const SourceLineInfo& _lineInfo,
-                        const std::string& _capturedExpression,
+        AssertionInfo(  std::string const& _macroName,
+                        SourceLineInfo const& _lineInfo,
+                        std::string const& _capturedExpression,
                         ResultDisposition::Flags _resultDisposition );
 
         std::string macroName;
@@ -39,7 +39,7 @@ namespace Catch {
     class AssertionResult {
     public:
         AssertionResult();
-        AssertionResult( const AssertionInfo& info, const AssertionResultData& data );
+        AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
         ~AssertionResult();
         
         bool isOk() const;
@@ -48,6 +48,7 @@ namespace Catch {
         bool hasExpression() const;
         bool hasMessage() const;
         std::string getExpression() const;
+        std::string getExpressionInMacro() const;
         bool hasExpandedExpression() const;
         std::string getExpandedExpression() const;
         std::string getMessage() const;

include/internal/catch_assertionresult.hpp

@@ -13,22 +13,19 @@
 namespace Catch {
 
 
-    AssertionInfo::AssertionInfo(   const std::string& _macroName,
-                                    const SourceLineInfo& _lineInfo,
-                                    const std::string& _capturedExpression,
+    AssertionInfo::AssertionInfo(   std::string const& _macroName,
+                                    SourceLineInfo const& _lineInfo,
+                                    std::string const& _capturedExpression,
                                     ResultDisposition::Flags _resultDisposition )
     :   macroName( _macroName ),
         lineInfo( _lineInfo ),
         capturedExpression( _capturedExpression ),
         resultDisposition( _resultDisposition )
-    {
-        if( shouldNegate( resultDisposition ) )
-            capturedExpression = "!" + _capturedExpression;
-    }
+    {}
 
     AssertionResult::AssertionResult() {}
 
-    AssertionResult::AssertionResult( const AssertionInfo& info, const AssertionResultData& data )
+    AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
     :   m_info( info ),
         m_resultData( data )
     {}
@@ -58,7 +55,16 @@ namespace Catch {
     }
 
     std::string AssertionResult::getExpression() const {
-        return m_info.capturedExpression;
+        if( shouldNegate( m_info.resultDisposition ) )
+            return "!" + m_info.capturedExpression;
+        else
+            return m_info.capturedExpression;
+    }
+    std::string AssertionResult::getExpressionInMacro() const {
+        if( m_info.macroName.empty() )
+            return m_info.capturedExpression;
+        else
+            return m_info.macroName + "( " + m_info.capturedExpression + " )";
     }
 
     bool AssertionResult::hasExpandedExpression() const {

include/internal/catch_capture.hpp

@@ -10,11 +10,14 @@
 
 #include "catch_expression_decomposer.hpp"
 #include "catch_expressionresult_builder.h"
+#include "catch_message.h"
 #include "catch_interfaces_capture.h"
 #include "catch_debugger.hpp"
 #include "catch_context.h"
 #include "catch_common.h"
 #include "catch_interfaces_registry_hub.h"
+#include "internal/catch_compiler_capabilities.h"
+
 #include <ostream>
 
 namespace Catch {
@@ -24,8 +27,8 @@ namespace Catch {
     }
     
     template<typename MatcherT>
-    ExpressionResultBuilder expressionResultBuilderFromMatcher( const MatcherT& matcher,
-                                                                const std::string& matcherCallAsString ) {
+    ExpressionResultBuilder expressionResultBuilderFromMatcher( MatcherT const& matcher,
+                                                                std::string const& matcherCallAsString ) {
         std::string matcherAsString = matcher.toString();
         if( matcherAsString == "{?}" )
             matcherAsString = matcherCallAsString;
@@ -35,18 +38,18 @@ namespace Catch {
     }
 
     template<typename MatcherT, typename ArgT>
-    ExpressionResultBuilder expressionResultBuilderFromMatcher( const MatcherT& matcher,
-                                                                const ArgT& arg,
-                                                                const std::string& matcherCallAsString ) {
+    ExpressionResultBuilder expressionResultBuilderFromMatcher( MatcherT const& matcher,
+                                                                ArgT const& arg,
+                                                                std::string const& matcherCallAsString ) {
         return expressionResultBuilderFromMatcher( matcher, matcherCallAsString )
             .setLhs( Catch::toString( arg ) )
             .setResultType( matcher.match( arg ) );
     }
 
     template<typename MatcherT, typename ArgT>
-    ExpressionResultBuilder expressionResultBuilderFromMatcher( const MatcherT& matcher,
+    ExpressionResultBuilder expressionResultBuilderFromMatcher( MatcherT const& matcher,
                                                                 ArgT* arg,
-                                                                const std::string& matcherCallAsString ) {
+                                                                std::string const& matcherCallAsString ) {
         return expressionResultBuilderFromMatcher( matcher, matcherCallAsString )
             .setLhs( Catch::toString( arg ) )
             .setResultType( matcher.match( arg ) );
@@ -54,30 +57,6 @@ namespace Catch {
     
 struct TestFailureException{};
 
-class ScopedInfo {
-public:
-    ScopedInfo() : m_resultBuilder( ResultWas::Info ) {
-        getResultCapture().pushScopedInfo( this );
-    }
-    ~ScopedInfo() {
-        getResultCapture().popScopedInfo( this );
-    }
-    template<typename T>
-    ScopedInfo& operator << ( const T& value ) {
-        m_resultBuilder << value;
-        return *this; 
-    }
-    AssertionResult buildResult( const AssertionInfo& assertionInfo ) const {
-        return m_resultBuilder.buildResult( assertionInfo );
-    }
-    
-private:
-    ExpressionResultBuilder m_resultBuilder;
-};
-
-// This is just here to avoid compiler warnings with macro constants and boolean literals
-inline bool isTrue( bool value ){ return value; }
-
 } // end namespace Catch
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -89,7 +68,7 @@ inline bool isTrue( bool value ){ return value; }
         if( internal_catch_action & Catch::ResultAction::Debug ) BreakIntoDebugger(); \
         if( internal_catch_action & Catch::ResultAction::Abort ) throw Catch::TestFailureException(); \
         if( !Catch::shouldContinueOnFailure( resultDisposition ) ) throw Catch::TestFailureException(); \
-        if( Catch::isTrue( false ) ){ bool this_is_here_to_invoke_warnings = ( originalExpr ); Catch::isTrue( this_is_here_to_invoke_warnings ); } \
+        Catch::isTrue( false && originalExpr ); \
     }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -107,7 +86,6 @@ inline bool isTrue( bool value ){ return value; }
         } catch( ... ) { \
             INTERNAL_CATCH_ACCEPT_EXPR( Catch::ExpressionResultBuilder( Catch::ResultWas::ThrewException ) << Catch::translateActiveException(), \
                 resultDisposition | Catch::ResultDisposition::ContinueOnFailure, expr ); \
-            throw; \
         } \
     } while( Catch::isTrue( false ) )
 
@@ -168,17 +146,24 @@ inline bool isTrue( bool value ){ return value; }
     } while( Catch::isTrue( false ) )
 
 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_MSG( reason, resultType, resultDisposition, macroName ) \
+#define INTERNAL_CATCH_INFO( log, macroName ) \
+    do { \
+        Catch::getResultCapture().acceptMessage( Catch::MessageBuilder( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log ); \
+    } while( Catch::isTrue( false ) )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_MSG( log, messageType, resultDisposition, macroName ) \
     do { \
         INTERNAL_CATCH_ACCEPT_INFO( "", macroName, resultDisposition ); \
-        INTERNAL_CATCH_ACCEPT_EXPR( Catch::ExpressionResultBuilder( resultType ) << reason, resultDisposition, true ) \
+        INTERNAL_CATCH_ACCEPT_EXPR( Catch::ExpressionResultBuilder( messageType ) << log, resultDisposition, true ) \
     } while( Catch::isTrue( false ) )
 
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_SCOPED_INFO( log, macroName ) \
-    INTERNAL_CATCH_ACCEPT_INFO( "", macroName, Catch::ResultDisposition::Normal ); \
-    Catch::ScopedInfo INTERNAL_CATCH_UNIQUE_NAME( info ); \
-    INTERNAL_CATCH_UNIQUE_NAME( info ) << log
+    Catch::ScopedMessageBuilder INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ); \
+    INTERNAL_CATCH_UNIQUE_NAME( scopedMessage ) << log; \
+    Catch::getResultCapture().pushScopedMessage( INTERNAL_CATCH_UNIQUE_NAME( scopedMessage ) )
+
 
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CHECK_THAT( arg, matcher, resultDisposition, macroName ) \
@@ -191,7 +176,6 @@ inline bool isTrue( bool value ){ return value; }
         } catch( ... ) { \
             INTERNAL_CATCH_ACCEPT_EXPR( ( Catch::ExpressionResultBuilder( Catch::ResultWas::ThrewException ) << Catch::translateActiveException() ), \
                 resultDisposition | Catch::ResultDisposition::ContinueOnFailure, false ); \
-            throw; \
         } \
     } while( Catch::isTrue( false ) )
 

include/internal/catch_commandline.hpp

@@ -10,659 +10,119 @@
 
 #include "catch_config.hpp"
 #include "catch_common.h"
+#include "clara.h"
 
 namespace Catch {
     
-    class Command {
-    public:
-        Command(){}
+    inline void abortAfterFirst( ConfigData& config ) { config.abortAfter = 1; }
+    inline void abortAfterX( ConfigData& config, int x ) {
+        if( x < 1 )
+            throw std::runtime_error( "Value after -x or --abortAfter must be greater than zero" );
+        config.abortAfter = x;
+    }
+    inline void addTestOrTags( ConfigData& config, std::string const& _testSpec ) { config.testsOrTags.push_back( _testSpec ); }
 
-        explicit Command( const std::string& name ) : m_name( name ) {
-        }
+    inline void addWarning( ConfigData& config, std::string const& _warning ) {
+        if( _warning == "NoAssertions" )
+            config.warnings = (ConfigData::WarnAbout::What)( config.warnings | ConfigData::WarnAbout::NoAssertions );
+        else
+            throw std::runtime_error( "Unrecognised warning: '" + _warning + "'" );
 
-        Command& operator += ( const std::string& arg ) {
-            m_args.push_back( arg );
-            return *this;
-        }
-        Command& operator += ( const Command& other ) {
-            std::copy( other.m_args.begin(), other.m_args.end(), std::back_inserter( m_args ) );
-            if( m_name.empty() )
-                m_name = other.m_name;
-            return *this;
-        }
-        Command operator + ( const Command& other ) {
-            Command newCommand( *this );
-            newCommand += other;
-            return newCommand;
-        }
-        
-        operator SafeBool::type() const {
-            return SafeBool::makeSafe( !m_name.empty() || !m_args.empty() );
-        }
-        
-        std::string name() const { return m_name; }
-        std::string operator[]( std::size_t i ) const { return m_args[i]; }
-        std::size_t argsCount() const { return m_args.size(); }
-
-        CATCH_ATTRIBUTE_NORETURN
-        void raiseError( const std::string& message ) const {
-            std::ostringstream oss;
-            if( m_name.empty() )
-                oss << "Error while parsing " << m_name << ". " << message << ".";
-            else
-                oss << "Error while parsing arguments. " << message << ".";
-
-            if( m_args.size() > 0 )
-                oss << " Arguments were:";
-            for( std::size_t i = 0; i < m_args.size(); ++i )
-                oss << " " << m_args[i];
-            throw std::domain_error( oss.str() );
-        }
-        
-    private:
-        
-        std::string m_name;
-        std::vector<std::string> m_args;
-    };
-    
-    class CommandParser {
-    public:
-        CommandParser( int argc, char const * const * argv ) : m_argc( static_cast<std::size_t>( argc ) ), m_argv( argv ) {}
-
-        std::string exeName() const {
-            return m_argv[0];
-        }
-        Command find( const std::string& arg1,  const std::string& arg2, const std::string& arg3 ) const {
-            return find( arg1 ) + find( arg2 ) + find( arg3 );
-        }
-
-        Command find( const std::string& shortArg, const std::string& longArg ) const {
-            return find( shortArg ) + find( longArg );
-        }
-        Command find( const std::string& arg ) const {
-            if( arg.empty() )
-                return getArgs( "", 1 );
-            else
-                for( std::size_t i = 1; i < m_argc; ++i  )
-                    if( m_argv[i] == arg )
-                        return getArgs( m_argv[i], i+1 );
-            return Command();
-        }
-        Command getDefaultArgs() const {
-            return getArgs( "", 1 );
-        }
-
-    private:
-        Command getArgs( const std::string& cmdName, std::size_t from ) const {
-            Command command( cmdName );
-            for( std::size_t i = from; i < m_argc && m_argv[i][0] != '-'; ++i  )
-                command += m_argv[i];
-            return command;
-        }
-        
-        std::size_t m_argc;
-        char const * const * m_argv;
-    };
-
-    class OptionParser : public SharedImpl<IShared> {
-    public:
-        OptionParser( int minArgs = 0, int maxArgs = 0 )
-        : m_minArgs( minArgs ), m_maxArgs( maxArgs )
-        {}
-        
-        virtual ~OptionParser() {}
-
-        Command find( const CommandParser& parser ) const {
-            Command cmd;
-            for( std::vector<std::string>::const_iterator it = m_optionNames.begin();
-                it != m_optionNames.end();
-                ++it )
-                cmd += parser.find( *it );
-            return cmd;
-        }
-
-        void validateArgs( const Command& args ) const {
-            if(  tooFewArgs( args ) || tooManyArgs( args ) ) {
-                std::ostringstream oss;
-                if( m_maxArgs == -1 )
-                    oss <<"Expected at least " << pluralise( static_cast<std::size_t>( m_minArgs ), "argument" );
-                else if( m_minArgs == m_maxArgs )
-                    oss <<"Expected " << pluralise( static_cast<std::size_t>( m_minArgs ), "argument" );
-                else
-                    oss <<"Expected between " << m_minArgs << " and " << m_maxArgs << " argument";
-                args.raiseError( oss.str() );
-            }
-        }
-
-        void parseIntoConfig( const CommandParser& parser, ConfigData& config ) {
-            if( Command cmd = find( parser ) ) {
-                validateArgs( cmd );
-                parseIntoConfig( cmd, config );
-            }
-        }
-
-        virtual void parseIntoConfig( const Command& cmd, ConfigData& config ) = 0;
-        virtual std::string argsSynopsis() const = 0;
-        virtual std::string optionSummary() const = 0;
-        virtual std::string optionDescription() const { return ""; }
-
-        std::string optionNames() const {
-            std::string names;
-            for(    std::vector<std::string>::const_iterator it = m_optionNames.begin();
-                    it != m_optionNames.end();
-                    ++it ) {
-                if( !it->empty() ) {
-                    if( !names.empty() )
-                        names += ", ";
-                    names += *it;
-                }
-                else {
-                    names = "[" + names;
-                }
-            }
-            if( names[0] == '[' )
-                names += "]";
-            return names;
-        }
-        
-    protected:
-
-        bool tooFewArgs( const Command& args ) const {
-            return args.argsCount() < static_cast<std::size_t>( m_minArgs );
-        }
-        bool tooManyArgs( const Command& args ) const {
-            return m_maxArgs >= 0 && args.argsCount() > static_cast<std::size_t>( m_maxArgs );
-        }
-        std::vector<std::string> m_optionNames;
-        int m_minArgs;
-        int m_maxArgs;
-    };
-
-    namespace Options {
-
-        class HelpOptionParser : public OptionParser {
-        public:
-            HelpOptionParser() {
-                m_optionNames.push_back( "-?" );
-                m_optionNames.push_back( "-h" );
-                m_optionNames.push_back( "--help" );
-            }
-            virtual std::string argsSynopsis() const {
-                return "[<option for help on> ...]";
-            }
-            virtual std::string optionSummary() const {
-                return "Shows this usage summary, or help on a specific option, or options, if supplied";
-            }
-            virtual std::string optionDescription() const {
-                return "";
-            }
-
-            virtual void parseIntoConfig( const Command&, ConfigData& ) {
-                // Does not affect config
-            }
-        };
-
-
-        class TestCaseOptionParser : public OptionParser {
-        public:
-            TestCaseOptionParser() : OptionParser( 1, -1 ) {
-                m_optionNames.push_back( "-t" );
-                m_optionNames.push_back( "--test" );
-                m_optionNames.push_back( "" ); // default option
-            }
-            virtual std::string argsSynopsis() const {
-                return "<testspec> [<testspec>...]";
-            }
-            virtual std::string optionSummary() const {
-                return "Specifies which test case or cases to run";
-            }
-
-            // Lines are split at the nearest prior space char to the 80 char column.
-            // Tab chars are removed from the output but their positions are used to align
-            // subsequently wrapped lines
-            virtual std::string optionDescription() const {
-                return
-                    "This option allows one ore more test specs to be supplied. Each spec either fully "
-                    "specifies a test case or is a pattern containing wildcards to match a set of test "
-                    "cases. If this option is not provided then all test cases, except those prefixed "
-                    "by './' are run\n"
-                    "\n"
-                    "Specs must be enclosed in \"quotes\" if they contain spaces. If they do not "
-                    "contain spaces the quotes are optional.\n"
-                    "\n"
-                    "Wildcards consist of the * character at the beginning, end, or both and can substitute for "
-                    "any number of any characters (including none)\n"
-                    "\n"
-                    "If spec is prefixed with exclude: or the ~ character then the pattern matches an exclusion. "
-                    "This means that tests matching the pattern are excluded from the set - even if a prior "
-                    "inclusion spec included them. Subsequent inclusion specs will take precedence, however. "
-                    "Inclusions and exclusions are evaluated in left-to-right order.\n"
-                    "\n"
-                    "Examples:\n"
-                    "\n"
-                    "    -t thisTestOnly        \tMatches the test case called, 'thisTestOnly'\n"
-                    "    -t \"this test only\"    \tMatches the test case called, 'this test only'\n"
-                    "    -t these/*             \tMatches all cases starting with 'these/'\n"
-                    "    -t exclude:notThis     \tMatches all tests except, 'notThis'\n"
-                    "    -t ~notThis            \tMatches all tests except, 'notThis'\n"
-                    "    -t ~*private*          \tMatches all tests except those that contain 'private'\n"
-                    "    -t a/* ~a/b/* a/b/c    \tMatches all tests that start with 'a/', except those "
-                                                 "that start with 'a/b/', except 'a/b/c', which is included";
-            }
-                            
-            virtual void parseIntoConfig( const Command& cmd, ConfigData& config ) {
-                std::string groupName;
-                for( std::size_t i = 0; i < cmd.argsCount(); ++i ) {
-                    if( i != 0 )
-                        groupName += " ";
-                    groupName += cmd[i];
-                }
-                TestCaseFilters filters( groupName );
-                for( std::size_t i = 0; i < cmd.argsCount(); ++i )
-                    filters.addFilter( TestCaseFilter( cmd[i] ) );
-                config.filters.push_back( filters );
-            }
-        };
-
-        class TagOptionParser : public OptionParser {
-        public:
-            TagOptionParser() : OptionParser( 1, -1 ) {
-                m_optionNames.push_back( "-g" );
-                m_optionNames.push_back( "--tag" );
-            }
-            virtual std::string argsSynopsis() const {
-                return "<tagspec> [,<tagspec>...]";
-            }
-            virtual std::string optionSummary() const {
-                return "Matches test cases against tags or tag patterns";
-            }
-
-            // Lines are split at the nearest prior space char to the 80 char column.
-            // Tab chars are removed from the output but their positions are used to align
-            // subsequently wrapped lines
-            virtual std::string optionDescription() const {
-                return
-                "This option allows one or more tags or tag patterns to be specified.\n"
-                "Each tag is enclosed in square brackets. A series of tags form an AND expression "
-                "wheras a comma seperated sequence forms an OR expression. e.g.:\n\n"
-                "    -g [one][two],[three]\n\n"
-                "This matches all tests tagged [one] and [two], as well as all tests tagged [three].\n\n"
-                "Tags can be negated with the ~ character. This removes matching tests from the set. e.g.:\n\n"
-                "    -g [one]~[two]\n\n"
-                "matches all tests tagged [one], except those also tagged [two]";
-            }
-            
-            virtual void parseIntoConfig( const Command& cmd, ConfigData& config ) {
-                std::string groupName;
-                for( std::size_t i = 0; i < cmd.argsCount(); ++i ) {
-                    if( i != 0 )
-                        groupName += " ";
-                    groupName += cmd[i];
-                }
-                TestCaseFilters filters( groupName );
-                for( std::size_t i = 0; i < cmd.argsCount(); ++i )
-                    filters.addTags( cmd[i] );
-                config.filters.push_back( filters );
-            }
-        };
-
-        
-        class ListOptionParser : public OptionParser {
-        public:
-            ListOptionParser() : OptionParser( 0, 2 ) {
-                m_optionNames.push_back( "-l" );
-                m_optionNames.push_back( "--list" );
-            }
-            virtual std::string argsSynopsis() const {
-                return "[all | tests | reporters [xml]]";
-            }
-            virtual std::string optionSummary() const {
-                return "Lists available tests or reporters";
-            }
-
-            virtual std::string optionDescription() const {
-                return
-                    "With no arguments this option will list all registered tests - one per line.\n"
-                    "Supplying the xml argument formats the list as an xml document (which may be useful for "
-                    "consumption by other tools).\n"
-                    "Supplying the tests or reporters lists tests or reporters respectively - with descriptions.\n"
-                    "\n"
-                    "Examples:\n"
-                    "\n"
-                    "    -l\n"
-                    "    -l tests\n"
-                    "    -l reporters xml\n"
-                    "    -l xml";
-            }
-
-            virtual void parseIntoConfig( const Command& cmd, ConfigData& config ) {
-                config.listSpec = List::TestNames;
-                if( cmd.argsCount() >= 1 ) {
-                    if( cmd[0] == "all" )
-                        config.listSpec = List::All;
-                    else if( cmd[0] == "tests" )
-                        config.listSpec = List::Tests;
-                    else if( cmd[0] == "reporters" )
-                        config.listSpec = List::Reports;
-                    else
-                        cmd.raiseError( "Expected [tests] or [reporters]" );
-                }
-                if( cmd.argsCount() >= 2 ) {
-                    if( cmd[1] == "xml" )
-                        config.listSpec = static_cast<List::What>( config.listSpec | List::AsXml );
-                    else if( cmd[1] == "text" )
-                        config.listSpec = static_cast<List::What>( config.listSpec | List::AsText );
-                    else
-                        cmd.raiseError( "Expected [xml] or [text]" );
-                }
-            }
-        };
-        
-        class ReporterOptionParser : public OptionParser {
-        public:
-            ReporterOptionParser() : OptionParser( 1, 1 ) {
-                m_optionNames.push_back( "-r" );
-                m_optionNames.push_back( "--reporter" );
-            }
-            virtual std::string argsSynopsis() const {
-                return "<reporter name>";
-            }
-            virtual std::string optionSummary() const {
-                return "Specifies type of reporter";
-            }
-
-            virtual std::string optionDescription() const {
-                return
-                    "A reporter is an object that formats and structures the output of running "
-                    "tests, and potentially summarises the results. By default a basic reporter "
-                    "is used that writes IDE friendly results. CATCH comes bundled with some "
-                    "alternative reporters, but more can be added in client code.\n"
-                    "\n"
-                    "The bundled reporters are:\n"
-                    "    -r basic\n"
-                    "    -r xml\n"
-                    "    -r junit\n"
-                    "\n"
-                    "The JUnit reporter is an xml format that follows the structure of the JUnit "
-                    "XML Report ANT task, as consumed by a number of third-party tools, "
-                    "including Continuous Integration servers such as Jenkins.\n"
-                    "If not otherwise needed, the standard XML reporter is preferred as this is "
-                    "a streaming reporter, whereas the Junit reporter needs to hold all its "
-                    "results until the end so it can write the overall results into attributes "
-                    "of the root node.";
-            }
-
-            virtual void parseIntoConfig( const Command& cmd, ConfigData& config ) {
-                config.reporter = cmd[0];
-            }
-        };
-
-        class OutputOptionParser : public OptionParser {
-        public:
-            OutputOptionParser() : OptionParser( 1, 1 ) {
-                m_optionNames.push_back( "-o" );
-                m_optionNames.push_back( "--out" );
-            }
-            virtual std::string argsSynopsis() const {
-                return "<file name>|<%stream name>";
-            }
-            virtual std::string optionSummary() const {
-                return "Sends output to a file or stream";
-            }
-            virtual std::string optionDescription() const {
-                return
-                    "Use this option to send all output to a file or a stream. By default output is "
-                    "sent to stdout (note that uses of stdout and stderr from within test cases are "
-                    "redirected and included in the report - so even stderr will effectively end up "
-                    "on stdout). If the name begins with % it is interpreted as a stream. "
-                    "Otherwise it is treated as a filename.\n"
-                    "\n"
-                    "Examples are:\n"
-                    "\n"
-                    "    -o filename.txt\n"
-                    "    -o \"long filename.txt\"\n"
-                    "    -o %stdout\n"
-                    "    -o %stderr\n"
-                    "    -o %debug    \t(The IDE's debug output window - currently only Windows' "
-                                        "OutputDebugString is supported).";
-            }
-            virtual void parseIntoConfig( const Command& cmd, ConfigData& config ) {
-                if( cmd[0][0] == '%' )
-                    config.stream = cmd[0].substr( 1 );
-                else
-                    config.outputFilename = cmd[0];
-            }
-        };
-        
-        class SuccessOptionParser : public OptionParser {
-        public:
-            SuccessOptionParser() {
-                m_optionNames.push_back( "-s" );
-                m_optionNames.push_back( "--success" );
-            }
-            virtual std::string argsSynopsis() const {
-                return "";
-            }
-            virtual std::string optionSummary() const {
-                return "Shows results for successful tests";
-            }
-            virtual std::string optionDescription() const {
-                return
-                    "Usually you only want to see reporting for failed tests. Sometimes it's useful "
-                    "to see all the output (especially when you don't trust that that test you just "
-                    "added worked first time!). To see successful, as well as failing, test results "
-                    "just pass this option.";
-            }
-            virtual void parseIntoConfig( const Command&, ConfigData& config ) {
-                config.includeWhichResults = Include::SuccessfulResults;
-            }
-        };
-        
-        class DebugBreakOptionParser : public OptionParser {
-        public:
-            DebugBreakOptionParser() {
-                m_optionNames.push_back( "-b" );
-                m_optionNames.push_back( "--break" );
-            }
-            virtual std::string argsSynopsis() const {
-                return "";
-            }
-            virtual std::string optionSummary() const {
-                return "Breaks into the debugger on failure";
-            }
-            virtual std::string optionDescription() const {
-                return
-                    "In some IDEs (currently XCode and Visual Studio) it is possible for CATCH to "
-                    "break into the debugger on a test failure. This can be very helpful during "
-                    "debug sessions - especially when there is more than one path through a "
-                    "particular test. In addition to the command line option, ensure you have "
-                    "built your code with the DEBUG preprocessor symbol";
-            }
-            
-            virtual void parseIntoConfig( const Command&, ConfigData& config ) {
-                config.shouldDebugBreak = true;
-            }
-        };
-        
-        class NameOptionParser : public OptionParser {
-        public:
-            NameOptionParser() : OptionParser( 1, 1 ) {
-                m_optionNames.push_back( "-n" );
-                m_optionNames.push_back( "--name" );
-            }
-            virtual std::string argsSynopsis() const {
-                return "<name>";
-            }
-            virtual std::string optionSummary() const {
-                return "Names a test run";
-            }
-            virtual std::string optionDescription() const {
-                return
-                    "If a name is supplied it will be used by the reporter to provide an overall "
-                    "name for the test run. This can be useful if you are sending to a file, for "
-                    "example, and need to distinguish different test runs - either from different "
-                    "Catch executables or runs of the same executable with different options.\n"
-                    "\n"
-                    "Examples:\n"
-                    "\n"
-                    "    -n testRun\n"
-                    "    -n \"tests of the widget component\"";
-            }
-
-            virtual void parseIntoConfig( const Command& cmd, ConfigData& config ) {
-                config.name = cmd[0];
-            }
-        };
-
-        class AbortOptionParser : public OptionParser {
-        public:
-            AbortOptionParser() : OptionParser( 0, 1 ) {
-                m_optionNames.push_back( "-a" );
-                m_optionNames.push_back( "--abort" );
-            }
-            virtual std::string argsSynopsis() const {
-                return "[#]";
-            }
-            virtual std::string optionSummary() const {
-                return "Aborts after a certain number of failures";
-            }
-            virtual std::string optionDescription() const {
-                return
-                    "If a REQUIRE assertion fails the test case aborts, but subsequent test cases "
-                    "are still run. If a CHECK assertion fails even the current test case is not "
-                    "aborted.\n"
-                    "\n"
-                    "Sometimes this results in a flood of failure messages and you'd rather just "
-                    "see the first few. Specifying -a or --abort on its own will abort the whole "
-                    "test run on the first failed assertion of any kind. Following it with a "
-                    "number causes it to abort after that number of assertion failures.";
-            }
-
-            virtual void parseIntoConfig( const Command& cmd, ConfigData& config ) {
-                int threshold = 1;
-                if( cmd.argsCount() == 1 ) {
-                    std::stringstream ss;
-                    ss << cmd[0];
-                    ss >> threshold;
-                    if( ss.fail() || threshold <= 0 )
-                        cmd.raiseError( "threshold must be a number greater than zero" );
-                }
-                config.cutoff = threshold;
-            }
-        };
-
-        class NoThrowOptionParser : public OptionParser {
-        public:
-            NoThrowOptionParser() {
-                m_optionNames.push_back( "-nt" );
-                m_optionNames.push_back( "--nothrow" );
-            }
-            virtual std::string argsSynopsis() const {
-                return "";
-            }
-            virtual std::string optionSummary() const {
-                return "Elides assertions expected to throw";
-            }
-            virtual std::string optionDescription() const {
-                return
-                    "Skips all assertions that test that an exception is thrown, "
-                    "e.g. REQUIRE_THROWS.\n"
-                    "\n"
-                    "These can be a nuisance in certain debugging environments that may break when "
-                    "exceptions are thrown (while this is usually optional for handled exceptions, "
-                    "it can be useful to have enabled if you are trying to track down something "
-                    "unexpected).\n"
-                    "\n"
-                    "When running with this option the throw checking assertions are skipped so "
-                    "as not to contribute additional noise.";
-            }
-
-            virtual void parseIntoConfig( const Command&, ConfigData& config ) {
-                config.allowThrows = false;
-            }
-        };
-
-        class WarningsOptionParser : public OptionParser {
-        public:
-            WarningsOptionParser() : OptionParser( 1, -1 ) {
-                m_optionNames.push_back( "-w" );
-                m_optionNames.push_back( "--warnings" );
-            }
-            virtual std::string argsSynopsis() const {
-                return "<warning>";
-            }
-            virtual std::string optionSummary() const {
-                return "Enable warnings";
-            }
-            virtual std::string optionDescription() const {
-                return
-                    "Enables the named warnings. If the warnings are violated the test case is "
-                    "failed.\n"
-                    "\n"
-                    "At present only one warning has been provided: NoAssertions. If this warning "
-                    "is enabled then any test case that completes without an assertions (CHECK, "
-                    "REQUIRE etc) being encountered violates the warning.\n"
-                    "\n"
-                    "e.g.:\n"
-                    "\n"
-                    "    -w NoAssertions";
-            }
-
-            virtual void parseIntoConfig( const Command& cmd, ConfigData& config ) {
-                for( std::size_t i = 0; i < cmd.argsCount(); ++i ) {
-                    if( cmd[i] == "NoAssertions" )
-                        config.warnings = (ConfigData::WarnAbout::What)( config.warnings | ConfigData::WarnAbout::NoAssertions );
-                    else
-                        cmd.raiseError( "Unrecognised warning: " + cmd[i] );
-                }
-            }
-        };
+    }
+    inline void setVerbosity( ConfigData& config, int level ) {
+        // !TBD: accept strings?
+        config.verbosity = (ConfigData::Verbosity::Level)level;
     }
     
-    class AllOptions
-    {
-    public:
-        typedef std::vector<Ptr<OptionParser> > Parsers;
-        typedef Parsers::const_iterator const_iterator;
-        typedef Parsers::const_iterator iterator;
+    inline Clara::CommandLine<ConfigData> makeCommandLineParser() {
 
-        AllOptions() {
-            add<Options::TestCaseOptionParser>();   // Keep this one first
+        Clara::CommandLine<ConfigData> cli;
 
-            add<Options::TagOptionParser>();
-            add<Options::ListOptionParser>();
-            add<Options::ReporterOptionParser>();
-            add<Options::OutputOptionParser>();
-            add<Options::SuccessOptionParser>();
-            add<Options::DebugBreakOptionParser>();
-            add<Options::NameOptionParser>();
-            add<Options::AbortOptionParser>();
-            add<Options::NoThrowOptionParser>();
-            add<Options::WarningsOptionParser>();
+        cli.bindProcessName( &ConfigData::processName );
 
-            add<Options::HelpOptionParser>();       // Keep this one last
-        }
+        cli.bind( &ConfigData::showHelp )
+            .describe( "display usage information" )
+            .shortOpt( "?")
+            .shortOpt( "h")
+            .longOpt( "help" );
 
-        void parseIntoConfig( const CommandParser& parser, ConfigData& config ) {
-            for( const_iterator it = m_parsers.begin(); it != m_parsers.end(); ++it )
-                (*it)->parseIntoConfig( parser, config );
-        }
+        cli.bind( &ConfigData::listTests )
+            .describe( "list all (or matching) test cases" )
+            .shortOpt( "l")
+            .longOpt( "list-tests" );
 
-        const_iterator begin() const {
-            return m_parsers.begin();
-        }
-        const_iterator end() const {
-            return m_parsers.end();
-        }
-    private:
+        cli.bind( &ConfigData::listTags )
+            .describe( "list all (or matching) tags" )
+            .shortOpt( "t")
+            .longOpt( "list-tags" );
 
-        template<typename T>
-        void add() {
-            m_parsers.push_back( new T() );
-        }
-        Parsers m_parsers;
+        cli.bind( &ConfigData::listReporters )
+            .describe( "list all reporters" )
+            .longOpt( "list-reporters" );
 
-    };
+        cli.bind( &ConfigData::showSuccessfulTests )
+            .describe( "include successful tests in output" )
+            .shortOpt( "s")
+            .longOpt( "success" );
+
+        cli.bind( &ConfigData::shouldDebugBreak )
+            .describe( "break into debugger on failure" )
+            .shortOpt( "b")
+            .longOpt( "break" );
+
+        cli.bind( &ConfigData::noThrow )
+            .describe( "skip exception tests" )
+            .shortOpt( "e")
+            .longOpt( "nothrow" );
+
+        cli.bind( &ConfigData::outputFilename )
+            .describe( "output filename" )
+            .shortOpt( "o")
+            .longOpt( "out" )
+            .argName( "filename" );
+
+        cli.bind( &ConfigData::reporterName )
+            .describe( "reporter to use - defaults to console" )
+            .shortOpt( "r")
+            .longOpt( "reporter" )
+//            .argName( "name[:filename]" );
+            .argName( "name" );
+
+        cli.bind( &ConfigData::name )
+            .describe( "suite name" )
+            .shortOpt( "n")
+            .longOpt( "name" )
+            .argName( "name" );
+
+        cli.bind( &abortAfterFirst )
+            .describe( "abort at first failure" )
+            .shortOpt( "a")
+            .longOpt( "abort" );
+
+        cli.bind( &abortAfterX )
+            .describe( "abort after x failures" )
+            .shortOpt( "x")
+            .longOpt( "abortx" )
+            .argName( "number of failures" );
+
+        cli.bind( &addWarning )
+            .describe( "enable warnings" )
+            .shortOpt( "w")
+            .longOpt( "warn" )
+            .argName( "warning name" );
+
+//        cli.bind( &setVerbosity )
+//            .describe( "level of verbosity (0=no output)" )
+//            .shortOpt( "v")
+//            .longOpt( "verbosity" )
+//            .argName( "level" );
+
+        cli.bind( &addTestOrTags )
+            .describe( "which test or tests to use" )
+            .argName( "test name, pattern or tags" );
+
+        return cli;
+    }
         
 } // end namespace Catch
 

include/internal/catch_common.h

@@ -15,25 +15,21 @@
 #define INTERNAL_CATCH_STRINGIFY2( expr ) #expr
 #define INTERNAL_CATCH_STRINGIFY( expr ) INTERNAL_CATCH_STRINGIFY2( expr )
 
-#ifdef __GNUC__
-#define CATCH_ATTRIBUTE_NORETURN __attribute__ ((noreturn))
-#else
-#define CATCH_ATTRIBUTE_NORETURN
-#endif
-
 #include <sstream>
 #include <stdexcept>
 #include <algorithm>
 
+#include "catch_compiler_capabilities.h"
+
 namespace Catch {
 
-	class NonCopyable {
-		NonCopyable( const NonCopyable& );
-		void operator = ( const NonCopyable& );
-	protected:
-		NonCopyable() {}
-		virtual ~NonCopyable();
-	};
+    class NonCopyable {
+        NonCopyable( NonCopyable const& );
+        void operator = ( NonCopyable const& );
+    protected:
+        NonCopyable() {}
+        virtual ~NonCopyable();
+    };
     
     class SafeBool {
     public:
@@ -51,18 +47,14 @@ namespace Catch {
         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 ) {
         typename AssociativeContainerT::const_iterator it = container.begin();
         typename AssociativeContainerT::const_iterator itEnd = container.end();
         for(; it != itEnd; ++it )
-        {
             delete it->second;
-        }
     }
     
     template<typename ContainerT, typename Function>
@@ -71,27 +63,35 @@ namespace Catch {
     }
     
     template<typename ContainerT, typename Function>
-    inline void forEach( const ContainerT& container, Function function ) {
+    inline void forEach( ContainerT const& container, Function function ) {
         std::for_each( container.begin(), container.end(), function );
     }
 
-    inline bool startsWith( const std::string& s, const std::string& prefix ) {
+    inline bool startsWith( std::string const& s, std::string const& prefix ) {
         return s.size() >= prefix.size() && s.substr( 0, prefix.size() ) == prefix;
     }
-    inline bool endsWith( const std::string& s, const std::string& suffix ) {
+    inline bool endsWith( std::string const& s, std::string const& suffix ) {
         return s.size() >= suffix.size() && s.substr( s.size()-suffix.size(), suffix.size() ) == suffix;
     }
-    inline bool contains( const std::string& s, const std::string& infix ) {
+    inline bool contains( std::string const& s, std::string const& infix ) {
         return s.find( infix ) != std::string::npos;
     }
+    inline void toLowerInPlace( std::string& s ) {
+        std::transform( s.begin(), s.end(), s.begin(), ::tolower );
+    }
+    inline std::string toLower( std::string const& s ) {
+        std::string lc = s;
+        toLowerInPlace( lc );
+        return lc;
+    }
 
     struct pluralise {
-        pluralise( std::size_t count, const std::string& label )
+        pluralise( std::size_t count, std::string const& label )
         :   m_count( count ),
             m_label( label )
         {}
 
-        friend std::ostream& operator << ( std::ostream& os, const pluralise& pluraliser ) {
+        friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
             os << pluraliser.m_count << " " << pluraliser.m_label;
             if( pluraliser.m_count != 1 )
                 os << "s";
@@ -105,11 +105,11 @@ namespace Catch {
     struct SourceLineInfo {
     
         SourceLineInfo() : line( 0 ){}
-        SourceLineInfo( const std::string& _file, std::size_t _line )
+        SourceLineInfo( std::string const& _file, std::size_t _line )
         :   file( _file ),
             line( _line )
         {}
-        SourceLineInfo( const SourceLineInfo& other )
+        SourceLineInfo( SourceLineInfo const& other )
         :   file( other.file ),
             line( other.line )
         {}
@@ -121,20 +121,23 @@ namespace Catch {
         std::size_t line;        
     };
     
-    inline std::ostream& operator << ( std::ostream& os, const SourceLineInfo& info ) {
+    inline std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
 #ifndef __GNUG__
-        os << info.file << "(" << info.line << "): ";
+        os << info.file << "(" << info.line << ")";
 #else                
-        os << info.file << ":" << info.line << ": ";            
+        os << info.file << ":" << info.line;
 #endif            
         return os;
     }
     
-    CATCH_ATTRIBUTE_NORETURN
-    inline void throwLogicError( const std::string& message, const SourceLineInfo& locationInfo ) {
+    // This is just here to avoid compiler warnings with macro constants and boolean literals
+    inline bool isTrue( bool value ){ return value; }
+    
+    inline void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo ) {
         std::ostringstream oss;
-        oss << "Internal Catch error: '" << message << "' at: " << locationInfo;
-        throw std::logic_error( oss.str() );
+        oss << locationInfo << ": Internal Catch error: '" << message << "'";
+        if( isTrue( true ))
+            throw std::logic_error( oss.str() );
     }
 }
 

include/internal/catch_compiler_capabilities.h

@@ -0,0 +1,85 @@
+/*
+ *  Created by Phil on 15/04/2013.
+ *  Copyright 2013 Two Blue Cubes Ltd. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
+
+// Much of the following code is based on Boost (1.53)
+
+////////////////////////////////////////////////////////////////////////////////
+// Borland
+#ifdef __BORLANDC__
+
+#if (__BORLANDC__ > 0x582 )
+//#define CATCH_CONFIG_SFINAE // Not confirmed
+#endif
+
+#endif // __BORLANDC__
+
+////////////////////////////////////////////////////////////////////////////////
+// EDG
+#ifdef __EDG_VERSION__
+
+#if (__EDG_VERSION__ > 238 )
+//#define CATCH_CONFIG_SFINAE // Not confirmed
+#endif
+
+#endif // __EDG_VERSION__
+
+////////////////////////////////////////////////////////////////////////////////
+// Digital Mars
+#ifdef __DMC__
+
+#if (__DMC__ > 0x840 )
+//#define CATCH_CONFIG_SFINAE // Not confirmed
+#endif
+
+#endif // __DMC__
+
+////////////////////////////////////////////////////////////////////////////////
+// GCC
+#ifdef __GNUC__
+
+#if __GNUC__ < 3
+
+#if (__GNUC_MINOR__ >= 96 )
+//#define CATCH_CONFIG_SFINAE
+#endif
+
+#elif __GNUC__ >= 3
+
+// #define CATCH_CONFIG_SFINAE // Taking this out completely for now
+
+#endif // __GNUC__ < 3
+
+
+#endif // __GNUC__
+
+////////////////////////////////////////////////////////////////////////////////
+// Visual C++
+#ifdef _MSC_VER
+
+#if (_MSC_VER >= 1310 ) // (VC++ 7.0+)
+//#define CATCH_CONFIG_SFINAE // Not confirmed
+#endif
+
+#endif // _MSC_VER
+
+// Use variadic macros if the compiler supports them
+#if ( defined _MSC_VER && _MSC_VER > 1400 && !defined __EDGE__) || \
+    ( defined __WAVE__ && __WAVE_HAS_VARIADICS ) || \
+    ( defined __GNUC__ && __GNUC__ >= 3 ) || \
+    ( !defined __cplusplus && __STDC_VERSION__ >= 199901L || __cplusplus >= 201103L )
+
+#ifndef CATCH_CONFIG_NO_VARIADIC_MACROS
+#define CATCH_CONFIG_VARIADIC_MACROS
+#endif
+
+#endif
+
+#endif // TWOBLUECUBES_CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
+

include/internal/catch_config.hpp

@@ -18,64 +18,65 @@
 #include <string>
 #include <iostream>
 
+#ifndef CATCH_CONFIG_CONSOLE_WIDTH
+#define CATCH_CONFIG_CONSOLE_WIDTH 80
+#endif
+
 namespace Catch {
     
-    struct Include { enum WhichResults {
-        FailedOnly, 
-        SuccessfulResults
-    }; };
-
-    struct List{ enum What {
-        None = 0,
-        
-        Reports = 1,
-        Tests = 2,
-        All = 3,
-
-        TestNames = 6,
-
-        WhatMask = 0xf,
-        
-        AsText = 0x10,
-        AsXml = 0x20,
-        
-        AsMask = 0xf0
-    }; };
-    
     struct ConfigData {
 
+        struct Verbosity { enum Level {
+            NoOutput = 0,
+            Quiet,
+            Normal
+        }; };
+
         struct WarnAbout { enum What {
             Nothing = 0x00,
             NoAssertions = 0x01
         }; };
 
         ConfigData()
-        :   listSpec( List::None ),
+        :   listTests( false ),
+            listTags( false ),
+            listReporters( false ),
+            showSuccessfulTests( false ),
             shouldDebugBreak( false ),
-            includeWhichResults( Include::FailedOnly ),
-            cutoff( -1 ),
-            allowThrows( true ),
+            noThrow( false ),
+            showHelp( false ),
+            abortAfter( -1 ),
+            verbosity( Verbosity::Normal ),
             warnings( WarnAbout::Nothing )
         {}
         
-        std::string reporter;
-        std::string outputFilename;
-        List::What listSpec;
-        std::vector<TestCaseFilters> filters;
+        bool listTests;
+        bool listTags;
+        bool listReporters;
+
+        bool showSuccessfulTests;
         bool shouldDebugBreak;
-        std::string stream;
-        Include::WhichResults includeWhichResults;
-        std::string name;
-        int cutoff;
-        bool allowThrows;
+        bool noThrow;
+        bool showHelp;
+
+        int abortAfter;
+
+        Verbosity::Level verbosity;
         WarnAbout::What warnings;
+
+        std::string reporterName;
+        std::string outputFilename;
+        std::string name;
+        std::string processName;
+
+        std::vector<std::string> testsOrTags;
     };
     
     
-    class Config : public IConfig {
+    class Config : public SharedImpl<IConfig> {
     private:
-        Config( const Config& other );
-        Config& operator = ( const Config& other );
+        Config( Config const& other );
+        Config& operator = ( Config const& other );
         virtual void dummy();
     public:
 
@@ -83,90 +84,96 @@ namespace Catch {
         :   m_os( std::cout.rdbuf() )
         {}
         
-        Config( const ConfigData& data )
+        Config( ConfigData const& data )
         :   m_data( data ),
             m_os( std::cout.rdbuf() )
-        {}
+        {
+            if( !data.testsOrTags.empty() ) {
+                std::string groupName;
+                for( std::size_t i = 0; i < data.testsOrTags.size(); ++i ) {
+                    if( i != 0 )
+                        groupName += " ";
+                    groupName += data.testsOrTags[i];
+                }
+                TestCaseFilters filters( groupName );
+                for( std::size_t i = 0; i < data.testsOrTags.size(); ++i ) {
+                    std::string filter = data.testsOrTags[i];
+                    if( startsWith( filter, "[" ) || startsWith( filter, "~[" ) )
+                        filters.addTags( filter );
+                    else
+                        filters.addFilter( TestCaseFilter( filter ) );
+                }
+                m_filterSets.push_back( filters );
+            }
+        }
         
         virtual ~Config() {
             m_os.rdbuf( std::cout.rdbuf() );
             m_stream.release();
         }
         
-        void setFilename( const std::string& filename ) {
+        void setFilename( std::string const& filename ) {
             m_data.outputFilename = filename;
         }
         
-        List::What getListSpec( void ) const {
-            return m_data.listSpec;
-        }
-
-        const std::string& getFilename() const {
+        std::string const& getFilename() const {
             return m_data.outputFilename ;
         }
         
-        List::What listWhat() const {
-            return static_cast<List::What>( m_data.listSpec & List::WhatMask );
-        }        
+        bool listTests() const { return m_data.listTests; }
+        bool listTags() const { return m_data.listTags; }
+        bool listReporters() const { return m_data.listReporters; }
         
-        List::What listAs() const {
-            return static_cast<List::What>( m_data.listSpec & List::AsMask );
-        }
-
-        std::string getName() const {
-            return m_data.name;
+        std::string getProcessName() const {
+            return m_data.processName;
         }
 
         bool shouldDebugBreak() const {
             return m_data.shouldDebugBreak;
         }
         
-        virtual std::ostream& stream() const {
-            return m_os;
-        }
-        
         void setStreamBuf( std::streambuf* buf ) {
             m_os.rdbuf( buf ? buf : std::cout.rdbuf() );
         }        
 
-        void useStream( const std::string& streamName ) {
+        void useStream( std::string const& streamName ) {
             Stream stream = createStream( streamName );
             setStreamBuf( stream.streamBuf );
             m_stream.release();
             m_stream = stream;
         }
         
-        void addTestSpec( const std::string& testSpec ) {
+        std::string getReporterName() const { return m_data.reporterName; }
+
+        void addTestSpec( std::string const& testSpec ) {
             TestCaseFilters filters( testSpec );
             filters.addFilter( TestCaseFilter( testSpec ) );
-            m_data.filters.push_back( filters );
+            m_filterSets.push_back( filters );
         }
 
-        virtual bool includeSuccessfulResults() const {
-            return m_data.includeWhichResults == Include::SuccessfulResults;
+        int abortAfter() const {
+            return m_data.abortAfter;
         }
         
-        int getCutoff() const {
-            return m_data.cutoff;
+        std::vector<TestCaseFilters> const& filters() const {
+            return m_filterSets;
         }
         
-        virtual bool allowThrows() const {
-            return m_data.allowThrows;
-        }
+        bool showHelp() const { return m_data.showHelp; }
 
-        const ConfigData& data() const {
-            return m_data;
-        }
-        ConfigData& data() {
-            return m_data;
-        }
+        // IConfig interface
+        virtual bool allowThrows() const        { return !m_data.noThrow; }
+        virtual std::ostream& stream() const    { return m_os; }
+        virtual std::string name() const        { return m_data.name.empty() ? m_data.processName : m_data.name; }
+        virtual bool includeSuccessfulResults() const   { return m_data.showSuccessfulTests; }
+        virtual bool warnAboutMissingAssertions() const { return m_data.warnings & ConfigData::WarnAbout::NoAssertions; }
 
     private:
         ConfigData m_data;
         
-        // !TBD Move these out of here
         Stream m_stream;
         mutable std::ostream m_os;
+        std::vector<TestCaseFilters> m_filterSets;
     };
         
     

include/internal/catch_console_colour.hpp

@@ -12,31 +12,53 @@
 
 namespace Catch {
 
-    struct ConsoleColourImpl;
+    namespace Detail {
+        struct IColourImpl;
+    }
 
-    class TextColour : NonCopyable {
-    public:
+    struct Colour {
+        enum Code {
+            None = 0,
             
-        enum Colours {
-            None,
+            White,
+            Red,
+            Green,
+            Blue,
+            Cyan,
+            Yellow,
+            Grey,
             
-            FileName,
-            ResultError,
-            ResultSuccess,
+            Bright = 0x10,
             
-            Error,
-            Success,
+            BrightRed = Bright | Red,
+            BrightGreen = Bright | Green,
+            LightGrey = Bright | Grey,
+            BrightWhite = Bright | White,
             
-            OriginalExpression,
-            ReconstructedExpression
+            // By intention
+            FileName = LightGrey,
+            ResultError = BrightRed,
+            ResultSuccess = BrightGreen,
+            
+            Error = BrightRed,
+            Success = Green,
+            
+            OriginalExpression = Cyan,
+            ReconstructedExpression = Yellow,
+            
+            SecondaryText = LightGrey,
+            Headers = White
         };
 
-        TextColour( Colours colour = None );
-        void set( Colours colour );
-        ~TextColour();
+        // Use constructed object for RAII guard
+        Colour( Code _colourCode );
+        ~Colour();
+        
+        // Use static method for one-shot changes
+        static void use( Code _colourCode );
         
     private:
-        ConsoleColourImpl* m_impl;
+        static Detail::IColourImpl* impl;
     };
     
 } // end namespace Catch

include/internal/catch_console_colour_impl.hpp

@@ -10,140 +10,137 @@
 
 #include "catch_console_colour.hpp"
 
-#if defined( CATCH_CONFIG_USE_ANSI_COLOUR_CODES )
+namespace Catch { namespace Detail {
+    struct IColourImpl {
+        virtual ~IColourImpl() {}
+        virtual void use( Colour::Code _colourCode ) = 0;
+    };
+}}
+
+#if defined ( CATCH_PLATFORM_WINDOWS ) /////////////////////////////////////////
+
+#define NOMINMAX
+#include <windows.h>
+
+namespace Catch {
+namespace {
+    
+    class Win32ColourImpl : public Detail::IColourImpl {
+    public:
+        Win32ColourImpl() : stdoutHandle( GetStdHandle(STD_OUTPUT_HANDLE) )
+        {
+            CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
+            GetConsoleScreenBufferInfo( stdoutHandle, &csbiInfo );
+            originalAttributes = csbiInfo.wAttributes;
+        }
+
+        virtual void use( Colour::Code _colourCode ) {
+            switch( _colourCode ) {
+                case Colour::None:      return setTextAttribute( originalAttributes );
+                case Colour::White:     return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
+                case Colour::Red:       return setTextAttribute( FOREGROUND_RED );
+                case Colour::Green:     return setTextAttribute( FOREGROUND_GREEN );
+                case Colour::Blue:      return setTextAttribute( FOREGROUND_BLUE );
+                case Colour::Cyan:      return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN );
+                case Colour::Yellow:    return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN );
+                case Colour::Grey:      return setTextAttribute( 0 );
+
+                case Colour::LightGrey:     return setTextAttribute( FOREGROUND_INTENSITY );
+                case Colour::BrightRed:     return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED );
+                case Colour::BrightGreen:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN );
+                case Colour::BrightWhite:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
+
+                case Colour::Bright: throw std::logic_error( "not a colour" );
+            }
+        }
+
+    private:    
+        void setTextAttribute( WORD _textAttribute ) {
+            SetConsoleTextAttribute( stdoutHandle, _textAttribute );
+        }
+        HANDLE stdoutHandle;
+        WORD originalAttributes;
+    };
+
+    inline bool shouldUseColourForPlatform() {
+        return true;
+    }
+    
+    Win32ColourImpl platformColourImpl;
+
+} // end anon namespace
+} // end namespace Catch
+
+#else // Not Windows - assumed to be POSIX compatible //////////////////////////
 
 #include <unistd.h>
 
 namespace Catch {
+namespace {
 
     // use POSIX/ ANSI console terminal codes
-    // Implementation contributed by Adam Strzelecki (http://github.com/nanoant)
+    // Thanks to Adam Strzelecki for original contribution
+    // (http://github.com/nanoant)
     // https://github.com/philsquared/Catch/pull/131
+    class PosixColourImpl : public Detail::IColourImpl {
+    public:
+        virtual void use( Colour::Code _colourCode ) {
+            switch( _colourCode ) {
+                case Colour::None:
+                case Colour::White:     return setColour( "[0m" );
+                case Colour::Red:       return setColour( "[0;31m" );
+                case Colour::Green:     return setColour( "[0;32m" );
+                case Colour::Blue:      return setColour( "[0:34m" );
+                case Colour::Cyan:      return setColour( "[0;36m" );
+                case Colour::Yellow:    return setColour( "[0;33m" );
+                case Colour::Grey:      return setColour( "[1;30m" );
 
-    TextColour::TextColour( Colours colour ) {
-        if( colour )
-            set( colour );
-    }
+                case Colour::LightGrey:     return setColour( "[0;37m" );
+                case Colour::BrightRed:     return setColour( "[1;31m" );
+                case Colour::BrightGreen:   return setColour( "[1;32m" );
+                case Colour::BrightWhite:   return setColour( "[1;37m" );
                 
-    TextColour::~TextColour() {
-        set( TextColour::None );
-    }
-
-    namespace { const char colourEscape = '\033'; }
-
-    void TextColour::set( Colours colour ) {
-        if( isatty( fileno(stdout) ) ) {
-            switch( colour ) {
-                case TextColour::FileName:
-                    std::cout << colourEscape << "[0m";    // white/ normal
-                    break;
-                case TextColour::ResultError:
-                    std::cout << colourEscape << "[1;31m"; // bold red
-                    break;
-                case TextColour::ResultSuccess:
-                    std::cout << colourEscape << "[1;32m"; // bold green
-                    break;
-                case TextColour::Error:
-                    std::cout << colourEscape << "[0;31m"; // red
-                    break;
-                case TextColour::Success:
-                    std::cout << colourEscape << "[0;32m"; // green
-                    break;
-                case TextColour::OriginalExpression:
-                    std::cout << colourEscape << "[0;36m"; // cyan
-                    break;
-                case TextColour::ReconstructedExpression:
-                    std::cout << colourEscape << "[0;33m"; // yellow
-                    break;
-                case TextColour::None:
-                    std::cout << colourEscape << "[0m"; // reset
+                case Colour::Bright: throw std::logic_error( "not a colour" );
             }
         }
+    private:    
+        void setColour( const char* _escapeCode ) {
+            std::cout << '\033' << _escapeCode;
+        }
+    };
+
+    inline bool shouldUseColourForPlatform() {
+        return isatty( fileno(stdout) );
     }
     
-} // namespace Catch
+    PosixColourImpl platformColourImpl;
     
-#elif defined ( CATCH_PLATFORM_WINDOWS )
+} // end anon namespace
+} // end namespace Catch
 
-#include <windows.h>
+#endif // not Windows
 
 namespace Catch {
 
     namespace {
-    
-        WORD mapConsoleColour( TextColour::Colours colour ) {
-            switch( colour ) {
-                case TextColour::FileName:      
-                    return FOREGROUND_INTENSITY;                    // greyed out
-                case TextColour::ResultError:   
-                    return FOREGROUND_RED | FOREGROUND_INTENSITY;   // bright red
-                case TextColour::ResultSuccess: 
-                    return FOREGROUND_GREEN | FOREGROUND_INTENSITY; // bright green
-                case TextColour::Error:         
-                    return FOREGROUND_RED;                          // dark red
-                case TextColour::Success:       
-                    return FOREGROUND_GREEN;                        // dark green      
-                case TextColour::OriginalExpression:      
-                    return FOREGROUND_BLUE | FOREGROUND_GREEN;      // turquoise
-                case TextColour::ReconstructedExpression:    
-                    return FOREGROUND_RED | FOREGROUND_GREEN;       // greeny-yellow
-                default: return 0;
-            }
-        }
+        struct NoColourImpl : Detail::IColourImpl {
+            void use( Colour::Code ) {}
+        };
+        NoColourImpl noColourImpl;        
+        static const bool shouldUseColour = shouldUseColourForPlatform() &&
+                                            !isDebuggerActive();
     }
 
-    struct ConsoleColourImpl {
-    
-        ConsoleColourImpl()
-        :   hStdout( GetStdHandle(STD_OUTPUT_HANDLE) ),
-            wOldColorAttrs( 0 )
-        {
-            GetConsoleScreenBufferInfo( hStdout, &csbiInfo );
-            wOldColorAttrs = csbiInfo.wAttributes;
-        }
-        
-        ~ConsoleColourImpl() {
-            SetConsoleTextAttribute( hStdout, wOldColorAttrs );
-        }
-        
-        void set( TextColour::Colours colour ) {
-            WORD consoleColour = mapConsoleColour( colour );
-            if( consoleColour > 0 )
-                SetConsoleTextAttribute( hStdout, consoleColour );
-        }
-        
-        HANDLE hStdout;
-        CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
-        WORD wOldColorAttrs;
-    };
-    
-    TextColour::TextColour( Colours colour ) 
-    : m_impl( new ConsoleColourImpl() ) 
-    {
-        if( colour )
-            m_impl->set( colour );
+    Colour::Colour( Code _colourCode ){ use( _colourCode ); }
+    Colour::~Colour(){ use( None ); }
+    void Colour::use( Code _colourCode ) {
+        impl->use( _colourCode );
     }
 
-    TextColour::~TextColour() {
-        delete m_impl;
-    }
-
-    void TextColour::set( Colours colour ) {
-        m_impl->set( colour );
-    }
+    Detail::IColourImpl* Colour::impl = shouldUseColour
+            ? static_cast<Detail::IColourImpl*>( &platformColourImpl )
+            : static_cast<Detail::IColourImpl*>( &noColourImpl );
 
 } // end namespace Catch
 
-#else
-
-namespace Catch {
-
-    TextColour::TextColour( Colours ){}
-    TextColour::~TextColour(){}
-    void TextColour::set( Colours ){}
-
-} // end namespace Catch
-
-#endif
-
 #endif // TWOBLUECUBES_CATCH_CONSOLE_COLOUR_IMPL_HPP_INCLUDED

include/internal/catch_context.h

@@ -9,6 +9,7 @@
 #define TWOBLUECUBES_CATCH_CONTEXT_H_INCLUDED
 
 #include "catch_interfaces_generators.h"
+#include "catch_ptr.hpp"
 
 #include <memory>
 #include <vector>
@@ -16,7 +17,7 @@
 
 namespace Catch {
 
-    class TestCaseInfo;
+    class TestCase;
     class Stream;
     struct IResultCapture;
     struct IRunner;
@@ -29,9 +30,9 @@ namespace Catch {
         
         virtual IResultCapture& getResultCapture() = 0;
         virtual IRunner& getRunner() = 0;
-        virtual size_t getGeneratorIndex( const std::string& fileInfo, size_t totalSize ) = 0;
+        virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) = 0;
         virtual bool advanceGeneratorsForCurrentTest() = 0;
-        virtual const IConfig* getConfig() const = 0;
+        virtual Ptr<IConfig const> getConfig() const = 0;
     };
 
     struct IMutableContext : IContext
@@ -39,13 +40,13 @@ namespace Catch {
         virtual ~IMutableContext();
         virtual void setResultCapture( IResultCapture* resultCapture ) = 0;
         virtual void setRunner( IRunner* runner ) = 0;
-        virtual void setConfig( const IConfig* config ) = 0;
+        virtual void setConfig( Ptr<IConfig const> const& config ) = 0;
     };
 
     IContext& getCurrentContext();
     IMutableContext& getCurrentMutableContext();
     void cleanUpContext();
-    Stream createStream( const std::string& streamName );
+    Stream createStream( std::string const& streamName );
 
 }
 

include/internal/catch_context_impl.hpp

@@ -18,8 +18,8 @@ namespace Catch {
     class Context : public IMutableContext {
 
         Context() : m_config( NULL ) {}
-        Context( const Context& );
-        void operator=( const Context& );
+        Context( Context const& );
+        void operator=( Context const& );
 
     public: // IContext
         virtual IResultCapture& getResultCapture() {
@@ -28,7 +28,7 @@ namespace Catch {
         virtual IRunner& getRunner() {
             return *m_runner;
         }
-        virtual size_t getGeneratorIndex( const std::string& fileInfo, size_t totalSize ) {
+        virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) {
             return getGeneratorsForCurrentTest()
             .getGeneratorInfo( fileInfo, totalSize )
             .getCurrentIndex();
@@ -38,7 +38,7 @@ namespace Catch {
             return generators && generators->moveNext();
         }
 
-        virtual const IConfig* getConfig() const {
+        virtual Ptr<IConfig const> getConfig() const {
             return m_config;
         }
 
@@ -49,7 +49,7 @@ namespace Catch {
         virtual void setRunner( IRunner* runner ) {
             m_runner = runner;
         }
-        virtual void setConfig( const IConfig* config ) {
+        virtual void setConfig( Ptr<IConfig const> const& config ) {
             m_config = config;
         }
         
@@ -79,7 +79,7 @@ namespace Catch {
     private:
         IRunner* m_runner;
         IResultCapture* m_resultCapture;
-        const IConfig* m_config;
+        Ptr<IConfig const> m_config;
         std::map<std::string, IGeneratorsForTest*> m_generatorsByTestName;
     };
     
@@ -95,7 +95,7 @@ namespace Catch {
         return getCurrentMutableContext();
     }
 
-    Stream createStream( const std::string& streamName ) {
+    Stream createStream( std::string const& streamName ) {
         if( streamName == "stdout" ) return Stream( std::cout.rdbuf(), false );
         if( streamName == "stderr" ) return Stream( std::cerr.rdbuf(), false );
         if( streamName == "debug" ) return Stream( new StreamBufImpl<OutputDebugWriter>, true );

include/internal/catch_debugger.hpp

@@ -97,17 +97,17 @@
         return IsDebuggerPresent() != 0;
     }
 #else
-	   inline void BreakIntoDebugger(){}
-	   inline bool isDebuggerActive() { return false; }
+       inline void BreakIntoDebugger(){}
+       inline bool isDebuggerActive() { return false; }
 #endif
 
 #ifdef CATCH_PLATFORM_WINDOWS
 extern "C" __declspec(dllimport) void __stdcall OutputDebugStringA( const char* );
-inline void writeToDebugConsole( const std::string& text ) {
+inline void writeToDebugConsole( std::string const& text ) {
     ::OutputDebugStringA( text.c_str() );
 }
 #else
-inline void writeToDebugConsole( const std::string& text ) {
+inline void writeToDebugConsole( std::string const& text ) {
     // !TBD: Need a version for Mac/ XCode and other IDEs
     std::cout << text;
 }

include/internal/catch_default_main.hpp

@@ -12,7 +12,7 @@
 
 // Standard C/C++ main entry point
 int main (int argc, char * const argv[]) {    
-    return Catch::Main( argc, argv );    
+    return Catch::Session().run( argc, argv );
 }
 
 #else // __OBJC__
@@ -24,7 +24,7 @@ int main (int argc, char * const argv[]) {
 #endif
     
     Catch::registerTestMethods();    
-    int result = Catch::Main( argc, (char* const*)argv );
+    int result = Catch::Session().run( argc, (char* const*)argv );
     
 #if !CATCH_ARC_ENABLED
     [pool drain];

include/internal/catch_evaluate.hpp

@@ -8,6 +8,11 @@
 #ifndef TWOBLUECUBES_CATCH_EVALUATE_HPP_INCLUDED
 #define TWOBLUECUBES_CATCH_EVALUATE_HPP_INCLUDED
 
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
+#endif
+
 namespace Catch {
 namespace Internal {
 
@@ -28,6 +33,15 @@ namespace Internal {
     template<> struct OperatorTraits<IsLessThanOrEqualTo>   { static const char* getName(){ return "<="; } };
     template<> struct OperatorTraits<IsGreaterThanOrEqualTo>{ static const char* getName(){ return ">="; } };
     
+    template<typename T>
+    inline 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
+    inline std::nullptr_t opCast(std::nullptr_t) { return nullptr; }
+#endif // CATCH_CONFIG_CPP11_NULLPTR
+    
+
     // 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>
@@ -35,43 +49,43 @@ namespace Internal {
     
     template<typename T1, typename T2>
     struct Evaluator<T1, T2, IsEqualTo> {
-        static bool evaluate( const T1& lhs, const T2& rhs) {
-            return const_cast<T1&>( lhs ) ==  const_cast<T2&>( rhs );
+        static bool evaluate( T1 const& lhs, T2 const& rhs) {
+            return opCast( lhs ) ==  opCast( rhs );
         }
     };
     template<typename T1, typename T2>
     struct Evaluator<T1, T2, IsNotEqualTo> {
-        static bool evaluate( const T1& lhs, const T2& rhs ) {
-            return const_cast<T1&>( lhs ) != const_cast<T2&>( rhs );
+        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
+            return opCast( lhs ) != opCast( rhs );
         }
     };
     template<typename T1, typename T2>
     struct Evaluator<T1, T2, IsLessThan> {
-        static bool evaluate( const T1& lhs, const T2& rhs ) {
-            return const_cast<T1&>( lhs ) < const_cast<T2&>( rhs );
+        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
+            return opCast( lhs ) < opCast( rhs );
         }
     };
     template<typename T1, typename T2>
     struct Evaluator<T1, T2, IsGreaterThan> {
-        static bool evaluate( const T1& lhs, const T2& rhs ) {
-            return const_cast<T1&>( lhs ) > const_cast<T2&>( rhs );
+        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
+            return opCast( lhs ) > opCast( rhs );
         }
     };
     template<typename T1, typename T2>
     struct Evaluator<T1, T2, IsGreaterThanOrEqualTo> {
-        static bool evaluate( const T1& lhs, const T2& rhs ) {
-            return const_cast<T1&>( lhs ) >= const_cast<T2&>( rhs );
+        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
+            return opCast( lhs ) >= opCast( rhs );
         }
     };
     template<typename T1, typename T2>
     struct Evaluator<T1, T2, IsLessThanOrEqualTo> {
-        static bool evaluate( const T1& lhs, const T2& rhs ) {
-            return const_cast<T1&>( lhs ) <= const_cast<T2&>( rhs );
+        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
+            return opCast( lhs ) <= opCast( rhs );
         }
     };
 
     template<Operator Op, typename T1, typename T2>
-    bool applyEvaluator( const T1& lhs, const T2& rhs ) {
+    bool applyEvaluator( T1 const& lhs, T2 const& rhs ) {
         return Evaluator<T1, T2, Op>::evaluate( lhs, rhs );
     }
 
@@ -80,7 +94,7 @@ namespace Internal {
 
     // "base" overload
     template<Operator Op, typename T1, typename T2>
-    bool compare( const T1& lhs, const T2& rhs ) {
+    bool compare( T1 const& lhs, T2 const& rhs ) {
         return Evaluator<T1, T2, Op>::evaluate( lhs, rhs );
     }
 
@@ -144,7 +158,21 @@ namespace Internal {
         return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
     }
 
+#ifdef CATCH_CONFIG_CPP11_NULLPTR
+    // pointer to nullptr_t (when comparing against nullptr)
+    template<Operator Op, typename T> bool compare( std::nullptr_t, T* rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( NULL, rhs );
+    }
+    template<Operator Op, typename T> bool compare( T* lhs, std::nullptr_t ) {
+        return Evaluator<T*, T*, Op>::evaluate( lhs, NULL );
+    }
+#endif // CATCH_CONFIG_CPP11_NULLPTR
+ 
 } // end of namespace Internal
 } // end of namespace Catch
 
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
 #endif // TWOBLUECUBES_CATCH_EVALUATE_HPP_INCLUDED

include/internal/catch_expression_decomposer.hpp

@@ -17,8 +17,8 @@ class ExpressionDecomposer {
 public:
 
     template<typename T>
-    ExpressionLhs<const T&> operator->* ( const T & operand ) {
-        return ExpressionLhs<const T&>( operand );
+    ExpressionLhs<T const&> operator->* ( T const& operand ) {
+        return ExpressionLhs<T const&>( operand );
     }
 
     ExpressionLhs<bool> operator->* ( bool value ) {

include/internal/catch_expression_lhs.hpp

@@ -19,38 +19,38 @@ struct STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison;
 // in an ExpressionResultBuilder object
 template<typename T>
 class ExpressionLhs {
-	void operator = ( const ExpressionLhs& );
+    void operator = ( ExpressionLhs const& );
 
 public:
     ExpressionLhs( T lhs ) : m_lhs( lhs ) {}
 
     template<typename RhsT>
-    ExpressionResultBuilder& operator == ( const RhsT& rhs ) {
+    ExpressionResultBuilder& operator == ( RhsT const& rhs ) {
         return captureExpression<Internal::IsEqualTo>( rhs );
     }
 
     template<typename RhsT>
-    ExpressionResultBuilder& operator != ( const RhsT& rhs ) {
+    ExpressionResultBuilder& operator != ( RhsT const& rhs ) {
         return captureExpression<Internal::IsNotEqualTo>( rhs );
     }
     
     template<typename RhsT>
-    ExpressionResultBuilder& operator < ( const RhsT& rhs ) {
+    ExpressionResultBuilder& operator < ( RhsT const& rhs ) {
         return captureExpression<Internal::IsLessThan>( rhs );
     }
     
     template<typename RhsT>
-    ExpressionResultBuilder& operator > ( const RhsT& rhs ) {
+    ExpressionResultBuilder& operator > ( RhsT const& rhs ) {
         return captureExpression<Internal::IsGreaterThan>( rhs );
     }
     
     template<typename RhsT>
-    ExpressionResultBuilder& operator <= ( const RhsT& rhs ) {
+    ExpressionResultBuilder& operator <= ( RhsT const& rhs ) {
         return captureExpression<Internal::IsLessThanOrEqualTo>( rhs );
     }
     
     template<typename RhsT>
-    ExpressionResultBuilder& operator >= ( const RhsT& rhs ) {
+    ExpressionResultBuilder& operator >= ( RhsT const& rhs ) {
         return captureExpression<Internal::IsGreaterThanOrEqualTo>( rhs );
     }
 
@@ -72,14 +72,14 @@ public:
 
     // Only simple binary expressions are allowed on the LHS.
     // If more complex compositions are required then place the sub expression in parentheses
-    template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator + ( const RhsT& );
-    template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator - ( const RhsT& );
-    template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator / ( const RhsT& );
-    template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator * ( const RhsT& );
+    template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator + ( RhsT const& );
+    template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator - ( RhsT const& );
+    template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator / ( RhsT const& );
+    template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator * ( RhsT const& );
 
 private:
     template<Internal::Operator Op, typename RhsT>
-    ExpressionResultBuilder& captureExpression( const RhsT& rhs ) {
+    ExpressionResultBuilder& captureExpression( RhsT const& rhs ) {
         return m_result
             .setResultType( Internal::compare<Op>( m_lhs, rhs ) )
             .setLhs( Catch::toString( m_lhs ) )

include/internal/catch_expressionresult_builder.h

@@ -22,26 +22,26 @@ class ExpressionResultBuilder {
 public:
     
     ExpressionResultBuilder( ResultWas::OfType resultType = ResultWas::Unknown );
-    ExpressionResultBuilder( const ExpressionResultBuilder& other );
-    ExpressionResultBuilder& operator=(const ExpressionResultBuilder& other );
+    ExpressionResultBuilder( ExpressionResultBuilder const& other );
+    ExpressionResultBuilder& operator=(ExpressionResultBuilder const& other );
 
     ExpressionResultBuilder& setResultType( ResultWas::OfType result );
     ExpressionResultBuilder& setResultType( bool result );
-    ExpressionResultBuilder& setLhs( const std::string& lhs );
-    ExpressionResultBuilder& setRhs( const std::string& rhs );
-    ExpressionResultBuilder& setOp( const std::string& op );
+    ExpressionResultBuilder& setLhs( std::string const& lhs );
+    ExpressionResultBuilder& setRhs( std::string const& rhs );
+    ExpressionResultBuilder& setOp( std::string const& op );
 
     ExpressionResultBuilder& endExpression( ResultDisposition::Flags resultDisposition );
 
     template<typename T>
-    ExpressionResultBuilder& operator << ( const T& value ) {
+    ExpressionResultBuilder& operator << ( T const& value ) {
         m_stream << value;
         return *this;
     }
 
-    std::string reconstructExpression( const AssertionInfo& info ) const;
+    std::string reconstructExpression( AssertionInfo const& info ) const;
 
-    AssertionResult buildResult( const AssertionInfo& info ) const;
+    AssertionResult buildResult( AssertionInfo const& info ) const;
 
 private:
     AssertionResultData m_data;

include/internal/catch_expressionresult_builder.hpp

@@ -17,13 +17,13 @@ namespace Catch {
     ExpressionResultBuilder::ExpressionResultBuilder( ResultWas::OfType resultType ) {
         m_data.resultType = resultType;
     }
-    ExpressionResultBuilder::ExpressionResultBuilder( const ExpressionResultBuilder& other )
+    ExpressionResultBuilder::ExpressionResultBuilder( ExpressionResultBuilder const& other )
     :   m_data( other.m_data ),
         m_exprComponents( other.m_exprComponents )
     {
         m_stream << other.m_stream.str();
     }
-    ExpressionResultBuilder& ExpressionResultBuilder::operator=(const ExpressionResultBuilder& other ) {
+    ExpressionResultBuilder& ExpressionResultBuilder::operator=(ExpressionResultBuilder const& other ) {
         m_data = other.m_data;
         m_exprComponents = other.m_exprComponents;
         m_stream.str("");
@@ -42,19 +42,19 @@ namespace Catch {
         m_exprComponents.shouldNegate = shouldNegate( resultDisposition );
         return *this;
     }
-    ExpressionResultBuilder& ExpressionResultBuilder::setLhs( const std::string& lhs ) {
+    ExpressionResultBuilder& ExpressionResultBuilder::setLhs( std::string const& lhs ) {
         m_exprComponents.lhs = lhs;
         return *this;
     }
-    ExpressionResultBuilder& ExpressionResultBuilder::setRhs( const std::string& rhs ) {
+    ExpressionResultBuilder& ExpressionResultBuilder::setRhs( std::string const& rhs ) {
         m_exprComponents.rhs = rhs;
         return *this;
     }
-    ExpressionResultBuilder& ExpressionResultBuilder::setOp( const std::string& op ) {
+    ExpressionResultBuilder& ExpressionResultBuilder::setOp( std::string const& op ) {
         m_exprComponents.op = op;
         return *this;
     }
-    AssertionResult ExpressionResultBuilder::buildResult( const AssertionInfo& info ) const
+    AssertionResult ExpressionResultBuilder::buildResult( AssertionInfo const& info ) const
     {
         assert( m_data.resultType != ResultWas::Unknown );
 
@@ -76,18 +76,18 @@ namespace Catch {
         }
         return AssertionResult( info, data );
     }
-    std::string ExpressionResultBuilder::reconstructExpression( const AssertionInfo& info ) const {
+    std::string ExpressionResultBuilder::reconstructExpression( AssertionInfo const& info ) const {
         if( m_exprComponents.op == "" )
             return m_exprComponents.lhs.empty() ? info.capturedExpression : m_exprComponents.op + m_exprComponents.lhs;
         else if( m_exprComponents.op == "matches" )
             return m_exprComponents.lhs + " " + m_exprComponents.rhs;
         else if( m_exprComponents.op != "!" ) {
-            if( m_exprComponents.lhs.size() + m_exprComponents.rhs.size() < 30 )
+            if( m_exprComponents.lhs.size() + m_exprComponents.rhs.size() < 40 &&
+                m_exprComponents.lhs.find("\n") == std::string::npos &&
+                m_exprComponents.rhs.find("\n") == std::string::npos )
                 return m_exprComponents.lhs + " " + m_exprComponents.op + " " + m_exprComponents.rhs;
-            else if( m_exprComponents.lhs.size() < 70 && m_exprComponents.rhs.size() < 70 )
-                return "\n\t" + m_exprComponents.lhs + "\n\t" + m_exprComponents.op + "\n\t" + m_exprComponents.rhs;
             else
-                return "\n" + m_exprComponents.lhs + "\n" + m_exprComponents.op + "\n" + m_exprComponents.rhs + "\n\n";
+                return m_exprComponents.lhs + "\n" + m_exprComponents.op + "\n" + m_exprComponents.rhs;
         }
         else
             return "{can't expand - use " + info.macroName + "_FALSE( " + info.capturedExpression.substr(1) + " ) instead of " + info.macroName + "( " + info.capturedExpression + " ) for better diagnostics}";

include/internal/catch_generators.hpp

@@ -30,7 +30,7 @@ public:
     BetweenGenerator( T from, T to ) : m_from( from ), m_to( to ){}
     
     virtual T getValue( std::size_t index ) const {
-        return m_from+static_cast<T>( index );
+        return m_from+static_cast<int>( index );
     }
     
     virtual std::size_t size() const {
@@ -69,12 +69,12 @@ class CompositeGenerator {
 public:
     CompositeGenerator() : m_totalSize( 0 ) {}
     
-	// *** Move semantics, similar to auto_ptr ***
+    // *** Move semantics, similar to auto_ptr ***
     CompositeGenerator( CompositeGenerator& other ) 
     :   m_fileInfo( other.m_fileInfo ), 
         m_totalSize( 0 ) 
     {
-		move( other );
+        move( other );
     }
     
     CompositeGenerator& setFileInfo( const char* fileInfo ) {
@@ -101,7 +101,7 @@ public:
             index += generator->size();
         }
         CATCH_INTERNAL_ERROR( "Indexed past end of generated range" );
-		return T(); // Suppress spurious "not all control paths return a value" warning in Visual Studio - if you know how to fix this please do so
+        return T(); // Suppress spurious "not all control paths return a value" warning in Visual Studio - if you know how to fix this please do so
     }
     
     void add( const IGenerator<T>* generator ) {

include/internal/catch_generators_impl.hpp

@@ -50,7 +50,7 @@ namespace Catch {
             deleteAll( m_generatorsInOrder );
         }
         
-        IGeneratorInfo& getGeneratorInfo( const std::string& fileInfo, std::size_t size ) {
+        IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) {
             std::map<std::string, IGeneratorInfo*>::const_iterator it = m_generatorsByName.find( fileInfo );
             if( it == m_generatorsByName.end() ) {
                 IGeneratorInfo* info = new GeneratorInfo( size );

include/internal/catch_impl.hpp

@@ -26,10 +26,15 @@
 #include "catch_expressionresult_builder.hpp"
 #include "catch_test_case_info.hpp"
 #include "catch_tags.hpp"
+#include "catch_version.hpp"
+#include "catch_text.hpp"
+#include "catch_message.hpp"
+#include "catch_legacy_reporter_adapter.hpp"
 
 #include "../reporters/catch_reporter_basic.hpp"
 #include "../reporters/catch_reporter_xml.hpp"
 #include "../reporters/catch_reporter_junit.hpp"
+#include "../reporters/catch_reporter_console.hpp"
 
 namespace Catch {
     NonCopyable::~NonCopyable() {}
@@ -46,7 +51,19 @@ namespace Catch {
     IReporter::~IReporter() {}
     IReporterFactory::~IReporterFactory() {}
     IReporterRegistry::~IReporterRegistry() {}
+    IStreamingReporter::~IStreamingReporter() {}
+    AssertionStats::~AssertionStats() {}
+    SectionStats::~SectionStats() {}
+    TestCaseStats::~TestCaseStats() {}
+    TestGroupStats::~TestGroupStats() {}
+    TestRunStats::~TestRunStats() {}
+    ThreadedSectionInfo::~ThreadedSectionInfo() {}
+    TestGroupNode::~TestGroupNode() {}
+    TestRunNode::~TestRunNode() {}
+
     BasicReporter::~BasicReporter() {}
+    StreamingReporterBase::~StreamingReporterBase() {}
+    ConsoleReporter::~ConsoleReporter() {}
     IRunner::~IRunner() {}
     IMutableContext::~IMutableContext() {}
     IConfig::~IConfig() {}
@@ -67,9 +84,9 @@ namespace Catch {
 
     void Config::dummy() {}
 
-    INTERNAL_CATCH_REGISTER_REPORTER( "basic", BasicReporter )
-    INTERNAL_CATCH_REGISTER_REPORTER( "xml", XmlReporter )
-    INTERNAL_CATCH_REGISTER_REPORTER( "junit", JunitReporter )
+    INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( "basic", BasicReporter )
+    INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( "xml", XmlReporter )
+    INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( "junit", JunitReporter )
 
 }
 

include/internal/catch_interfaces_capture.h

@@ -15,27 +15,29 @@
 
 namespace Catch {
 
-    class TestCaseInfo;
-    class ScopedInfo;
+    class TestCase;
     class ExpressionResultBuilder;
     class AssertionResult;
     struct AssertionInfo;
+    struct SectionInfo;
+    class MessageBuilder;
+    class ScopedMessageBuilder;
 
     struct IResultCapture {
     
         virtual ~IResultCapture();
         
-        virtual void testEnded( const AssertionResult& result ) = 0;
-        virtual bool sectionStarted(    const std::string& name, 
-                                        const std::string& description, 
-                                        const SourceLineInfo& lineInfo,
+        virtual void assertionEnded( AssertionResult const& result ) = 0;
+        virtual bool sectionStarted(    SectionInfo const& sectionInfo,
                                         Counts& assertions ) = 0;
-        virtual void sectionEnded( const std::string& name, const Counts& assertions ) = 0;
-        virtual void pushScopedInfo( ScopedInfo* scopedInfo ) = 0;
-        virtual void popScopedInfo( ScopedInfo* scopedInfo ) = 0;
+        virtual void sectionEnded( SectionInfo const& name, Counts const& assertions ) = 0;
+        virtual void pushScopedMessage( ScopedMessageBuilder const& _builder ) = 0;
+        virtual void popScopedMessage( ScopedMessageBuilder const& _builder ) = 0;
+        
         virtual bool shouldDebugBreak() const = 0;
         
-        virtual ResultAction::Value acceptExpression( const ExpressionResultBuilder& assertionResult, const AssertionInfo& assertionInfo ) = 0;
+        virtual void acceptMessage( MessageBuilder const& messageBuilder ) = 0;
+        virtual ResultAction::Value acceptExpression( ExpressionResultBuilder const& assertionResult, AssertionInfo const& assertionInfo ) = 0;
         
         virtual std::string getCurrentTestName() const = 0;        
         virtual const AssertionResult* getLastResult() const = 0;        

include/internal/catch_interfaces_config.h

@@ -8,13 +8,24 @@
 #ifndef TWOBLUECUBES_CATCH_INTERFACES_CONFIG_H_INCLUDED
 #define TWOBLUECUBES_CATCH_INTERFACES_CONFIG_H_INCLUDED
 
+#include <iostream>
+#include <string>
+
+#include "catch_ptr.hpp"
+
 namespace Catch {
 
-    struct IConfig {
+    struct IConfig : IShared {
     
         virtual ~IConfig();
         
         virtual bool allowThrows() const = 0;
+        virtual std::ostream& stream() const = 0;
+        virtual std::string name() const = 0;
+        virtual bool includeSuccessfulResults() const = 0;
+        virtual bool shouldDebugBreak() const = 0;
+        virtual bool warnAboutMissingAssertions() const = 0;
+        virtual int abortAfter() const = 0;
     };
 }
 

include/internal/catch_interfaces_generators.h

@@ -21,7 +21,7 @@ namespace Catch {
     struct IGeneratorsForTest {
         virtual ~IGeneratorsForTest();
 
-        virtual IGeneratorInfo& getGeneratorInfo( const std::string& fileInfo, std::size_t size ) = 0;
+        virtual IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) = 0;
         virtual bool moveNext() = 0;
     };
 

include/internal/catch_interfaces_registry_hub.h

@@ -15,7 +15,7 @@
 
 namespace Catch {
 
-    class TestCaseInfo;
+    class TestCase;
     struct ITestCaseRegistry;
     struct IExceptionTranslatorRegistry;
     struct IExceptionTranslator;
@@ -23,15 +23,15 @@ namespace Catch {
     struct IRegistryHub {
         virtual ~IRegistryHub();
 
-        virtual const IReporterRegistry& getReporterRegistry() const = 0;
-        virtual const ITestCaseRegistry& getTestCaseRegistry() const = 0;
+        virtual IReporterRegistry const& getReporterRegistry() const = 0;
+        virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
         virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() = 0;
     };
 
     struct IMutableRegistryHub {
         virtual ~IMutableRegistryHub();
-        virtual void registerReporter( const std::string& name, IReporterFactory* factory ) = 0;
-        virtual void registerTest( const TestCaseInfo& testInfo ) = 0;
+        virtual void registerReporter( std::string const& name, IReporterFactory* factory ) = 0;
+        virtual void registerTest( TestCase const& testInfo ) = 0;
         virtual void registerTranslator( const IExceptionTranslator* translator ) = 0;
     };
 

include/internal/catch_interfaces_reporter.h

@@ -12,6 +12,10 @@
 #include "catch_totals.hpp"
 #include "catch_ptr.hpp"
 #include "catch_config.hpp"
+#include "catch_test_case_info.h"
+#include "catch_assertionresult.h"
+#include "catch_message.h"
+#include "catch_option.hpp"
 
 #include <string>
 #include <ostream>
@@ -19,72 +23,298 @@
 
 namespace Catch
 {
-    struct ReporterConfig
-    {
-        ReporterConfig( const std::string& _name,
-                        std::ostream& _stream,
-                        bool _includeSuccessfulResults,
-                        const ConfigData& _fullConfig )
-        :   name( _name ),
-            stream( _stream ),
-            includeSuccessfulResults( _includeSuccessfulResults ),
-            fullConfig( _fullConfig )
-        {}
+    struct ReporterConfig {
+        explicit ReporterConfig( Ptr<IConfig> const& _fullConfig )
+        :   m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {}
 
-        ReporterConfig( const ReporterConfig& other )
-        :   name( other.name ),
-            stream( other.stream ),
-            includeSuccessfulResults( other.includeSuccessfulResults ),
-            fullConfig( other.fullConfig )
-        {}
+        ReporterConfig( Ptr<IConfig> const& _fullConfig, std::ostream& _stream )
+        :   m_stream( &_stream ), m_fullConfig( _fullConfig ) {}
 
-
-        std::string name;
-        std::ostream& stream;
-        bool includeSuccessfulResults;
-        ConfigData fullConfig;
+        std::ostream& stream() const    { return *m_stream; }
+        Ptr<IConfig> fullConfig() const { return m_fullConfig; }
 
     private:
-        void operator=(const ReporterConfig&);
+        std::ostream* m_stream;
+        Ptr<IConfig> m_fullConfig;
     };
 
-    class TestCaseInfo;
-    class AssertionResult;
+    struct ReporterPreferences {
+        ReporterPreferences()
+        : shouldRedirectStdOut( false )
+        {}
 
+        bool shouldRedirectStdOut;
+    };
+
+    struct TestRunInfo {
+        TestRunInfo( std::string const& _name ) : name( _name ) {}
+        std::string name;
+    };
+    struct GroupInfo {
+        GroupInfo(  std::string const& _name,
+                    std::size_t _groupIndex,
+                    std::size_t _groupsCount )
+        :   name( _name ),
+            groupIndex( _groupIndex ),
+            groupsCounts( _groupsCount )
+        {}
+
+        std::string name;
+        std::size_t groupIndex;
+        std::size_t groupsCounts;
+    };
+
+    struct SectionInfo {
+        SectionInfo(    std::string const& _name,
+                        std::string const& _description,
+                        SourceLineInfo const& _lineInfo )
+        :   name( _name ),
+            description( _description ),
+            lineInfo( _lineInfo )
+        {}
+
+        std::string name;
+        std::string description;
+        SourceLineInfo lineInfo;
+    };
+
+    struct ThreadedSectionInfo : SectionInfo, SharedImpl<> {
+        ThreadedSectionInfo( SectionInfo const& _sectionInfo, ThreadedSectionInfo* _parent = NULL )
+        :   SectionInfo( _sectionInfo ),
+            parent( _parent )
+        {}
+        virtual ~ThreadedSectionInfo();
+
+        std::vector<Ptr<ThreadedSectionInfo> > children;
+        ThreadedSectionInfo* parent;
+    };
+
+    struct AssertionStats {
+        AssertionStats( AssertionResult const& _assertionResult,
+                        std::vector<MessageInfo> const& _infoMessages,
+                        Totals const& _totals )
+        :   assertionResult( _assertionResult ),
+            infoMessages( _infoMessages ),
+            totals( _totals )
+        {
+            if( assertionResult.hasMessage() ) {
+                // Copy message into messages list.
+                // !TBD This should have been done earlier, somewhere
+                MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
+                builder << assertionResult.getMessage();
+                infoMessages.push_back( builder.build() );
+            }
+        }
+        virtual ~AssertionStats();
+        
+        AssertionResult assertionResult;
+        std::vector<MessageInfo> infoMessages;
+        Totals totals;
+    };
+
+    struct SectionStats {
+        SectionStats(   SectionInfo const& _sectionInfo,
+                        Counts const& _assertions,
+                        bool _missingAssertions )
+        :   sectionInfo( _sectionInfo ),
+            assertions( _assertions ),
+            missingAssertions( _missingAssertions )
+        {}
+        virtual ~SectionStats();
+
+        SectionInfo sectionInfo;
+        Counts assertions;
+        bool missingAssertions;
+    };
+
+    struct TestCaseStats {
+        TestCaseStats(  TestCaseInfo const& _testInfo,
+                        Totals const& _totals,
+                        std::string const& _stdOut,
+                        std::string const& _stdErr,
+                        bool _missingAssertions,
+                        bool _aborting )
+        : testInfo( _testInfo ),
+            totals( _totals ),
+            stdOut( _stdOut ),
+            stdErr( _stdErr ),
+            missingAssertions( _missingAssertions ),
+            aborting( _aborting )
+        {}
+        virtual ~TestCaseStats();
+
+        TestCaseInfo testInfo;
+        Totals totals;
+        std::string stdOut;
+        std::string stdErr;
+        bool missingAssertions;
+        bool aborting;
+    };
+    
+    struct TestGroupStats {
+        TestGroupStats( GroupInfo const& _groupInfo,
+                        Totals const& _totals,
+                        bool _aborting )
+        :   groupInfo( _groupInfo ),
+            totals( _totals ),
+            aborting( _aborting )
+        {}
+        TestGroupStats( GroupInfo const& _groupInfo )
+        :   groupInfo( _groupInfo ),
+            aborting( false )
+        {}
+        virtual ~TestGroupStats();
+
+        GroupInfo groupInfo;
+        Totals totals;
+        bool aborting;
+    };
+    
+    struct TestRunStats {
+        TestRunStats(   TestRunInfo const& _runInfo,
+                        Totals const& _totals,
+                        bool _aborting )
+        :   runInfo( _runInfo ),
+            totals( _totals ),
+            aborting( _aborting )
+        {}
+        TestRunStats( TestRunStats const& _other )
+        :   runInfo( _other.runInfo ),
+            totals( _other.totals ),
+            aborting( _other.aborting )
+        {}
+        virtual ~TestRunStats();
+
+        TestRunInfo runInfo;
+        Totals totals;
+        bool aborting;
+    };
+
+    struct IStreamingReporter : IShared {
+        virtual ~IStreamingReporter();
+
+        // Implementing class must also provide the following static method:
+        // static std::string getDescription();
+
+        virtual ReporterPreferences getPreferences() const = 0;
+        
+        virtual void noMatchingTestCases( std::string const& spec ) = 0;
+
+        virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
+        virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0;
+
+        virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
+        virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;
+
+        virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
+
+        virtual void assertionEnded( AssertionStats const& assertionStats ) = 0;
+        virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
+        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
+        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0;
+        virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
+    };
+
+    struct StreamingReporterBase : SharedImpl<IStreamingReporter> {
+
+        StreamingReporterBase( ReporterConfig const& _config )
+        :   m_config( _config.fullConfig() ),
+            stream( _config.stream() )
+        {}
+
+        virtual ~StreamingReporterBase();
+        
+        virtual void noMatchingTestCases( std::string const& ) {}
+
+        virtual void testRunStarting( TestRunInfo const& _testRunInfo ) {
+            testRunInfo = _testRunInfo;
+        }
+        virtual void testGroupStarting( GroupInfo const& _groupInfo ) {
+            unusedGroupInfo = _groupInfo;
+        }
+
+        virtual void testCaseStarting( TestCaseInfo const& _testInfo ) {
+            unusedTestCaseInfo = _testInfo;
+        }
+        virtual void sectionStarting( SectionInfo const& _sectionInfo ) {
+            Ptr<ThreadedSectionInfo> sectionInfo = new ThreadedSectionInfo( _sectionInfo );
+            if( !currentSectionInfo ) {
+                currentSectionInfo = sectionInfo;
+                m_rootSections.push_back( currentSectionInfo );
+            }
+            else {
+                currentSectionInfo->children.push_back( sectionInfo );
+                sectionInfo->parent = currentSectionInfo.get();
+                currentSectionInfo = sectionInfo;
+            }
+        }
+
+        virtual void sectionEnded( SectionStats const& /* _sectionStats */ ) {
+            currentSectionInfo = currentSectionInfo->parent;
+        }
+        virtual void testCaseEnded( TestCaseStats const& /* _testCaseStats */ ) {
+            unusedTestCaseInfo.reset();
+        }
+        virtual void testGroupEnded( TestGroupStats const& /* _testGroupStats */ ) {
+            unusedGroupInfo.reset();
+        }
+        virtual void testRunEnded( TestRunStats const& /* _testRunStats */ ) {
+            currentSectionInfo.reset();
+            unusedTestCaseInfo.reset();
+            unusedGroupInfo.reset();
+            testRunInfo.reset();
+        }
+
+        Ptr<IConfig> m_config;
+        Option<TestRunInfo> testRunInfo;
+        Option<GroupInfo> unusedGroupInfo;
+        Option<TestCaseInfo> unusedTestCaseInfo;
+        Ptr<ThreadedSectionInfo> currentSectionInfo;
+        std::ostream& stream;
+        
+        // !TBD: This should really go in the TestCaseStats class
+        std::vector<Ptr<ThreadedSectionInfo> > m_rootSections;        
+    };
+
+    struct TestGroupNode : TestGroupStats {
+        TestGroupNode( TestGroupStats const& _stats ) : TestGroupStats( _stats ) {}
+//        TestGroupNode( GroupInfo const& _info ) : TestGroupStats( _stats ) {}
+        ~TestGroupNode();
+
+    };
+
+    struct TestRunNode : TestRunStats {
+
+        TestRunNode( TestRunStats const& _stats ) : TestRunStats( _stats ) {}
+        ~TestRunNode();
+        
+        std::vector<TestGroupNode> groups;
+    };
+    
+    // Deprecated
     struct IReporter : IShared {
         virtual ~IReporter();
 
         virtual bool shouldRedirectStdout() const = 0;
 
         virtual void StartTesting() = 0;        
-        virtual void EndTesting( const Totals& totals ) = 0;        
-
-        virtual void StartGroup( const std::string& groupName ) = 0;
-        virtual void EndGroup( const std::string& groupName, const Totals& totals ) = 0;        
-
-        virtual void StartTestCase( const TestCaseInfo& testInfo ) = 0;
-        // TestCaseResult
-        virtual void EndTestCase( const TestCaseInfo& testInfo, const Totals& totals, const std::string& stdOut, const std::string& stdErr ) = 0;
-
-        // SectionInfo
-        virtual void StartSection( const std::string& sectionName, const std::string& description ) = 0;
-        // Section Result
-        virtual void EndSection( const std::string& sectionName, const Counts& assertions ) = 0;
-
-        // - merge into SectionResult ?
-        virtual void NoAssertionsInSection( const std::string& sectionName ) = 0;
-        virtual void NoAssertionsInTestCase( const std::string& testName ) = 0;
-
-        // - merge into SectionResult, TestCaseResult, GroupResult & TestRunResult
+        virtual void EndTesting( Totals const& totals ) = 0;
+        virtual void StartGroup( std::string const& groupName ) = 0;
+        virtual void EndGroup( std::string const& groupName, Totals const& totals ) = 0;
+        virtual void StartTestCase( TestCaseInfo const& testInfo ) = 0;
+        virtual void EndTestCase( TestCaseInfo const& testInfo, Totals const& totals, std::string const& stdOut, std::string const& stdErr ) = 0;
+        virtual void StartSection( std::string const& sectionName, std::string const& description ) = 0;
+        virtual void EndSection( std::string const& sectionName, Counts const& assertions ) = 0;
+        virtual void NoAssertionsInSection( std::string const& sectionName ) = 0;
+        virtual void NoAssertionsInTestCase( std::string const& testName ) = 0;
         virtual void Aborted() = 0;
-
-        // AssertionReslt
-        virtual void Result( const AssertionResult& result ) = 0;
+        virtual void Result( AssertionResult const& result ) = 0;
     };
 
+    
     struct IReporterFactory {
         virtual ~IReporterFactory();
-        virtual IReporter* create( const ReporterConfig& config ) const = 0;
+        virtual IStreamingReporter* create( ReporterConfig const& config ) const = 0;
         virtual std::string getDescription() const = 0;
     };
 
@@ -92,11 +322,11 @@ namespace Catch
         typedef std::map<std::string, IReporterFactory*> FactoryMap;
 
         virtual ~IReporterRegistry();
-        virtual IReporter* create( const std::string& name, const ReporterConfig& config ) const = 0;        
-        virtual const FactoryMap& getFactories() const = 0;
+        virtual IStreamingReporter* create( std::string const& name, Ptr<IConfig> const& config ) const = 0;        
+        virtual FactoryMap const& getFactories() const = 0;
     };
     
-    inline std::string trim( const std::string& str ) {
+    inline std::string trim( std::string const& str ) {
         std::string::size_type start = str.find_first_not_of( "\n\r\t " );
         std::string::size_type end = str.find_last_not_of( "\n\r\t " );
         

include/internal/catch_interfaces_runner.h

@@ -13,7 +13,7 @@
 #include <string>
 
 namespace Catch {
-    class TestCaseInfo;
+    class TestCase;
     
     struct IRunner {
         virtual ~IRunner();

include/internal/catch_interfaces_testcase.h

@@ -22,12 +22,12 @@ namespace Catch {
         virtual ~ITestCase();
     };
     
-    class TestCaseInfo;
+    class TestCase;
 
     struct ITestCaseRegistry {
         virtual ~ITestCaseRegistry();
-        virtual const std::vector<TestCaseInfo>& getAllTests() const = 0;
-        virtual std::vector<TestCaseInfo> getMatchingTestCases( const std::string& rawTestSpec ) const = 0;
+        virtual std::vector<TestCase> const& getAllTests() const = 0;
+        virtual std::vector<TestCase> getMatchingTestCases( std::string const& rawTestSpec ) const = 0;
     };
 }
 

include/internal/catch_legacy_reporter_adapter.h

@@ -0,0 +1,39 @@
+/*
+ *  Created by Phil on 6th April 2013.
+ *  Copyright 2013 Two Blue Cubes Ltd. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_H_INCLUDED
+#define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_H_INCLUDED
+
+#include "catch_interfaces_reporter.h"
+
+namespace Catch
+{
+    class LegacyReporterAdapter : public SharedImpl<IStreamingReporter>
+    {
+    public:
+        LegacyReporterAdapter( Ptr<IReporter> const& legacyReporter );
+        virtual ~LegacyReporterAdapter();
+
+        virtual ReporterPreferences getPreferences() const;
+        virtual void noMatchingTestCases( std::string const& );
+        virtual void testRunStarting( TestRunInfo const& );
+        virtual void testGroupStarting( GroupInfo const& groupInfo );
+        virtual void testCaseStarting( TestCaseInfo const& testInfo );
+        virtual void sectionStarting( SectionInfo const& sectionInfo );
+        virtual void assertionStarting( AssertionInfo const& );
+        virtual void assertionEnded( AssertionStats const& assertionStats );
+        virtual void sectionEnded( SectionStats const& sectionStats );
+        virtual void testCaseEnded( TestCaseStats const& testCaseStats );
+        virtual void testGroupEnded( TestGroupStats const& testGroupStats );
+        virtual void testRunEnded( TestRunStats const& testRunStats );
+
+    private:
+        Ptr<IReporter> m_legacyReporter;
+    };
+}
+
+#endif // TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_H_INCLUDED

include/internal/catch_legacy_reporter_adapter.hpp

@@ -0,0 +1,83 @@
+/*
+ *  Created by Phil on 6th April 2013.
+ *  Copyright 2013 Two Blue Cubes Ltd. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_HPP_INCLUDED
+
+#include "catch_legacy_reporter_adapter.h"
+
+namespace Catch
+{
+    LegacyReporterAdapter::LegacyReporterAdapter( Ptr<IReporter> const& legacyReporter )
+    :   m_legacyReporter( legacyReporter )
+    {}
+    LegacyReporterAdapter::~LegacyReporterAdapter() {}
+
+    ReporterPreferences LegacyReporterAdapter::getPreferences() const {
+        ReporterPreferences prefs;
+        prefs.shouldRedirectStdOut = m_legacyReporter->shouldRedirectStdout();
+        return prefs;
+    }
+
+    void LegacyReporterAdapter::noMatchingTestCases( std::string const& ) {}
+    void LegacyReporterAdapter::testRunStarting( TestRunInfo const& ) {
+        m_legacyReporter->StartTesting();
+    }
+    void LegacyReporterAdapter::testGroupStarting( GroupInfo const& groupInfo ) {
+        m_legacyReporter->StartGroup( groupInfo.name );
+    }
+    void LegacyReporterAdapter::testCaseStarting( TestCaseInfo const& testInfo ) {
+        m_legacyReporter->StartTestCase( testInfo );
+    }
+    void LegacyReporterAdapter::sectionStarting( SectionInfo const& sectionInfo ) {
+        m_legacyReporter->StartSection( sectionInfo.name, sectionInfo.description );
+    }
+    void LegacyReporterAdapter::assertionStarting( AssertionInfo const& ) {
+        // Not on legacy interface
+    }
+
+    void LegacyReporterAdapter::assertionEnded( AssertionStats const& assertionStats ) {
+        if( assertionStats.assertionResult.getResultType() != ResultWas::Ok ) {
+            for( std::vector<MessageInfo>::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end();
+                    it != itEnd;
+                    ++it ) {
+                if( it->type == ResultWas::Info ) {
+                    ExpressionResultBuilder expressionBuilder( it->type );
+                        expressionBuilder << it->message;
+                    AssertionInfo info( it->macroName, it->lineInfo, "", ResultDisposition::Normal );
+                    AssertionResult result = expressionBuilder.buildResult( info );
+                    m_legacyReporter->Result( result );
+                }
+            }
+        }    
+        m_legacyReporter->Result( assertionStats.assertionResult );
+    }
+    void LegacyReporterAdapter::sectionEnded( SectionStats const& sectionStats ) {
+        if( sectionStats.missingAssertions )
+            m_legacyReporter->NoAssertionsInSection( sectionStats.sectionInfo.name );
+        m_legacyReporter->EndSection( sectionStats.sectionInfo.name, sectionStats.assertions );
+    }
+    void LegacyReporterAdapter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+        if( testCaseStats.missingAssertions )
+            m_legacyReporter->NoAssertionsInTestCase( testCaseStats.testInfo.name );
+        m_legacyReporter->EndTestCase
+            (   testCaseStats.testInfo,
+                testCaseStats.totals,
+                testCaseStats.stdOut,
+                testCaseStats.stdErr );
+    }
+    void LegacyReporterAdapter::testGroupEnded( TestGroupStats const& testGroupStats ) {
+        if( testGroupStats.aborting )
+            m_legacyReporter->Aborted();
+        m_legacyReporter->EndGroup( testGroupStats.groupInfo.name, testGroupStats.totals );
+    }
+    void LegacyReporterAdapter::testRunEnded( TestRunStats const& testRunStats ) {
+        m_legacyReporter->EndTesting( testRunStats.totals );
+    }
+}
+
+#endif // TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_H_INCLUDED

include/internal/catch_list.hpp

@@ -9,10 +9,14 @@
 #define TWOBLUECUBES_CATCH_LIST_HPP_INCLUDED
 
 #include "catch_commandline.hpp"
+#include "catch_text.h"
+#include "catch_console_colour.hpp"
+
 #include <limits>
+#include <algorithm>
 
 namespace Catch {
-    inline bool matchesFilters( const std::vector<TestCaseFilters>& filters, const TestCaseInfo& testCase ) {
+    inline bool matchesFilters( std::vector<TestCaseFilters> const& filters, TestCase const& testCase ) {
         std::vector<TestCaseFilters>::const_iterator it = filters.begin();
         std::vector<TestCaseFilters>::const_iterator itEnd = filters.end();
         for(; it != itEnd; ++it )
@@ -20,47 +24,173 @@ namespace Catch {
                 return false;
         return true;
     }
-    inline void List( const ConfigData& config ) {
 
-        if( config.listSpec & List::Reports ) {
-            std::cout << "Available reports:\n";
-            IReporterRegistry::FactoryMap::const_iterator it = getRegistryHub().getReporterRegistry().getFactories().begin();
-            IReporterRegistry::FactoryMap::const_iterator itEnd = getRegistryHub().getReporterRegistry().getFactories().end();
-            for(; it != itEnd; ++it ) {
-                // !TBD: consider listAs()
-                std::cout << "\t" << it->first << "\n\t\t'" << it->second->getDescription() << "'\n";
+    inline std::size_t listTests( Config const& config ) {
+        if( config.filters().empty() )
+            std::cout << "All available test cases:\n";
+        else
+            std::cout << "Matching test cases:\n";
+        std::vector<TestCase> const& allTests = getRegistryHub().getTestCaseRegistry().getAllTests();
+        std::vector<TestCase>::const_iterator it = allTests.begin(), itEnd = allTests.end();
+
+        // First pass - get max tags
+        std::size_t maxTagLen = 0;
+        std::size_t maxNameLen = 0;
+        for(; it != itEnd; ++it ) {
+            if( matchesFilters( config.filters(), *it ) ) {
+                maxTagLen = (std::max)( it->getTestCaseInfo().tagsAsString.size(), maxTagLen );
+                maxNameLen = (std::max)( it->getTestCaseInfo().name.size(), maxNameLen );
             }
-            std::cout << std::endl;
         }
         
-        if( config.listSpec & List::Tests ) {
-            if( config.filters.empty() )
-                std::cout << "All available test cases:\n";
+        // Try to fit everything in. If not shrink tag column first, down to 30
+        // then shrink name column until it all fits (strings will be wrapped within column)
+        while( maxTagLen + maxNameLen > CATCH_CONFIG_CONSOLE_WIDTH-5 ) {
+            if( maxTagLen > 30 )
+                --maxTagLen;
             else
-                std::cout << "Matching test cases:\n";
-            std::vector<TestCaseInfo>::const_iterator it = getRegistryHub().getTestCaseRegistry().getAllTests().begin();
-            std::vector<TestCaseInfo>::const_iterator itEnd = getRegistryHub().getTestCaseRegistry().getAllTests().end();
-            std::size_t matchedTests = 0;
-            for(; it != itEnd; ++it ) {
-                if( matchesFilters( config.filters, *it ) ) {
-                    matchedTests++;
-                    // !TBD: consider listAs()
-                    std::cout << "\t" << it->getName() << "\n";
-                    if( ( config.listSpec & List::TestNames ) != List::TestNames )
-                        std::cout << "\t\t '" << it->getDescription() << "'\n";
+                --maxNameLen;
+        }
+
+        std::size_t matchedTests = 0;
+        for( it = allTests.begin(); it != itEnd; ++it ) {
+            if( matchesFilters( config.filters(), *it ) ) {
+                matchedTests++;
+                Text nameWrapper(   it->getTestCaseInfo().name,
+                                    TextAttributes()
+                                        .setWidth( maxNameLen )
+                                        .setInitialIndent(2)
+                                        .setIndent(4) );
+
+                Text tagsWrapper(   it->getTestCaseInfo().tagsAsString,
+                                    TextAttributes()
+                                        .setWidth( maxTagLen )
+                                        .setInitialIndent(0)
+                                        .setIndent( 2 ) );
+                
+                for( std::size_t i = 0; i < std::max( nameWrapper.size(), tagsWrapper.size() ); ++i ) {
+                    Colour::Code colour = Colour::None;
+                    if( it->getTestCaseInfo().isHidden )
+                        colour = Colour::SecondaryText;
+                    std::string nameCol;
+                    if( i < nameWrapper.size() ) {
+                        nameCol = nameWrapper[i];
+                    }
+                    else {
+                        nameCol = "    ...";
+                        colour = Colour::SecondaryText;
+                    }
+                    
+                    {
+                        Colour colourGuard( colour );
+                        std::cout << nameCol;
+                    }
+                    if( i < tagsWrapper.size() && !tagsWrapper[i].empty() ) {
+                        if( i == 0 ) {
+                            Colour colourGuard( Colour::SecondaryText );
+                            std::cout << "  " << std::string( maxNameLen - nameCol.size(), '.' ) << "  ";
+                        }
+                        else {
+                            std::cout << std::string( maxNameLen - nameCol.size(), ' ' ) << "    ";
+                        }
+                        std::cout << tagsWrapper[i];
+                    }
+                    std::cout << "\n";
                 }
             }
-            if( config.filters.empty() )
-                std::cout << pluralise( matchedTests, "test case" ) << std::endl;
-            else
-                std::cout << pluralise( matchedTests, "matching test case" ) << std::endl;
         }
+        if( config.filters().empty() )
+            std::cout << pluralise( matchedTests, "test case" ) << "\n" << std::endl;
+        else
+            std::cout << pluralise( matchedTests, "matching test case" ) << "\n" << std::endl;
+        return matchedTests;
+    }
     
-        if( ( config.listSpec & List::All ) == 0 ) {
-            std::ostringstream oss;
-            oss << "Unknown list type";
-            throw std::domain_error( oss.str() );
+    inline std::size_t listTags( Config const& config ) {
+        if( config.filters().empty() )
+            std::cout << "All available tags:\n";
+        else
+            std::cout << "Matching tags:\n";
+        std::vector<TestCase> const& allTests = getRegistryHub().getTestCaseRegistry().getAllTests();
+        std::vector<TestCase>::const_iterator it = allTests.begin(), itEnd = allTests.end();
+
+        std::map<std::string, int> tagCounts;
+        
+        std::size_t maxTagLen = 0;
+
+        for(; it != itEnd; ++it ) {
+            if( matchesFilters( config.filters(), *it ) ) {
+                for( std::set<std::string>::const_iterator  tagIt = it->getTestCaseInfo().tags.begin(),
+                                                            tagItEnd = it->getTestCaseInfo().tags.end();
+                        tagIt != tagItEnd;
+                        ++tagIt ) {
+                    std::string tagName = *tagIt;
+                    maxTagLen = (std::max)( maxTagLen, tagName.size() );
+                    std::map<std::string, int>::iterator countIt = tagCounts.find( tagName );
+                    if( countIt == tagCounts.end() )
+                        tagCounts.insert( std::make_pair( tagName, 1 ) );
+                    else
+                        countIt->second++;
+                }
+            }
         }
+        maxTagLen +=4;
+        if( maxTagLen > CATCH_CONFIG_CONSOLE_WIDTH-10 )
+            maxTagLen = CATCH_CONFIG_CONSOLE_WIDTH-10;
+        
+        for( std::map<std::string, int>::const_iterator countIt = tagCounts.begin(), countItEnd = tagCounts.end();
+                countIt != countItEnd;
+                ++countIt ) {            
+            Text wrapper( "[" + countIt->first + "]", TextAttributes()
+                                                        .setIndent(2)
+                                                        .setWidth( maxTagLen ) );
+            std::cout << wrapper;
+            std::size_t dots = 2;
+            if( maxTagLen > wrapper.last().size() )
+                dots += maxTagLen - wrapper.last().size();
+            {
+                Colour colourGuard( Colour::SecondaryText );
+                std::cout << std::string( dots, '.' );
+            }
+            std::cout   << countIt->second
+                        << "\n";
+        }
+        std::cout << pluralise( tagCounts.size(), "tag" ) << "\n" << std::endl;
+        return tagCounts.size();
+    }
+
+    inline std::size_t listReporters( Config const& /*config*/ ) {
+        std::cout << "Available reports:\n";
+        IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
+        IReporterRegistry::FactoryMap::const_iterator itBegin = factories.begin(), itEnd = factories.end(), it;
+        std::size_t maxNameLen = 0;
+        for(it = itBegin; it != itEnd; ++it )
+            maxNameLen = (std::max)( maxNameLen, it->first.size() );
+    
+        for(it = itBegin; it != itEnd; ++it ) {
+            Text wrapper( it->second->getDescription(), TextAttributes()
+                                                        .setInitialIndent( 0 )
+                                                        .setIndent( 7+maxNameLen )
+                                                        .setWidth( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen-8 ) );
+            std::cout << "  "
+                    << it->first
+                    << ":"
+                    << std::string( maxNameLen - it->first.size() + 2, ' ' )
+                    << wrapper << "\n";
+        }
+        std::cout << std::endl;
+        return factories.size();
+    }
+    
+    inline Option<std::size_t> list( Config const& config ) {
+        Option<std::size_t> listedCount;
+        if( config.listTests() )
+            listedCount = listedCount.valueOr(0) + listTests( config );
+        if( config.listTags() )
+            listedCount = listedCount.valueOr(0) + listTags( config );
+        if( config.listReporters() )
+            listedCount = listedCount.valueOr(0) + listReporters( config );
+        return listedCount;
     }
     
 } // end namespace Catch

include/internal/catch_matchers.hpp

@@ -19,7 +19,7 @@ namespace Matchers {
 
         virtual ~Matcher() {}
         virtual Ptr<Matcher> clone() const = 0;
-        virtual bool match( const ExpressionT& expr ) const = 0;
+        virtual bool match( ExpressionT const& expr ) const = 0;
         virtual std::string toString() const = 0;
     };
 
@@ -27,7 +27,7 @@ namespace Matchers {
     struct MatcherImpl : Matcher<ExpressionT> {
 
         virtual Ptr<Matcher<ExpressionT> > clone() const {
-            return Ptr<Matcher<ExpressionT> >( new DerivedT( static_cast<const DerivedT&>( *this ) ) );
+            return Ptr<Matcher<ExpressionT> >( new DerivedT( static_cast<DerivedT const&>( *this ) ) );
         }
     };
 
@@ -38,13 +38,13 @@ namespace Matchers {
         public:
 
             AllOf() {}
-            AllOf( const AllOf& other ) : m_matchers( other.m_matchers ) {}
+            AllOf( AllOf const& other ) : m_matchers( other.m_matchers ) {}
 
-            AllOf& add( const Matcher<ExpressionT>& matcher ) {
+            AllOf& add( Matcher<ExpressionT> const& matcher ) {
                 m_matchers.push_back( matcher.clone() );
                 return *this;
             }
-            virtual bool match( const ExpressionT& expr ) const
+            virtual bool match( ExpressionT const& expr ) const
             {
                 for( std::size_t i = 0; i < m_matchers.size(); ++i )
                     if( !m_matchers[i]->match( expr ) )
@@ -72,13 +72,13 @@ namespace Matchers {
         public:
 
             AnyOf() {}
-            AnyOf( const AnyOf& other ) : m_matchers( other.m_matchers ) {}
+            AnyOf( AnyOf const& other ) : m_matchers( other.m_matchers ) {}
 
-            AnyOf& add( const Matcher<ExpressionT>& matcher ) {
+            AnyOf& add( Matcher<ExpressionT> const& matcher ) {
                 m_matchers.push_back( matcher.clone() );
                 return *this;
             }
-            virtual bool match( const ExpressionT& expr ) const
+            virtual bool match( ExpressionT const& expr ) const
             {
                 for( std::size_t i = 0; i < m_matchers.size(); ++i )
                     if( m_matchers[i]->match( expr ) )
@@ -105,13 +105,16 @@ namespace Matchers {
 
     namespace StdString {
 
+        inline std::string makeString( std::string const& str ) { return str; }
+        inline std::string makeString( const char* str ) { return str ? std::string( str ) : std::string(); }
+        
         struct Equals : MatcherImpl<Equals, std::string> {
-            Equals( const std::string& str ) : m_str( str ){}
-            Equals( const Equals& other ) : m_str( other.m_str ){}
+            Equals( std::string const& str ) : m_str( str ){}
+            Equals( Equals const& other ) : m_str( other.m_str ){}
 
             virtual ~Equals();
 
-            virtual bool match( const std::string& expr ) const {
+            virtual bool match( std::string const& expr ) const {
                 return m_str == expr;
             }
             virtual std::string toString() const {
@@ -122,12 +125,12 @@ namespace Matchers {
         };
         
         struct Contains : MatcherImpl<Contains, std::string> {
-            Contains( const std::string& substr ) : m_substr( substr ){}
-            Contains( const Contains& other ) : m_substr( other.m_substr ){}
+            Contains( std::string const& substr ) : m_substr( substr ){}
+            Contains( Contains const& other ) : m_substr( other.m_substr ){}
 
             virtual ~Contains();
 
-            virtual bool match( const std::string& expr ) const {
+            virtual bool match( std::string const& expr ) const {
                 return expr.find( m_substr ) != std::string::npos;
             }
             virtual std::string toString() const {
@@ -138,12 +141,12 @@ namespace Matchers {
         };
         
         struct StartsWith : MatcherImpl<StartsWith, std::string> {
-            StartsWith( const std::string& substr ) : m_substr( substr ){}
-            StartsWith( const StartsWith& other ) : m_substr( other.m_substr ){}
+            StartsWith( std::string const& substr ) : m_substr( substr ){}
+            StartsWith( StartsWith const& other ) : m_substr( other.m_substr ){}
 
             virtual ~StartsWith();
 
-            virtual bool match( const std::string& expr ) const {
+            virtual bool match( std::string const& expr ) const {
                 return expr.find( m_substr ) == 0;
             }
             virtual std::string toString() const {
@@ -154,12 +157,12 @@ namespace Matchers {
         };
         
         struct EndsWith : MatcherImpl<EndsWith, std::string> {
-            EndsWith( const std::string& substr ) : m_substr( substr ){}
-            EndsWith( const EndsWith& other ) : m_substr( other.m_substr ){}
+            EndsWith( std::string const& substr ) : m_substr( substr ){}
+            EndsWith( EndsWith const& other ) : m_substr( other.m_substr ){}
 
             virtual ~EndsWith();
 
-            virtual bool match( const std::string& expr ) const {
+            virtual bool match( std::string const& expr ) const {
                 return expr.find( m_substr ) == expr.size() - m_substr.size();
             }
             virtual std::string toString() const {
@@ -174,32 +177,52 @@ namespace Matchers {
     // The following functions create the actual matcher objects.
     // This allows the types to be inferred
     template<typename ExpressionT>
-    inline Impl::Generic::AllOf<ExpressionT> AllOf( const Impl::Matcher<ExpressionT>& m1,
-                                                    const Impl::Matcher<ExpressionT>& m2 ) {
+    inline Impl::Generic::AllOf<ExpressionT> AllOf( Impl::Matcher<ExpressionT> const& m1,
+                                                    Impl::Matcher<ExpressionT> const& m2 ) {
         return Impl::Generic::AllOf<ExpressionT>().add( m1 ).add( m2 );
     }
     template<typename ExpressionT>
-    inline Impl::Generic::AllOf<ExpressionT> AllOf( const Impl::Matcher<ExpressionT>& m1,
-                                                    const Impl::Matcher<ExpressionT>& m2,
-                                                    const Impl::Matcher<ExpressionT>& m3 ) {
+    inline Impl::Generic::AllOf<ExpressionT> AllOf( Impl::Matcher<ExpressionT> const& m1,
+                                                    Impl::Matcher<ExpressionT> const& m2,
+                                                    Impl::Matcher<ExpressionT> const& m3 ) {
         return Impl::Generic::AllOf<ExpressionT>().add( m1 ).add( m2 ).add( m3 );
     }
     template<typename ExpressionT>
-    inline Impl::Generic::AnyOf<ExpressionT> AnyOf( const Impl::Matcher<ExpressionT>& m1,
-                                                    const Impl::Matcher<ExpressionT>& m2 ) {
+    inline Impl::Generic::AnyOf<ExpressionT> AnyOf( Impl::Matcher<ExpressionT> const& m1,
+                                                    Impl::Matcher<ExpressionT> const& m2 ) {
         return Impl::Generic::AnyOf<ExpressionT>().add( m1 ).add( m2 );
     }
     template<typename ExpressionT>
-    inline Impl::Generic::AnyOf<ExpressionT> AnyOf( const Impl::Matcher<ExpressionT>& m1,
-                                                    const Impl::Matcher<ExpressionT>& m2,
-                                                    const Impl::Matcher<ExpressionT>& m3 ) {
+    inline Impl::Generic::AnyOf<ExpressionT> AnyOf( Impl::Matcher<ExpressionT> const& m1,
+                                                    Impl::Matcher<ExpressionT> const& m2,
+                                                    Impl::Matcher<ExpressionT> const& m3 ) {
         return Impl::Generic::AnyOf<ExpressionT>().add( m1 ).add( m2 ).add( m3 );
     }
 
-    inline Impl::StdString::Equals      Equals( const std::string& str ){ return Impl::StdString::Equals( str ); }
-    inline Impl::StdString::Contains    Contains( const std::string& substr ){ return Impl::StdString::Contains( substr ); }
-    inline Impl::StdString::StartsWith  StartsWith( const std::string& substr ){ return Impl::StdString::StartsWith( substr ); }
-    inline Impl::StdString::EndsWith    EndsWith( const std::string& substr ){ return Impl::StdString::EndsWith( substr ); }
+    inline Impl::StdString::Equals      Equals( std::string const& str ) {
+        return Impl::StdString::Equals( str );
+    }
+    inline Impl::StdString::Equals      Equals( const char* str ) {
+        return Impl::StdString::Equals( Impl::StdString::makeString( str ) );
+    }
+    inline Impl::StdString::Contains    Contains( std::string const& substr ) {
+        return Impl::StdString::Contains( substr );
+    }
+    inline Impl::StdString::Contains    Contains( const char* substr ) {
+        return Impl::StdString::Contains( Impl::StdString::makeString( substr ) );
+    }
+    inline Impl::StdString::StartsWith  StartsWith( std::string const& substr ) {
+        return Impl::StdString::StartsWith( substr );
+    }
+    inline Impl::StdString::StartsWith  StartsWith( const char* substr ) {
+        return Impl::StdString::StartsWith( Impl::StdString::makeString( substr ) );
+    }
+    inline Impl::StdString::EndsWith    EndsWith( std::string const& substr ) {
+        return Impl::StdString::EndsWith( substr );
+    }
+    inline Impl::StdString::EndsWith    EndsWith( const char* substr ) {
+        return Impl::StdString::EndsWith( Impl::StdString::makeString( substr ) );
+    }
     
 } // namespace Matchers
     

include/internal/catch_message.h

@@ -0,0 +1,66 @@
+/*
+ *  Created by Phil Nash on 1/2/2013.
+ *  Copyright 2013 Two Blue Cubes Ltd. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_CATCH_MESSAGE_H_INCLUDED
+#define TWOBLUECUBES_CATCH_MESSAGE_H_INCLUDED
+
+#include <string>
+#include "catch_result_type.h"
+#include "catch_common.h"
+
+namespace Catch {
+    
+    struct MessageInfo {
+        MessageInfo(    std::string const& _macroName,
+                        SourceLineInfo const& _lineInfo,
+                        ResultWas::OfType _type );
+
+        std::string macroName;
+        SourceLineInfo lineInfo;
+        ResultWas::OfType type;
+        std::string message;
+        unsigned int sequence;
+        
+        bool operator == ( MessageInfo const& other ) const {
+            return sequence == other.sequence;
+        }
+        bool operator < ( MessageInfo const& other ) const {
+            return sequence < other.sequence;
+        }
+    private:
+        static unsigned int globalCount;
+    };
+    
+    
+    class MessageBuilder : public MessageInfo {
+    public:
+        MessageBuilder( std::string const& _macroName,
+                       SourceLineInfo const& _lineInfo,
+                       ResultWas::OfType _type );
+        
+        MessageInfo build() const;
+        
+        template<typename T>
+        MessageBuilder& operator << ( T const& _value ) {
+            stream << _value;
+            return *this;
+        }
+    private:
+        std::ostringstream stream;
+    };
+    
+    class ScopedMessageBuilder : public MessageBuilder {
+    public:
+        ScopedMessageBuilder(   std::string const& _macroName,
+                                SourceLineInfo const& _lineInfo,
+                                ResultWas::OfType _type );
+        ~ScopedMessageBuilder();
+    };
+
+} // end namespace Catch
+
+#endif // TWOBLUECUBES_CATCH_MESSAGE_H_INCLUDED

include/internal/catch_message.hpp

@@ -0,0 +1,57 @@
+/*
+ *  Created by Phil Nash on 1/2/2013.
+ *  Copyright 2013 Two Blue Cubes Ltd. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_CATCH_MESSAGE_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_MESSAGE_HPP_INCLUDED
+
+#include "catch_message.h"
+
+namespace Catch {
+        
+    MessageInfo::MessageInfo(   std::string const& _macroName,
+                                SourceLineInfo const& _lineInfo,
+                                ResultWas::OfType _type )
+    :   macroName( _macroName ),
+        lineInfo( _lineInfo ),
+        type( _type ),
+        sequence( ++globalCount )
+    {}
+    
+    // This may need protecting if threading support is added
+    unsigned int MessageInfo::globalCount = 0;
+    
+    ////////////////////////////////////////////////////////////////////////////
+    
+    MessageBuilder::MessageBuilder( std::string const& _macroName,
+                                    SourceLineInfo const& _lineInfo,
+                                    ResultWas::OfType _type )
+    :   MessageInfo( _macroName, _lineInfo, _type )
+    {}
+    
+    MessageInfo MessageBuilder::build() const {
+        MessageInfo message = *this;
+        message.message = stream.str();
+        return message;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ScopedMessageBuilder::ScopedMessageBuilder
+        (   std::string const& _macroName,
+            SourceLineInfo const& _lineInfo,
+            ResultWas::OfType _type )
+    : MessageBuilder( _macroName, _lineInfo, _type )
+    {}
+    
+    ScopedMessageBuilder::~ScopedMessageBuilder() {
+        getResultCapture().popScopedMessage( *this );
+    }
+    
+    
+} // end namespace Catch
+
+#endif // TWOBLUECUBES_CATCH_MESSAGE_HPP_INCLUDED

include/internal/catch_notimplemented_exception.h

@@ -16,7 +16,7 @@ namespace Catch {
     class NotImplementedException : public std::exception
     {
     public:
-        NotImplementedException( const SourceLineInfo& lineInfo );
+        NotImplementedException( SourceLineInfo const& lineInfo );
 
         virtual ~NotImplementedException() throw() {}
 

include/internal/catch_notimplemented_exception.hpp

@@ -13,10 +13,10 @@
 
 namespace Catch {
 
-    NotImplementedException::NotImplementedException( const SourceLineInfo& lineInfo )
+    NotImplementedException::NotImplementedException( SourceLineInfo const& lineInfo )
     :   m_lineInfo( lineInfo ) {
         std::ostringstream oss;
-        oss << lineInfo << "function ";
+        oss << lineInfo << ": function ";
         oss << "not implemented";
         m_what = oss.str();
     }

include/internal/catch_objc.hpp

@@ -56,13 +56,13 @@ namespace Catch {
     
     namespace Detail{
     
-        inline bool startsWith( const std::string& str, const std::string& sub ) {
+        inline bool startsWith( std::string const& str, std::string const& sub ) {
             return str.length() > sub.length() && str.substr( 0, sub.length() ) == sub;
         }
         
         inline std::string getAnnotation(   Class cls, 
-                                            const std::string& annotationName, 
-                                            const std::string& testCaseName ) {
+                                            std::string const& annotationName, 
+                                            std::string const& testCaseName ) {
             NSString* selStr = [[NSString alloc] initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()];
             SEL sel = NSSelectorFromString( selStr );
             arcSafeRelease( selStr );
@@ -94,7 +94,7 @@ namespace Catch {
                         std::string desc = Detail::getAnnotation( cls, "Description", testCaseName );
                         const char* className = class_getName( cls );
                         
-                        getMutableRegistryHub().registerTest( TestCaseInfo( new OcMethod( cls, selector ), className, name.c_str(), desc.c_str(), SourceLineInfo() ) );
+                        getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, name.c_str(), desc.c_str(), SourceLineInfo() ) );
                         noTestMethods++;
                     }
                 }

include/internal/catch_option.hpp

@@ -0,0 +1,67 @@
+/*
+ *  Created by Phil on 02/12/2012.
+ *  Copyright 2012 Two Blue Cubes Ltd. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_CATCH_OPTION_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_OPTION_HPP_INCLUDED
+
+#include "catch_common.h"
+
+namespace Catch {
+
+    // An optional type
+    template<typename T>
+    class Option {
+    public:
+        Option() : nullableValue( NULL ) {}
+        Option( T const& _value )
+        : nullableValue( new( storage ) T( _value ) )
+        {}
+        Option( Option const& _other )
+        : nullableValue( _other ? new( storage ) T( *_other ) : NULL )
+        {}
+        
+        ~Option() {
+            reset();
+        }
+
+        Option& operator= ( Option const& _other ) {
+            reset();
+            if( _other )
+                nullableValue = new( storage ) T( *_other );
+            return *this;
+        }
+
+        void reset() {
+            if( nullableValue )
+                nullableValue->~T();
+            nullableValue = NULL;
+        }
+        T& operator*() { return *nullableValue; }
+        T const& operator*() const { return *nullableValue; }
+        T* operator->() { return nullableValue; }
+        const T* operator->() const { return nullableValue; }
+
+        T valueOr( T const& defaultValue ) const {
+            return nullableValue ? *nullableValue : defaultValue;
+        }
+
+        bool some() const { return nullableValue != NULL; }
+        bool none() const { return nullableValue == NULL; }
+        
+        bool operator !() const { return nullableValue == NULL; }
+        operator SafeBool::type() const {
+            return SafeBool::makeSafe( some() );
+        }
+
+    private:
+        T* nullableValue;
+        char storage[sizeof(T)];
+    };
+
+} // end namespace Catch
+
+#endif // TWOBLUECUBES_CATCH_OPTION_HPP_INCLUDED

include/internal/catch_ptr.hpp

@@ -10,6 +10,11 @@
 
 #include "catch_common.h"
 
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
 namespace Catch {
 
     // An intrusive reference counting smart pointer.
@@ -23,7 +28,7 @@ namespace Catch {
             if( m_p )
                 m_p->addRef();
         }
-        Ptr( const Ptr& other ) : m_p( other.m_p ){
+        Ptr( Ptr const& other ) : m_p( other.m_p ){
             if( m_p )
                 m_p->addRef();
         }
@@ -31,38 +36,28 @@ namespace Catch {
             if( m_p )
                 m_p->release();
         }
+        void reset() {
+            if( m_p )
+                m_p->release();
+            m_p = NULL;
+        }
         Ptr& operator = ( T* p ){
             Ptr temp( p );
             swap( temp );
             return *this;
         }
-        Ptr& operator = ( const Ptr& other ){
+        Ptr& operator = ( Ptr const& other ){
             Ptr temp( other );
             swap( temp );
             return *this;
         }
-        void swap( Ptr& other ){
-            std::swap( m_p, other.m_p );
-        }
-        
-        T* get(){
-            return m_p;
-        }
-        const T* get() const{
-            return m_p;
-        }
-        
-        T& operator*() const {
-            return *m_p;
-        }
-
-        T* operator->() const {
-            return m_p;
-        }
-        
-        bool operator !() const {
-            return m_p == NULL;
-        }
+        void swap( Ptr& other ) { std::swap( m_p, other.m_p ); }
+        T* get() { return m_p; }
+        const T* get() const{ return m_p; }
+        T& operator*() const { return *m_p; }
+        T* operator->() const { return m_p; }
+        bool operator !() const { return m_p == NULL; }
+        operator SafeBool::type() const { return SafeBool::makeSafe( m_p != NULL ); }
         
     private:
         T* m_p;
@@ -70,26 +65,30 @@ namespace Catch {
     
     struct IShared : NonCopyable {
         virtual ~IShared();
-        virtual void addRef() = 0;
-        virtual void release() = 0;
+        virtual void addRef() const = 0;
+        virtual void release() const = 0;
     };
     
-    template<typename T>
+    template<typename T = IShared>
     struct SharedImpl : T {
         
         SharedImpl() : m_rc( 0 ){}
 
-        virtual void addRef(){
+        virtual void addRef() const {
             ++m_rc;
         }
-        virtual void release(){
+        virtual void release() const {
             if( --m_rc == 0 )
                 delete this;
         }
         
-        int m_rc;
+        mutable unsigned int m_rc;
     };
     
 } // end namespace Catch
 
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
 #endif // TWOBLUECUBES_CATCH_PTR_HPP_INCLUDED

include/internal/catch_registry_hub.hpp

@@ -20,16 +20,16 @@ namespace Catch {
         
         class RegistryHub : public IRegistryHub, public IMutableRegistryHub {
 
-            RegistryHub( const RegistryHub& );
-            void operator=( const RegistryHub& );
+            RegistryHub( RegistryHub const& );
+            void operator=( RegistryHub const& );
 
         public: // IRegistryHub
             RegistryHub() {
             }
-            virtual const IReporterRegistry& getReporterRegistry() const {
+            virtual IReporterRegistry const& getReporterRegistry() const {
                 return m_reporterRegistry;
             }
-            virtual const ITestCaseRegistry& getTestCaseRegistry() const {
+            virtual ITestCaseRegistry const& getTestCaseRegistry() const {
                 return m_testCaseRegistry;
             }
             virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() {
@@ -37,10 +37,10 @@ namespace Catch {
             }
 
         public: // IMutableRegistryHub
-            virtual void registerReporter( const std::string& name, IReporterFactory* factory ) {
+            virtual void registerReporter( std::string const& name, IReporterFactory* factory ) {
                 m_reporterRegistry.registerReporter( name, factory );
             }
-            virtual void registerTest( const TestCaseInfo& testInfo ) {
+            virtual void registerTest( TestCase const& testInfo ) {
                 m_testCaseRegistry.registerTest( testInfo );
             }
             virtual void registerTranslator( const IExceptionTranslator* translator ) {

include/internal/catch_reporter_registrars.hpp

@@ -9,15 +9,48 @@
 #define TWOBLUECUBES_CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
 
 #include "catch_interfaces_registry_hub.h"
+#include "catch_legacy_reporter_adapter.h"
 
 namespace Catch {    
 
+    template<typename T>
+    class LegacyReporterRegistrar {
+    
+        class ReporterFactory : public IReporterFactory {
+
+            virtual IStreamingReporter* create( ReporterConfig const& config ) const {
+                return new LegacyReporterAdapter( new T( config ) );
+            }
+            
+            virtual std::string getDescription() const {
+                return T::getDescription();
+            }
+        };
+        
+    public:
+
+        LegacyReporterRegistrar( std::string const& name ) {
+            getMutableRegistryHub().registerReporter( name, new ReporterFactory() );
+        }
+    };
+
     template<typename T>
     class ReporterRegistrar {
 
         class ReporterFactory : public IReporterFactory {
 
-            virtual IReporter* create( const ReporterConfig& config ) const {
+            // *** Please Note ***:
+            // - If you end up here looking at a compiler error because it's trying to register
+            // your custom reporter class be aware that the native reporter interface has changed
+            // to IStreamingReporter. The "legacy" interface, IReporter, is still supported via
+            // an adapter. Just use REGISTER_LEGACY_REPORTER to take advantage of the adapter.
+            // However please consider updating to the new interface as the old one is now
+            // deprecated and will probably be removed quite soon!
+            // Please contact me via github if you have any questions at all about this.
+            // In fact, ideally, please contact me anyway to let me know you've hit this - as I have
+            // no idea who is actually using custom reporters at all (possibly no-one!).
+            // The new interface is designed to minimise exposure to interface changes in the future.
+            virtual IStreamingReporter* create( ReporterConfig const& config ) const {
                 return new T( config );
             }
 
@@ -28,12 +61,14 @@ namespace Catch {
 
     public:
 
-        ReporterRegistrar( const std::string& name ) {
+        ReporterRegistrar( std::string const& name ) {
             getMutableRegistryHub().registerReporter( name, new ReporterFactory() );
         }
     }; 
 }
 
+#define INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) \
+    Catch::LegacyReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name );
 #define INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType ) \
     Catch::ReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name );
 

include/internal/catch_reporter_registry.hpp

@@ -22,18 +22,18 @@ namespace Catch {
             deleteAllValues( m_factories );
         }
         
-        virtual IReporter* create( const std::string& name, const ReporterConfig& config ) const {
+        virtual IStreamingReporter* create( std::string const& name, Ptr<IConfig> const& config ) const {
             FactoryMap::const_iterator it =  m_factories.find( name );
             if( it == m_factories.end() )
                 return NULL;
-            return it->second->create( config );
+            return it->second->create( ReporterConfig( config ) );
         }
         
-        void registerReporter( const std::string& name, IReporterFactory* factory ) {
+        void registerReporter( std::string const& name, IReporterFactory* factory ) {
             m_factories.insert( std::make_pair( name, factory ) );
         }        
 
-        const FactoryMap& getFactories() const {
+        FactoryMap const& getFactories() const {
             return m_factories;
         }
 

include/internal/catch_result_type.h

@@ -32,6 +32,9 @@ namespace Catch {
     inline bool isOk( ResultWas::OfType resultType ) {
         return ( resultType & ResultWas::FailureBit ) == 0;
     }
+    inline bool isJustInfo( int flags ) {
+        return flags == ResultWas::Info;
+    }
 
     // ResultAction::Value enum
     struct ResultAction { enum Value {
@@ -54,9 +57,9 @@ namespace Catch {
         return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) | static_cast<int>( rhs ) );
     }
 
-    inline bool shouldContinueOnFailure( int flags ) { return flags & ResultDisposition::ContinueOnFailure; }
-    inline bool shouldNegate( int flags ) { return flags & ResultDisposition::NegateResult; }
-    inline bool shouldSuppressFailure( int flags ) { return flags & ResultDisposition::SuppressFail; }
+    inline bool shouldContinueOnFailure( int flags )    { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }
+    inline bool shouldNegate( int flags )               { return ( flags & ResultDisposition::NegateResult ) != 0; }
+    inline bool shouldSuppressFailure( int flags )      { return ( flags & ResultDisposition::SuppressFail ) != 0; }
 
 } // end namespace Catch
 

include/internal/catch_runner_impl.hpp

@@ -49,15 +49,16 @@ namespace Catch {
 
     ///////////////////////////////////////////////////////////////////////////
 
-    class Runner : public IResultCapture, public IRunner {
+    class RunContext : public IResultCapture, public IRunner {
     
-        Runner( const Runner& );
-        void operator =( const Runner& );
+        RunContext( RunContext const& );
+        void operator =( RunContext const& );
         
     public:
 
-        explicit Runner( const Config& config, const Ptr<IReporter>& reporter )
-        :   m_context( getCurrentMutableContext() ),
+        explicit RunContext( Ptr<IConfig const> const& config, Ptr<IStreamingReporter> const& reporter )
+        :   m_runInfo( config->name() ),
+            m_context( getCurrentMutableContext() ),
             m_runningTest( NULL ),
             m_config( config ),
             m_reporter( reporter ),
@@ -66,46 +67,54 @@ namespace Catch {
             m_prevConfig( m_context.getConfig() )
         {
             m_context.setRunner( this );
-            m_context.setConfig( &m_config );
+            m_context.setConfig( m_config );
             m_context.setResultCapture( this );
-            m_reporter->StartTesting();
+            m_reporter->testRunStarting( m_runInfo );
         }
         
-        virtual ~Runner() {
-            m_reporter->EndTesting( m_totals );
+        virtual ~RunContext() {
+            m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, aborting() ) );
             m_context.setRunner( m_prevRunner );
             m_context.setConfig( NULL );
             m_context.setResultCapture( m_prevResultCapture );
             m_context.setConfig( m_prevConfig );
         }
 
-        Totals runMatching( const std::string& testSpec ) {
+        void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount ) {
+            m_reporter->testGroupStarting( GroupInfo( testSpec, groupIndex, groupsCount ) );
+        }
+        void testGroupEnded( std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount ) {
+            m_reporter->testGroupEnded( TestGroupStats( GroupInfo( testSpec, groupIndex, groupsCount ), totals, aborting() ) );
+        }
 
-            std::vector<TestCaseInfo> matchingTests = getRegistryHub().getTestCaseRegistry().getMatchingTestCases( testSpec );
+        Totals runMatching( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount ) {
+
+            std::vector<TestCase> matchingTests = getRegistryHub().getTestCaseRegistry().getMatchingTestCases( testSpec );
 
             Totals totals;
             
-            m_reporter->StartGroup( testSpec );
+            testGroupStarting( testSpec, groupIndex, groupsCount );
 
-            std::vector<TestCaseInfo>::const_iterator it = matchingTests.begin();
-            std::vector<TestCaseInfo>::const_iterator itEnd = matchingTests.end();
+            std::vector<TestCase>::const_iterator it = matchingTests.begin();
+            std::vector<TestCase>::const_iterator itEnd = matchingTests.end();
             for(; it != itEnd; ++it )
                 totals += runTest( *it );
-            // !TBD use std::accumulate?
 
-            m_reporter->EndGroup( testSpec, totals );
+            testGroupEnded( testSpec, totals, groupIndex, groupsCount );
             return totals;
         }
 
-        Totals runTest( const TestCaseInfo& testInfo ) {
+        Totals runTest( TestCase const& testCase ) {
             Totals prevTotals = m_totals;
 
             std::string redirectedCout;
             std::string redirectedCerr;
 
-            m_reporter->StartTestCase( testInfo );
+            TestCaseInfo testInfo = testCase.getTestCaseInfo();
 
-            m_runningTest = new RunningTest( &testInfo );
+            m_reporter->testCaseStarting( testInfo );
+            
+            m_runningTest = new RunningTest( testCase );
 
             do {
                 do {
@@ -115,105 +124,118 @@ namespace Catch {
             }
             while( getCurrentContext().advanceGeneratorsForCurrentTest() && !aborting() );
 
+            Totals deltaTotals = m_totals.delta( prevTotals );
+            bool missingAssertions = false;
+            if( deltaTotals.assertions.total() == 0  && m_config->warnAboutMissingAssertions() ) {
+                m_totals.assertions.failed++;
+                deltaTotals = m_totals.delta( prevTotals );
+                missingAssertions = true;
+            }
+
+            m_totals.testCases += deltaTotals.testCases;
+
+            m_reporter->testCaseEnded( TestCaseStats(   testInfo,
+                                                        deltaTotals,
+                                                        redirectedCout,
+                                                        redirectedCerr,
+                                                        missingAssertions,
+                                                        aborting() ) );
+
+
             delete m_runningTest;
             m_runningTest = NULL;
 
-            Totals deltaTotals = m_totals.delta( prevTotals );
-            m_totals.testCases += deltaTotals.testCases;            
-            m_reporter->EndTestCase( testInfo, deltaTotals, redirectedCout, redirectedCerr );
             return deltaTotals;
         }
 
-        const Config& config() const {
+        Ptr<IConfig const> config() const {
             return m_config;
         }
         
     private: // IResultCapture
 
-        virtual ResultAction::Value acceptExpression( const ExpressionResultBuilder& assertionResult, const AssertionInfo& assertionInfo ) {
+        virtual void acceptMessage( MessageBuilder const& messageBuilder ) {
+            m_messages.push_back( messageBuilder.build() );
+        }
+
+        virtual ResultAction::Value acceptExpression( ExpressionResultBuilder const& assertionResult, AssertionInfo const& assertionInfo ) {
             m_lastAssertionInfo = assertionInfo;
             return actOnCurrentResult( assertionResult.buildResult( assertionInfo ) );
         }
 
-        virtual void testEnded( const AssertionResult& result ) {
+        virtual void assertionEnded( AssertionResult const& result ) {
             if( result.getResultType() == ResultWas::Ok ) {
                 m_totals.assertions.passed++;
             }
             else if( !result.isOk() ) {
                 m_totals.assertions.failed++;
-
-                {
-                    std::vector<ScopedInfo*>::const_iterator it = m_scopedInfos.begin();
-                    std::vector<ScopedInfo*>::const_iterator itEnd = m_scopedInfos.end();
-                    for(; it != itEnd; ++it )
-                        m_reporter->Result( (*it)->buildResult( m_lastAssertionInfo ) );
-                }
-                {
-                    std::vector<AssertionResult>::const_iterator it = m_assertionResults.begin();
-                    std::vector<AssertionResult>::const_iterator itEnd = m_assertionResults.end();
-                    for(; it != itEnd; ++it )
-                        m_reporter->Result( *it );
-                }
-                m_assertionResults.clear();
             }
             
-            if( result.getResultType() == ResultWas::Info )
-                m_assertionResults.push_back( result );
-            else
-                m_reporter->Result( result );
+            m_reporter->assertionEnded( AssertionStats( result, m_messages, m_totals ) );
+
+            // Reset working state
+            m_lastAssertionInfo = AssertionInfo( "", m_lastAssertionInfo.lineInfo, "{Unknown expression after the reported line}" , m_lastAssertionInfo.resultDisposition );
+            m_messages.clear();            
         }
         
         virtual bool sectionStarted (
-            const std::string& name, 
-            const std::string& description,
-            const SourceLineInfo& lineInfo,
+            SectionInfo const& sectionInfo,
             Counts& assertions
         )
         {
             std::ostringstream oss;
-            oss << name << "@" << lineInfo;
+            oss << sectionInfo.name << "@" << sectionInfo.lineInfo;
 
 
             if( !m_runningTest->addSection( oss.str() ) )
                 return false;
 
-            m_lastAssertionInfo.lineInfo = lineInfo;
+            m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
+
+            m_reporter->sectionStarting( sectionInfo );
 
-            m_reporter->StartSection( name, description );
             assertions = m_totals.assertions;
             
             return true;
         }
         
-        virtual void sectionEnded( const std::string& name, const Counts& prevAssertions ) {
+        virtual void sectionEnded( SectionInfo const& info, Counts const& prevAssertions ) {
+            if( std::uncaught_exception() ) {
+                m_unfinishedSections.push_back( UnfinishedSections( info, prevAssertions ) );
+                return;
+            }
+            
             Counts assertions = m_totals.assertions - prevAssertions;
-            if( assertions.total() == 0  &&
-               ( m_config.data().warnings & ConfigData::WarnAbout::NoAssertions ) &&
-               !m_runningTest->isBranchSection() ) {
-                m_reporter->NoAssertionsInSection( name );
+            bool missingAssertions = false;
+            if( assertions.total() == 0 &&
+                    m_config->warnAboutMissingAssertions() &&
+                    !m_runningTest->isBranchSection() ) {
                 m_totals.assertions.failed++;
                 assertions.failed++;
+                missingAssertions = true;
+
             }
-            m_runningTest->endSection( name );
-            m_reporter->EndSection( name, assertions );
+            m_runningTest->endSection( info.name, false );
+
+            m_reporter->sectionEnded( SectionStats( info, assertions, missingAssertions ) );
+            m_messages.clear();
         }
 
-        virtual void pushScopedInfo( ScopedInfo* scopedInfo ) {
-            m_scopedInfos.push_back( scopedInfo );
+        virtual void pushScopedMessage( ScopedMessageBuilder const& _builder ) {
+            m_messages.push_back( _builder.build() );
         }
         
-        virtual void popScopedInfo( ScopedInfo* scopedInfo ) {
-            if( m_scopedInfos.back() == scopedInfo )
-                m_scopedInfos.pop_back();
+        virtual void popScopedMessage( ScopedMessageBuilder const& _builder ) {
+            m_messages.erase( std::remove( m_messages.begin(), m_messages.end(), _builder ), m_messages.end() );
         }
 
         virtual bool shouldDebugBreak() const {
-            return m_config.shouldDebugBreak();
+            return m_config->shouldDebugBreak();
         }
 
         virtual std::string getCurrentTestName() const {
             return m_runningTest
-                ? m_runningTest->getTestCaseInfo().getName()
+                ? m_runningTest->getTestCase().getTestCaseInfo().name
                 : "";
         }
 
@@ -224,14 +246,14 @@ namespace Catch {
     public:
         // !TBD We need to do this another way!
         bool aborting() const {
-            return m_totals.assertions.failed == static_cast<std::size_t>( m_config.getCutoff() );
+            return m_totals.assertions.failed == static_cast<std::size_t>( m_config->abortAfter() );
         }
 
     private:
 
-        ResultAction::Value actOnCurrentResult( const AssertionResult& result ) {
+        ResultAction::Value actOnCurrentResult( AssertionResult const& result ) {
             m_lastResult = result;
-            testEnded( m_lastResult );
+            assertionEnded( m_lastResult );
 
             ResultAction::Value action = ResultAction::None;
             
@@ -247,23 +269,16 @@ namespace Catch {
 
         void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr ) {
             try {
-                m_lastAssertionInfo = AssertionInfo( "TEST_CASE", m_runningTest->getTestCaseInfo().getLineInfo(), "", ResultDisposition::Normal );
+                m_lastAssertionInfo = AssertionInfo( "TEST_CASE", m_runningTest->getTestCase().getTestCaseInfo().lineInfo, "", ResultDisposition::Normal );
                 m_runningTest->reset();
-                Counts prevAssertions = m_totals.assertions;
-                if( m_reporter->shouldRedirectStdout() ) {
+                
+                if( m_reporter->getPreferences().shouldRedirectStdOut ) {
                     StreamRedirect coutRedir( std::cout, redirectedCout );
                     StreamRedirect cerrRedir( std::cerr, redirectedCerr );
-                    m_runningTest->getTestCaseInfo().invoke();
+                    m_runningTest->getTestCase().invoke();
                 }
                 else {
-                    m_runningTest->getTestCaseInfo().invoke();
-                }
-                Counts assertions = m_totals.assertions - prevAssertions;
-                if( assertions.total() == 0  &&
-                   ( m_config.data().warnings & ConfigData::WarnAbout::NoAssertions ) &&
-                   !m_runningTest->hasSections() ) {
-                        m_totals.assertions.failed++;                        
-                        m_reporter->NoAssertionsInTestCase( m_runningTest->getTestCaseInfo().getName() );
+                    m_runningTest->getTestCase().invoke();
                 }
                 m_runningTest->ranToCompletion();
             }
@@ -275,23 +290,39 @@ namespace Catch {
                 exResult << translateActiveException();
                 actOnCurrentResult( exResult.buildResult( m_lastAssertionInfo )  );
             }
-            m_assertionResults.clear();
+            for( std::vector<UnfinishedSections>::const_iterator it = m_unfinishedSections.begin(),
+                        itEnd = m_unfinishedSections.end();
+                    it != itEnd;
+                    ++it )
+                sectionEnded( it->info, it->prevAssertions );
+            m_unfinishedSections.clear();
+            m_messages.clear();
         }
 
     private:
+        struct UnfinishedSections {
+            UnfinishedSections( SectionInfo const& _info, Counts const& _prevAssertions )
+            : info( _info ), prevAssertions( _prevAssertions )
+            {}
+
+            SectionInfo info;
+            Counts prevAssertions;
+        };
+
+        TestRunInfo m_runInfo;
         IMutableContext& m_context;
         RunningTest* m_runningTest;
         AssertionResult m_lastResult;
 
-        const Config& m_config;
+        Ptr<IConfig const> m_config;
         Totals m_totals;
-        Ptr<IReporter> m_reporter;
-        std::vector<ScopedInfo*> m_scopedInfos;
-        std::vector<AssertionResult> m_assertionResults;
+        Ptr<IStreamingReporter> m_reporter;
+        std::vector<MessageInfo> m_messages;
         IRunner* m_prevRunner;
         IResultCapture* m_prevResultCapture;
-        const IConfig* m_prevConfig;
+        Ptr<IConfig const> m_prevConfig;
         AssertionInfo m_lastAssertionInfo;
+        std::vector<UnfinishedSections> m_unfinishedSections;
     };
     
 } // end namespace Catch

include/internal/catch_running_test.hpp

@@ -24,9 +24,10 @@ namespace Catch {
         };
         
     public:
-        explicit RunningTest( const TestCaseInfo* info = NULL )
+        explicit RunningTest( TestCase const& info )
         :   m_info( info ),
             m_runStatus( RanAtLeastOneSection ),
+            m_rootSection( info.getTestCaseInfo().name ),
             m_currentSection( &m_rootSection ),
             m_changed( false )
         {}
@@ -54,28 +55,20 @@ namespace Catch {
         }
         
         void ranToCompletion() {
-            if( m_runStatus == RanAtLeastOneSection ||
-                m_runStatus == EncounteredASection ) {
-                m_runStatus = RanToCompletionWithSections;
-                if( m_lastSectionToRun ) {
-                    m_lastSectionToRun->ranToCompletion();
-                    m_changed = true;
-                }
-            }
-            else {
+            if( m_runStatus != RanAtLeastOneSection && m_runStatus != EncounteredASection )
                 m_runStatus = RanToCompletionWithNoSections;
+            m_runStatus = RanToCompletionWithSections;
+            if( m_lastSectionToRun ) {
+                m_lastSectionToRun->ranToCompletion();
+                m_changed = true;
             }
         }
         
-        bool addSection( const std::string& name ) {
+        bool addSection( std::string const& name ) {
             if( m_runStatus == NothingRun )
                 m_runStatus = EncounteredASection;
             
-            SectionInfo* thisSection = m_currentSection->findSubSection( name );
-            if( !thisSection ) {
-                thisSection = m_currentSection->addSubSection( name );
-                m_changed = true;
-            }
+            RunningSection* thisSection = m_currentSection->findOrAddSubSection( name, m_changed );
 
             if( !wasSectionSeen() && thisSection->shouldRun() ) {
                 m_currentSection = thisSection;
@@ -85,20 +78,22 @@ namespace Catch {
             return false;
         }
         
-        void endSection( const std::string& ) {
+        void endSection( std::string const&, bool stealth ) {
             if( m_currentSection->ran() ) {
-                m_runStatus = RanAtLeastOneSection;
+                if( !stealth )
+                    m_runStatus = RanAtLeastOneSection;
                 m_changed = true;
             }
             else if( m_runStatus == EncounteredASection ) {
-                m_runStatus = RanAtLeastOneSection;
+                if( !stealth )
+                    m_runStatus = RanAtLeastOneSection;
                 m_lastSectionToRun = m_currentSection;
             }
             m_currentSection = m_currentSection->getParent();
         }
         
-        const TestCaseInfo& getTestCaseInfo() const {
-            return *m_info;
+        TestCase const& getTestCase() const {
+            return m_info;
         }
 
         bool hasUntestedSections() const {
@@ -107,11 +102,14 @@ namespace Catch {
         }
         
     private:
-        const TestCaseInfo* m_info;
+		RunningTest( RunningTest const& );
+		void operator=( RunningTest const& );
+
+        TestCase const& m_info;
         RunStatus m_runStatus;
-        SectionInfo m_rootSection;
-        SectionInfo* m_currentSection;
-        SectionInfo* m_lastSectionToRun;
+        RunningSection m_rootSection;
+        RunningSection* m_currentSection;
+        RunningSection* m_lastSectionToRun;
         bool m_changed;
     };
 }

include/internal/catch_section.hpp

@@ -10,6 +10,7 @@
 
 #include "catch_capture.hpp"
 #include "catch_totals.hpp"
+#include "catch_compiler_capabilities.h"
 
 #include <string>
 
@@ -17,16 +18,16 @@ namespace Catch {
 
     class Section {
     public:
-        Section(    const std::string& name, 
-                    const std::string& description,
-                    const SourceLineInfo& lineInfo )
-        :   m_name( name ),
-            m_sectionIncluded( getCurrentContext().getResultCapture().sectionStarted( name, description, lineInfo, m_assertions ) )
+        Section(    SourceLineInfo const& lineInfo,
+                    std::string const& name,
+                    std::string const& description = "" )
+        :   m_info( name, description, lineInfo ),
+            m_sectionIncluded( getCurrentContext().getResultCapture().sectionStarted( m_info, m_assertions ) )
         {}
 
         ~Section() {
             if( m_sectionIncluded )
-                getCurrentContext().getResultCapture().sectionEnded( m_name, m_assertions );
+                getCurrentContext().getResultCapture().sectionEnded( m_info, m_assertions );
         }
         
         // This indicates whether the section should be executed or not
@@ -35,6 +36,7 @@ namespace Catch {
         }
 
     private:
+        SectionInfo m_info;
         
         std::string m_name;
         Counts m_assertions;
@@ -43,7 +45,12 @@ namespace Catch {
     
 } // end namespace Catch
 
-#define INTERNAL_CATCH_SECTION( name, desc ) \
-    if( Catch::Section INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::Section( name, desc, CATCH_INTERNAL_LINEINFO ) )
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+    #define INTERNAL_CATCH_SECTION( ... ) \
+        if( Catch::Section INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::Section( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) )
+#else
+    #define INTERNAL_CATCH_SECTION( name, desc ) \
+        if( Catch::Section INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::Section( CATCH_INTERNAL_LINEINFO, name, desc ) )
+#endif
 
 #endif // TWOBLUECUBES_CATCH_SECTION_HPP_INCLUDED

include/internal/catch_section_info.hpp

@@ -15,10 +15,12 @@
 
 namespace Catch {
 
-    class SectionInfo {
+    class RunningSection {
     public:
 
-        enum Status {
+        typedef std::vector<RunningSection*> SubSections;
+    
+        enum State {
             Root,
             Unknown,
             Branch,
@@ -26,76 +28,85 @@ namespace Catch {
             TestedLeaf
         };
         
-        SectionInfo( SectionInfo* parent )
-        :   m_status( Unknown ),
-            m_parent( parent )
+        RunningSection( RunningSection* parent, std::string const& name )
+        :   m_state( Unknown ),
+            m_parent( parent ),
+            m_name( name )
         {}
         
-        SectionInfo()
-        :   m_status( Root ),
-            m_parent( NULL )
+        RunningSection( std::string const& name )
+        :   m_state( Root ),
+            m_parent( NULL ),
+            m_name( name )
         {}
         
-        ~SectionInfo() {
-            deleteAllValues( m_subSections );
+        ~RunningSection() {
+            deleteAll( m_subSections );
+        }
+
+        std::string getName() const {
+            return m_name;
         }
 
         bool shouldRun() const {
-            return m_status < TestedBranch;
-        }
-        
-        bool ran() {
-            if( m_status < Branch ) {
-                m_status = TestedLeaf;
-                return true;
-            }            
-            return false;
+            return m_state < TestedBranch;
         }
         
         bool isBranch() const {
-            return m_status == Branch;
+            return m_state == Branch;
         }
 
-        void ranToCompletion() {
-            if( m_status == Branch && !hasUntestedSections() )
-                m_status = TestedBranch;
-        }
-                
-        SectionInfo* findSubSection( const std::string& name ) {
-            std::map<std::string, SectionInfo*>::const_iterator it = m_subSections.find( name );
-            return it != m_subSections.end()
-                        ? it->second
-                        : NULL;
-        }
-        
-        SectionInfo* addSubSection( const std::string& name ) {
-            SectionInfo* subSection = new SectionInfo( this );
-            m_subSections.insert( std::make_pair( name, subSection ) );
-            m_status = Branch;
-            return subSection;
-        }
-        
-        SectionInfo* getParent() {
+        const RunningSection* getParent() const {
             return m_parent;
         }
 
         bool hasUntestedSections() const {
-            if( m_status == Unknown )
+            if( m_state == Unknown )
                 return true;
-            
-            std::map<std::string, SectionInfo*>::const_iterator it = m_subSections.begin();
-            std::map<std::string, SectionInfo*>::const_iterator itEnd = m_subSections.end();
-            for(; it != itEnd; ++it ) {
-                if( it->second->hasUntestedSections() )
+            for(    SubSections::const_iterator it = m_subSections.begin();
+                    it != m_subSections.end();
+                    ++it)
+                if( (*it)->hasUntestedSections() )
                     return true;
-            }
             return false;
         }
 
+        // Mutable methods:
+
+        RunningSection* getParent() {
+            return m_parent;
+        }
+
+        RunningSection* findOrAddSubSection( std::string const& name, bool& changed ) {
+            for(    SubSections::const_iterator it = m_subSections.begin();
+                    it != m_subSections.end();
+                    ++it)
+                if( (*it)->getName() == name )
+                    return *it;
+            RunningSection* subSection = new RunningSection( this, name );
+            m_subSections.push_back( subSection );
+            m_state = Branch;
+            changed = true;
+            return subSection;
+        }
+
+        bool ran() {
+            if( m_state >= Branch )
+                return false;
+            m_state = TestedLeaf;
+            return true;
+        }
+
+        void ranToCompletion() {
+            if( m_state == Branch && !hasUntestedSections() )
+                m_state = TestedBranch;
+        }
+
     private:
-        Status m_status;
-        std::map<std::string, SectionInfo*> m_subSections;
-        SectionInfo* m_parent;
+        State m_state;
+        RunningSection* m_parent;
+        std::string m_name;
+        SubSections m_subSections;
     };
 }
 

include/internal/catch_sfinae.hpp

@@ -0,0 +1,44 @@
+/*
+ *  Created by Phil on 15/04/2013.
+ *  Copyright 2013 Two Blue Cubes Ltd. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_CATCH_SFINAE_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_SFINAE_HPP_INCLUDED
+
+// Try to detect if the current compiler supports SFINAE
+#include "catch_compiler_capabilities.h"
+
+namespace Catch {
+    
+    struct TrueType {
+        static const bool value = true;
+        typedef void Enable;
+        char sizer[1];
+    };
+    struct FalseType {
+        static const bool value = false;
+        typedef void Disable;
+        char sizer[2];
+    };
+
+#ifdef CATCH_CONFIG_SFINAE
+
+    template<bool> struct NotABooleanExpression;
+
+    template<bool c> struct If : NotABooleanExpression<c> {};
+    template<> struct If<true> : TrueType {};
+    template<> struct If<false> : FalseType {};
+
+    template<int size> struct SizedIf;
+    template<> struct SizedIf<sizeof(TrueType)> : TrueType {};
+    template<> struct SizedIf<sizeof(FalseType)> : FalseType {};
+
+#endif // CATCH_CONFIG_SFINAE
+    
+} // end namespace Catch
+
+#endif // TWOBLUECUBES_CATCH_SFINAE_HPP_INCLUDED
+

include/internal/catch_stream.hpp

@@ -32,7 +32,7 @@ namespace Catch {
         }
         
     private:
-        int	overflow( int c ) {
+        int overflow( int c ) {
             sync();
             
             if( c != EOF ) {
@@ -44,7 +44,7 @@ namespace Catch {
             return 0;
         }
         
-        int	sync() {
+        int sync() {
             if( pbase() != pptr() ) {
                 m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
                 setp( pbase(), epptr() );
@@ -57,7 +57,7 @@ namespace Catch {
 
     struct OutputDebugWriter {
     
-        void operator()( const std::string &str ) {
+        void operator()( std::string const&str ) {
             writeToDebugConsole( str );
         }
     };

include/internal/catch_tags.hpp

@@ -8,6 +8,8 @@
 #ifndef TWOBLUECUBES_CATCH_TAGS_HPP_INCLUDED
 #define TWOBLUECUBES_CATCH_TAGS_HPP_INCLUDED
 
+#include "catch_common.h"
+
 #include <string>
 #include <set>
 #include <map>
@@ -22,7 +24,7 @@ namespace Catch {
     public:
         virtual ~TagParser();
 
-        void parse( const std::string& str ) {
+        void parse( std::string const& str ) {
             std::size_t pos = 0;
             while( pos < str.size() ) {
                 char c = str[pos];
@@ -46,7 +48,7 @@ namespace Catch {
         }
 
     protected:
-        virtual void acceptTag( const std::string& tag ) = 0;
+        virtual void acceptTag( std::string const& tag ) = 0;
         virtual void acceptChar( char c ) = 0;
         virtual void endParse() {}
 
@@ -67,14 +69,14 @@ namespace Catch {
         }
 
     private:
-        virtual void acceptTag( const std::string& tag ) {
-            m_tags.insert( tag );
+        virtual void acceptTag( std::string const& tag ) {
+            m_tags.insert( toLower( tag ) );
         }
         virtual void acceptChar( char c ) {
             m_remainder += c;
         }
 
-        TagExtracter& operator=(const TagExtracter&);
+        TagExtracter& operator=(TagExtracter const&);
         
         std::set<std::string>& m_tags;
         std::string m_remainder;
@@ -86,7 +88,7 @@ namespace Catch {
         :   m_isNegated( false )
         {}
 
-        Tag( const std::string& name, bool isNegated )
+        Tag( std::string const& name, bool isNegated )
         :   m_name( name ),
             m_isNegated( isNegated )
         {}
@@ -110,15 +112,15 @@ namespace Catch {
     class TagSet {
         typedef std::map<std::string, Tag> TagMap;
     public:
-        void add( const Tag& tag ) {
-            m_tags.insert( std::make_pair( tag.getName(), tag ) );
+        void add( Tag const& tag ) {
+            m_tags.insert( std::make_pair( toLower( tag.getName() ), tag ) );
         }
 
         bool empty() const {
             return m_tags.empty();
         }
 
-        bool matches( const std::set<std::string>& tags ) const {
+        bool matches( std::set<std::string> const& tags ) const {
             TagMap::const_iterator it = m_tags.begin();
             TagMap::const_iterator itEnd = m_tags.end();
             for(; it != itEnd; ++it ) {
@@ -135,7 +137,7 @@ namespace Catch {
 
     class TagExpression {
     public:
-        bool matches( const std::set<std::string>& tags ) const {
+        bool matches( std::set<std::string> const& tags ) const {
             std::vector<TagSet>::const_iterator it = m_tagSets.begin();
             std::vector<TagSet>::const_iterator itEnd = m_tagSets.end();
             for(; it != itEnd; ++it )
@@ -160,7 +162,7 @@ namespace Catch {
         ~TagExpressionParser();
 
     private:
-        virtual void acceptTag( const std::string& tag ) {
+        virtual void acceptTag( std::string const& tag ) {
             m_currentTagSet.add( Tag( tag, m_isNegated ) );
             m_isNegated = false;
         }
@@ -179,7 +181,7 @@ namespace Catch {
                 m_exp.m_tagSets.push_back( m_currentTagSet );
         }
 
-        TagExpressionParser& operator=(const TagExpressionParser&);
+        TagExpressionParser& operator=(TagExpressionParser const&);
 
         bool m_isNegated;
         TagSet m_currentTagSet;

include/internal/catch_test_case_info.h

@@ -9,53 +9,74 @@
 #define TWOBLUECUBES_CATCH_TEST_CASE_INFO_H_INCLUDED
 
 #include "catch_common.h"
+#include "catch_ptr.hpp"
 
 #include <string>
 #include <set>
 
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
 namespace Catch {
 
     struct ITestCase;
 
-    class TestCaseInfo {
+    struct TestCaseInfo {
+        TestCaseInfo(   std::string const& _name,
+                        std::string const& _className,
+                        std::string const& _description,
+                        std::set<std::string> const& _tags,
+                        bool _isHidden,
+                        SourceLineInfo const& _lineInfo );
+
+        TestCaseInfo( TestCaseInfo const& other );
+
+        std::string name;
+        std::string className;
+        std::string description;
+        std::set<std::string> tags;
+        std::string tagsAsString;
+        SourceLineInfo lineInfo;
+        bool isHidden;
+    };
+    
+    class TestCase : protected TestCaseInfo {
     public:
-        TestCaseInfo();
 
-        TestCaseInfo(   ITestCase* testCase,
-                        const std::string& className,
-                        const std::string& name,
-                        const std::string& description,
-                        const SourceLineInfo& lineInfo );
+        TestCase( ITestCase* testCase, TestCaseInfo const& info );
+        TestCase( TestCase const& other );
 
-
-        TestCaseInfo( const TestCaseInfo& other, const std::string& name );
-        TestCaseInfo( const TestCaseInfo& other );
+        TestCase withName( std::string const& _newName ) const;
 
         void invoke() const;
 
-        const std::string& getClassName() const;
-        const std::string& getName() const;
-        const std::string& getDescription() const;
-        const SourceLineInfo& getLineInfo() const;
-        bool isHidden() const;
-        bool hasTag( const std::string& tag ) const;
-        bool matchesTags( const std::string& tagPattern ) const;
-        const std::set<std::string>& getTags() const;
+        TestCaseInfo const& getTestCaseInfo() const;
 
-        void swap( TestCaseInfo& other );
-        bool operator == ( const TestCaseInfo& other ) const;
-        bool operator < ( const TestCaseInfo& other ) const;
-        TestCaseInfo& operator = ( const TestCaseInfo& other );
+        bool isHidden() const;
+        bool hasTag( std::string const& tag ) const;
+        bool matchesTags( std::string const& tagPattern ) const;
+        std::set<std::string> const& getTags() const;
+        
+        void swap( TestCase& other );
+        bool operator == ( TestCase const& other ) const;
+        bool operator < ( TestCase const& other ) const;
+        TestCase& operator = ( TestCase const& other );
 
     private:
-        Ptr<ITestCase> m_test;
-        std::string m_className;
-        std::string m_name;
-        std::string m_description;
-        std::set<std::string> m_tags;
-        SourceLineInfo m_lineInfo;
-        bool m_isHidden;
+        Ptr<ITestCase> test;
     };
+
+    TestCase makeTestCase(  ITestCase* testCase,
+                            std::string const& className,
+                            std::string const& name,
+                            std::string const& description,
+                            SourceLineInfo const& lineInfo );
 }
 
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
 #endif // TWOBLUECUBES_CATCH_TEST_CASE_INFO_H_INCLUDED

include/internal/catch_test_case_info.hpp

@@ -11,111 +11,117 @@
 #include "catch_tags.hpp"
 #include "catch_test_case_info.h"
 #include "catch_interfaces_testcase.h"
+#include "catch_common.h"
 
 namespace Catch {
 
-    
-    TestCaseInfo::TestCaseInfo( ITestCase* testCase,
-                                const std::string& className,
-                                const std::string& name,
-                                const std::string& description,
-                                const SourceLineInfo& lineInfo )
-    :   m_test( testCase ),
-        m_className( className ),
-        m_name( name ),
-        m_description( description ),
-        m_lineInfo( lineInfo ),
-        m_isHidden( startsWith( name, "./" ) )
+    TestCase makeTestCase(  ITestCase* _testCase,
+                            std::string const& _className,
+                            std::string const& _name,
+                            std::string const& _descOrTags,
+                            SourceLineInfo const& _lineInfo )
     {
-        TagExtracter( m_tags ).parse( m_description );
-        if( hasTag( "hide" ) )
-            m_isHidden = true;
+        std::string desc = _descOrTags;
+        bool isHidden( startsWith( _name, "./" ) );
+        std::set<std::string> tags;
+        TagExtracter( tags ).parse( desc );
+        if( tags.find( "hide" ) != tags.end() )
+            isHidden = true;
+
+        TestCaseInfo info( _name, _className, desc, tags, isHidden, _lineInfo );
+        return TestCase( _testCase, info );
     }
 
-    TestCaseInfo::TestCaseInfo()
-    :   m_test( NULL ),
-        m_className(),
-        m_name(),
-        m_description(),
-        m_isHidden( false )
+    TestCaseInfo::TestCaseInfo( std::string const& _name,
+                                std::string const& _className,
+                                std::string const& _description,
+                                std::set<std::string> const& _tags,
+                                bool _isHidden,
+                                SourceLineInfo const& _lineInfo )
+    :   name( _name ),
+        className( _className ),
+        description( _description ),
+        tags( _tags ),
+        lineInfo( _lineInfo ),
+        isHidden( _isHidden )
+    {
+        std::ostringstream oss;
+        for( std::set<std::string>::const_iterator it = _tags.begin(), itEnd = _tags.end(); it != itEnd; ++it )
+            oss << "[" << *it << "]";
+        tagsAsString = oss.str();
+    }
+
+    TestCaseInfo::TestCaseInfo( TestCaseInfo const& other )
+    :   name( other.name ),
+        className( other.className ),
+        description( other.description ),
+        tags( other.tags ),
+        tagsAsString( other.tagsAsString ),
+        lineInfo( other.lineInfo ),
+        isHidden( other.isHidden )        
     {}
 
-    TestCaseInfo::TestCaseInfo( const TestCaseInfo& other, const std::string& name )
-    :   m_test( other.m_test ),
-        m_className( other.m_className ),
-        m_name( name ),
-        m_description( other.m_description ),
-        m_tags( other.m_tags ),
-        m_lineInfo( other.m_lineInfo ),
-        m_isHidden( other.m_isHidden )
+    TestCase::TestCase( ITestCase* testCase, TestCaseInfo const& info ) : TestCaseInfo( info ), test( testCase ) {}
+
+    TestCase::TestCase( TestCase const& other )
+    :   TestCaseInfo( other ),
+        test( other.test )
     {}
 
-    TestCaseInfo::TestCaseInfo( const TestCaseInfo& other )
-    :   m_test( other.m_test ),
-        m_className( other.m_className ),
-        m_name( other.m_name ),
-        m_description( other.m_description ),
-        m_tags( other.m_tags ),
-        m_lineInfo( other.m_lineInfo ),
-        m_isHidden( other.m_isHidden )
-    {}
-
-    void TestCaseInfo::invoke() const {
-        m_test->invoke();
+    TestCase TestCase::withName( std::string const& _newName ) const {
+        TestCase other( *this );
+        other.name = _newName;
+        return other;
     }
 
-    const std::string& TestCaseInfo::getClassName() const {
-        return m_className;
-    }
-    const std::string& TestCaseInfo::getName() const {
-        return m_name;
-    }
-    const std::string& TestCaseInfo::getDescription() const {
-        return m_description;
-    }
-    const SourceLineInfo& TestCaseInfo::getLineInfo() const {
-        return m_lineInfo;
+    void TestCase::invoke() const {
+        test->invoke();
     }
 
-    bool TestCaseInfo::isHidden() const {
-        return m_isHidden;
+    bool TestCase::isHidden() const {
+        return TestCaseInfo::isHidden;
     }
 
-    bool TestCaseInfo::hasTag( const std::string& tag ) const {
-        return m_tags.find( tag ) != m_tags.end();
+    bool TestCase::hasTag( std::string const& tag ) const {
+        return tags.find( toLower( tag ) ) != tags.end();
     }
-    bool TestCaseInfo::matchesTags( const std::string& tagPattern ) const {
+    bool TestCase::matchesTags( std::string const& tagPattern ) const {
         TagExpression exp;
         TagExpressionParser( exp ).parse( tagPattern );
-        return exp.matches( m_tags );
+        return exp.matches( tags );
     }
-    const std::set<std::string>& TestCaseInfo::getTags() const {
-        return m_tags;
+    std::set<std::string> const& TestCase::getTags() const {
+        return tags;
     }
 
-    void TestCaseInfo::swap( TestCaseInfo& other ) {
-        m_test.swap( other.m_test );
-        m_className.swap( other.m_className );
-        m_name.swap( other.m_name );
-        m_description.swap( other.m_description );
-        std::swap( m_lineInfo, other.m_lineInfo );
+    void TestCase::swap( TestCase& other ) {
+        test.swap( other.test );
+        className.swap( other.className );
+        name.swap( other.name );
+        description.swap( other.description );
+        std::swap( lineInfo, other.lineInfo );
     }
 
-    bool TestCaseInfo::operator == ( const TestCaseInfo& other ) const {
-        return  m_test.get() == other.m_test.get() &&
-                m_name == other.m_name &&
-                m_className == other.m_className;
+    bool TestCase::operator == ( TestCase const& other ) const {
+        return  test.get() == other.test.get() &&
+                name == other.name &&
+                className == other.className;
     }
 
-    bool TestCaseInfo::operator < ( const TestCaseInfo& other ) const {
-        return m_name < other.m_name;
+    bool TestCase::operator < ( TestCase const& other ) const {
+        return name < other.name;
     }
-    TestCaseInfo& TestCaseInfo::operator = ( const TestCaseInfo& other ) {
-        TestCaseInfo temp( other );
+    TestCase& TestCase::operator = ( TestCase const& other ) {
+        TestCase temp( other );
         swap( temp );
         return *this;
     }
 
+    TestCaseInfo const& TestCase::getTestCaseInfo() const
+    {
+        return *this;
+    }
+
 } // end namespace Catch
 
 #endif // TWOBLUECUBES_CATCH_TEST_CASE_INFO_HPP_INCLUDED

include/internal/catch_test_case_registry_impl.hpp

@@ -25,58 +25,59 @@ namespace Catch {
         TestRegistry() : m_unnamedCount( 0 ) {}
         virtual ~TestRegistry();
         
-        virtual void registerTest( const TestCaseInfo& testInfo ) {
-            if( testInfo.getName() == "" ) {
+        virtual void registerTest( TestCase const& testCase ) {
+            std::string name = testCase.getTestCaseInfo().name;
+            if( name == "" ) {
                 std::ostringstream oss;
-                oss << testInfo.getName() << "unnamed/" << ++m_unnamedCount;
-                return registerTest( TestCaseInfo( testInfo, oss.str() ) );
+                oss << "Anonymous test case " << ++m_unnamedCount;
+                return registerTest( testCase.withName( oss.str() ) );
             }
 
-            if( m_functions.find( testInfo ) == m_functions.end() ) {
-                m_functions.insert( testInfo );
-                m_functionsInOrder.push_back( testInfo );
-                if( !testInfo.isHidden() )
-                    m_nonHiddenFunctions.push_back( testInfo );
+            if( m_functions.find( testCase ) == m_functions.end() ) {
+                m_functions.insert( testCase );
+                m_functionsInOrder.push_back( testCase );
+                if( !testCase.isHidden() )
+                    m_nonHiddenFunctions.push_back( testCase );
             }
             else {
-                const TestCaseInfo& prev = *m_functions.find( testInfo );
-                std::cerr   << "error: TEST_CASE( \"" << testInfo.getName() << "\" ) already defined.\n"
-                            << "\tFirst seen at " << SourceLineInfo( prev.getLineInfo() ) << "\n"
-                            << "\tRedefined at " << SourceLineInfo( testInfo.getLineInfo() ) << std::endl;
+                TestCase const& prev = *m_functions.find( testCase );
+                std::cerr   << "error: TEST_CASE( \"" << name << "\" ) already defined.\n"
+                            << "\tFirst seen at " << SourceLineInfo( prev.getTestCaseInfo().lineInfo ) << "\n"
+                            << "\tRedefined at " << SourceLineInfo( testCase.getTestCaseInfo().lineInfo ) << std::endl;
                 exit(1);
             }
         }
         
-        virtual const std::vector<TestCaseInfo>& getAllTests() const {
+        virtual std::vector<TestCase> const& getAllTests() const {
             return m_functionsInOrder;
         }
 
-        virtual const std::vector<TestCaseInfo>& getAllNonHiddenTests() const {
+        virtual std::vector<TestCase> const& getAllNonHiddenTests() const {
             return m_nonHiddenFunctions;
         }
 
         // !TBD deprecated
-        virtual std::vector<TestCaseInfo> getMatchingTestCases( const std::string& rawTestSpec ) const {
-            std::vector<TestCaseInfo> matchingTests;
+        virtual std::vector<TestCase> getMatchingTestCases( std::string const& rawTestSpec ) const {
+            std::vector<TestCase> matchingTests;
             getMatchingTestCases( rawTestSpec, matchingTests );
             return matchingTests;
         }
 
         // !TBD deprecated
-        virtual void getMatchingTestCases( const std::string& rawTestSpec, std::vector<TestCaseInfo>& matchingTestsOut ) const {
+        virtual void getMatchingTestCases( std::string const& rawTestSpec, std::vector<TestCase>& matchingTestsOut ) const {
             TestCaseFilter filter( rawTestSpec );
 
-            std::vector<TestCaseInfo>::const_iterator it = m_functionsInOrder.begin();
-            std::vector<TestCaseInfo>::const_iterator itEnd = m_functionsInOrder.end();
+            std::vector<TestCase>::const_iterator it = m_functionsInOrder.begin();
+            std::vector<TestCase>::const_iterator itEnd = m_functionsInOrder.end();
             for(; it != itEnd; ++it ) {
                 if( filter.shouldInclude( *it ) ) {
                     matchingTestsOut.push_back( *it );
                 }
             }
         }
-        virtual void getMatchingTestCases( const TestCaseFilters& filters, std::vector<TestCaseInfo>& matchingTestsOut ) const {
-            std::vector<TestCaseInfo>::const_iterator it = m_functionsInOrder.begin();
-            std::vector<TestCaseInfo>::const_iterator itEnd = m_functionsInOrder.end();
+        virtual void getMatchingTestCases( TestCaseFilters const& filters, std::vector<TestCase>& matchingTestsOut ) const {
+            std::vector<TestCase>::const_iterator it = m_functionsInOrder.begin();
+            std::vector<TestCase>::const_iterator itEnd = m_functionsInOrder.end();
             // !TBD: replace with algorithm
             for(; it != itEnd; ++it )
                 if( filters.shouldInclude( *it ) )
@@ -85,9 +86,9 @@ namespace Catch {
 
     private:
         
-        std::set<TestCaseInfo> m_functions;
-        std::vector<TestCaseInfo> m_functionsInOrder;
-        std::vector<TestCaseInfo> m_nonHiddenFunctions;        
+        std::set<TestCase> m_functions;
+        std::vector<TestCase> m_functionsInOrder;
+        std::vector<TestCase> m_nonHiddenFunctions;        
         size_t m_unnamedCount;
     };
 
@@ -108,7 +109,7 @@ namespace Catch {
         TestFunction m_fun;
     };
 
-    inline std::string extractClassName( const std::string& classOrQualifiedMethodName ) {
+    inline std::string extractClassName( std::string const& classOrQualifiedMethodName ) {
         std::string className = classOrQualifiedMethodName;
         if( className[0] == '&' )
         {
@@ -124,21 +125,24 @@ namespace Catch {
     ///////////////////////////////////////////////////////////////////////////
     
     AutoReg::AutoReg(   TestFunction function,
-                        const char* name,
-                        const char* description,
-                        const SourceLineInfo& lineInfo ) {
-        registerTestCase( new FreeFunctionTestCase( function ), "global", name, description, lineInfo );
+                        SourceLineInfo const& lineInfo,
+                        NameAndDesc const& nameAndDesc ) {
+        registerTestCase( new FreeFunctionTestCase( function ), "global", nameAndDesc, lineInfo );
     }    
     
     AutoReg::~AutoReg() {}
     
     void AutoReg::registerTestCase( ITestCase* testCase,
-                                    const char* classOrQualifiedMethodName,
-                                    const char* name,
-                                    const char* description,
-                                    const SourceLineInfo& lineInfo ) {
+                                    char const* classOrQualifiedMethodName,
+                                    NameAndDesc const& nameAndDesc,
+                                    SourceLineInfo const& lineInfo ) {
         
-        getMutableRegistryHub().registerTest( TestCaseInfo( testCase, extractClassName( classOrQualifiedMethodName ), name, description, lineInfo ) );
+        getMutableRegistryHub().registerTest
+            ( makeTestCase( testCase,
+                            extractClassName( classOrQualifiedMethodName ),
+                            nameAndDesc.name,
+                            nameAndDesc.description,
+                            lineInfo ) );
     }
     
 } // end namespace Catch

include/internal/catch_test_registry.hpp

@@ -10,6 +10,7 @@
 
 #include "catch_common.h"
 #include "catch_interfaces_testcase.h"
+#include "internal/catch_compiler_capabilities.h"
 
 namespace Catch {
     
@@ -32,61 +33,88 @@ private:
 
 typedef void(*TestFunction)();
 
+struct NameAndDesc {
+    NameAndDesc( const char* _name = "", const char* _description= "" )
+    : name( _name ), description( _description )
+    {}
+
+    const char* name;
+    const char* description;
+};
+
 struct AutoReg {
 
     AutoReg(    TestFunction function,
-                const char* name, 
-                const char* description,
-                const SourceLineInfo& lineInfo );
+                SourceLineInfo const& lineInfo,
+                NameAndDesc const& nameAndDesc );
     
     template<typename C>
     AutoReg(    void (C::*method)(),
-                const char* className,
-                const char* name, 
-                const char* description,
-                const SourceLineInfo& lineInfo ) {
-        registerTestCase( new MethodTestCase<C>( method ), className, name, description, lineInfo );
+                char const* className,
+                NameAndDesc const& nameAndDesc,
+                SourceLineInfo const& lineInfo ) {
+        registerTestCase(   new MethodTestCase<C>( method ),
+                            className,
+                            nameAndDesc,
+                            lineInfo );
     }
     
     void registerTestCase(  ITestCase* testCase, 
-                            const char* className,
-                            const char* name,
-                            const char* description,
-                            const SourceLineInfo& lineInfo );
+                            char const* className,
+                            NameAndDesc const& nameAndDesc,
+                            SourceLineInfo const& lineInfo );
     
     ~AutoReg();
     
 private:
-    AutoReg( const AutoReg& );    
-    void operator= ( const AutoReg& );
+    AutoReg( AutoReg const& );    
+    void operator= ( AutoReg const& );
 };
     
 } // end namespace Catch
 
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_TESTCASE( Name, Desc ) \
-    static void INTERNAL_CATCH_UNIQUE_NAME( TestCaseFunction_catch_internal_ )(); \
-    namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &INTERNAL_CATCH_UNIQUE_NAME(  TestCaseFunction_catch_internal_ ), Name, Desc, CATCH_INTERNAL_LINEINFO ); }\
-    static void INTERNAL_CATCH_UNIQUE_NAME(  TestCaseFunction_catch_internal_ )()
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TESTCASE( ... ) \
+        static void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )(); \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &INTERNAL_CATCH_UNIQUE_NAME(  ____C_A_T_C_H____T_E_S_T____ ), CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); }\
+        static void INTERNAL_CATCH_UNIQUE_NAME(  ____C_A_T_C_H____T_E_S_T____ )()
 
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_TESTCASE_NORETURN( Name, Desc ) \
-    static void INTERNAL_CATCH_UNIQUE_NAME( TestCaseFunction_catch_internal_ )() CATCH_ATTRIBUTE_NORETURN; \
-    namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &INTERNAL_CATCH_UNIQUE_NAME(  TestCaseFunction_catch_internal_ ), Name, Desc, CATCH_INTERNAL_LINEINFO ); }\
-    static void INTERNAL_CATCH_UNIQUE_NAME(  TestCaseFunction_catch_internal_ )()
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); }
 
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, Name, Desc ) \
-    namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Name, Desc, CATCH_INTERNAL_LINEINFO ); }
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... )\
+        namespace{ \
+            struct INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ) : ClassName{ \
+                void test(); \
+            }; \
+            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test, #ClassName, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); \
+        } \
+        void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test()
 
-///////////////////////////////////////////////////////////////////////////////
-#define TEST_CASE_METHOD( ClassName, TestName, Desc )\
-    namespace{ \
-        struct INTERNAL_CATCH_UNIQUE_NAME( TestCaseMethod_catch_internal_ ) : ClassName{ \
-            void test(); \
-        }; \
-        Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &INTERNAL_CATCH_UNIQUE_NAME( TestCaseMethod_catch_internal_ )::test, #ClassName, TestName, Desc, CATCH_INTERNAL_LINEINFO ); \
-    } \
-    void INTERNAL_CATCH_UNIQUE_NAME( TestCaseMethod_catch_internal_ )::test()
+#else
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TESTCASE( Name, Desc ) \
+        static void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )(); \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &INTERNAL_CATCH_UNIQUE_NAME(  ____C_A_T_C_H____T_E_S_T____ ), CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) ); }\
+        static void INTERNAL_CATCH_UNIQUE_NAME(  ____C_A_T_C_H____T_E_S_T____ )()
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, Name, Desc ) \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( Name, Desc ), CATCH_INTERNAL_LINEINFO ); }
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, TestName, Desc )\
+        namespace{ \
+            struct INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ) : ClassName{ \
+                void test(); \
+            }; \
+            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test, #ClassName, Catch::NameAndDesc( TestName, Desc ), CATCH_INTERNAL_LINEINFO ); \
+        } \
+        void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test()
+
+#endif
 
 #endif // TWOBLUECUBES_CATCH_TEST_REGISTRY_HPP_INCLUDED

include/internal/catch_test_spec.h

@@ -10,6 +10,7 @@
 
 #include "catch_test_case_info.h"
 #include "catch_tags.hpp"
+#include "catch_common.h"
 
 #include <string>
 #include <vector>
@@ -31,8 +32,8 @@ namespace Catch {
         };
 
     public:
-        TestCaseFilter( const std::string& testSpec, IfFilterMatches::DoWhat matchBehaviour = IfFilterMatches::AutoDetectBehaviour )
-        :   m_stringToMatch( testSpec ),
+        TestCaseFilter( std::string const& testSpec, IfFilterMatches::DoWhat matchBehaviour = IfFilterMatches::AutoDetectBehaviour )
+        :   m_stringToMatch( toLower( testSpec ) ),
             m_filterType( matchBehaviour ),
             m_wildcardPosition( NoWildcard )
         {
@@ -50,11 +51,11 @@ namespace Catch {
                 }
             }
 
-            if( m_stringToMatch[0] == '*' ) {
+            if( startsWith( m_stringToMatch, "*" ) ) {
                 m_stringToMatch = m_stringToMatch.substr( 1 );
                 m_wildcardPosition = (WildcardPosition)( m_wildcardPosition | WildcardAtStart );
             }
-            if( m_stringToMatch[m_stringToMatch.size()-1] == '*' ) {
+            if( endsWith( m_stringToMatch, "*" ) ) {
                 m_stringToMatch = m_stringToMatch.substr( 0, m_stringToMatch.size()-1 );
                 m_wildcardPosition = (WildcardPosition)( m_wildcardPosition | WildcardAtEnd );
             }
@@ -64,7 +65,7 @@ namespace Catch {
             return m_filterType;
         }
         
-        bool shouldInclude( const TestCaseInfo& testCase ) const {
+        bool shouldInclude( TestCase const& testCase ) const {
             return isMatch( testCase ) == (m_filterType == IfFilterMatches::IncludeTests);
         }
     private:
@@ -74,8 +75,9 @@ namespace Catch {
 #pragma clang diagnostic ignored "-Wunreachable-code"
 #endif
 
-        bool isMatch( const TestCaseInfo& testCase ) const {
-            const std::string& name = testCase.getName();
+        bool isMatch( TestCase const& testCase ) const {
+            std::string name = testCase.getTestCaseInfo().name;
+            toLowerInPlace( name );
 
             switch( m_wildcardPosition ) {
                 case NoWildcard:
@@ -101,27 +103,27 @@ namespace Catch {
 
     class TestCaseFilters {
     public:
-        TestCaseFilters( const std::string& name ) : m_name( name ) {}
+        TestCaseFilters( std::string const& name ) : m_name( name ) {}
 
         std::string getName() const {
             return m_name;
         }
         
-        void addFilter( const TestCaseFilter& filter ) {
+        void addFilter( TestCaseFilter const& filter ) {
             if( filter.getFilterType() == IfFilterMatches::ExcludeTests )
                 m_exclusionFilters.push_back( filter );
             else
                 m_inclusionFilters.push_back( filter );
         }
 
-        void addTags( const std::string& tagPattern ) {
+        void addTags( std::string const& tagPattern ) {
             TagExpression exp;
             TagExpressionParser( exp ).parse( tagPattern );
 
             m_tagExpressions.push_back( exp );
         }
 
-        bool shouldInclude( const TestCaseInfo& testCase ) const {
+        bool shouldInclude( TestCase const& testCase ) const {
             if( !m_tagExpressions.empty() ) {
                 std::vector<TagExpression>::const_iterator it = m_tagExpressions.begin();
                 std::vector<TagExpression>::const_iterator itEnd = m_tagExpressions.end();

include/internal/catch_text.h

@@ -0,0 +1,61 @@
+/*
+ *  Created by Phil on 18/4/2013.
+ *  Copyright 2013 Two Blue Cubes Ltd. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_CATCH_TEXT_H_INCLUDED
+#define TWOBLUECUBES_CATCH_TEXT_H_INCLUDED
+
+#include "catch_config.hpp"
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+    
+    struct TextAttributes {
+        TextAttributes()
+        :   initialIndent( std::string::npos ),
+            indent( 0 ),
+            width( CATCH_CONFIG_CONSOLE_WIDTH-1 ),
+            tabChar( '\t' )
+        {}
+        
+        TextAttributes& setInitialIndent( std::size_t _value )  { initialIndent = _value; return *this; }
+        TextAttributes& setIndent( std::size_t _value )         { indent = _value; return *this; }
+        TextAttributes& setWidth( std::size_t _value )          { width = _value; return *this; }
+        TextAttributes& setTabChar( char _value )               { tabChar = _value; return *this; }
+
+        std::size_t initialIndent;  // indent of first line, or npos
+        std::size_t indent;         // indent of subsequent lines, or all if initialIndent is npos
+        std::size_t width;          // maximum width of text, including indent. Longer text will wrap
+        char tabChar;               // If this char is seen the indent is changed to current pos
+    };
+
+    class Text {
+    public:
+        Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() );
+        void spliceLine( std::size_t _indent, std::string& _remainder, std::size_t _pos );
+        
+        typedef std::vector<std::string>::const_iterator const_iterator;
+
+        const_iterator begin() const { return lines.begin(); }
+        const_iterator end() const { return lines.end(); }
+        std::string const& last() const { return lines.back(); }
+        std::size_t size() const { return lines.size(); }
+        std::string const& operator[]( std::size_t _index ) const { return lines[_index]; }
+        std::string toString() const;
+
+        friend std::ostream& operator << ( std::ostream& _stream, Text const& _text );
+        
+    private:
+        std::string str;
+        TextAttributes attr;
+        std::vector<std::string> lines;
+    };
+    
+} // end namespace Catch
+
+#endif // TWOBLUECUBES_CATCH_TEXT_H_INCLUDED

include/internal/catch_text.hpp

@@ -0,0 +1,92 @@
+/*
+ *  Created by Phil on 20/4/2013.
+ *  Copyright 2013 Two Blue Cubes Ltd. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_CATCH_TEXT_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_TEXT_HPP_INCLUDED
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+    
+    Text::Text( std::string const& _str, TextAttributes const& _attr )
+    : attr( _attr )
+    {
+        std::string wrappableChars = " [({.,/|\\-";
+        std::size_t indent = _attr.initialIndent != std::string::npos
+            ? _attr.initialIndent
+            : _attr.indent;
+        std::string remainder = _str;
+
+        while( !remainder.empty() ) {
+            assert( lines.size() < 1000 );
+            std::size_t tabPos = std::string::npos;
+            std::size_t width = (std::min)( remainder.size(), _attr.width - indent );
+            std::size_t pos = remainder.find_first_of( '\n' );
+            if( pos <= width ) {
+                width = pos;
+            }
+            pos = remainder.find_last_of( _attr.tabChar, width );
+            if( pos != std::string::npos ) {
+                tabPos = pos;
+                if( remainder[width] == '\n' )
+                    width--;
+                remainder = remainder.substr( 0, tabPos ) + remainder.substr( tabPos+1 );
+            }
+            
+            if( width == remainder.size() ) {
+                spliceLine( indent, remainder, width );
+            }
+            else if( remainder[width] == '\n' ) {
+                spliceLine( indent, remainder, width );
+                if( width <= 1 || remainder.size() != 1 )
+                    remainder = remainder.substr( 1 );
+                indent = _attr.indent;
+            }
+            else {
+                pos = remainder.find_last_of( wrappableChars, width );
+                if( pos != std::string::npos && pos > 0 ) {
+                    spliceLine( indent, remainder, pos );
+                    if( remainder[0] == ' ' )
+                        remainder = remainder.substr( 1 );
+                }
+                else {
+                    spliceLine( indent, remainder, width-1 );
+                    lines.back() += "-";
+                }
+                if( lines.size() == 1 )
+                    indent = _attr.indent;
+                if( tabPos != std::string::npos )
+                    indent += tabPos;
+            }
+        }
+    }
+
+    void Text::spliceLine( std::size_t _indent, std::string& _remainder, std::size_t _pos ) {
+        lines.push_back( std::string( _indent, ' ' ) + _remainder.substr( 0, _pos ) );
+        _remainder = _remainder.substr( _pos );
+    }
+
+    std::string Text::toString() const {
+        std::ostringstream oss;
+        oss << *this;
+        return oss.str();
+    }
+
+    std::ostream& operator << ( std::ostream& _stream, Text const& _text ) {
+        for( Text::const_iterator it = _text.begin(), itEnd = _text.end();
+            it != itEnd; ++it ) {
+            if( it != _text.begin() )
+                _stream << "\n";
+            _stream << *it;
+        }
+        return _stream;
+    }
+    
+} // end namespace Catch
+
+#endif // TWOBLUECUBES_CATCH_TEXT_HPP_INCLUDED

include/internal/catch_tostring.hpp

@@ -9,7 +9,11 @@
 #define TWOBLUECUBES_CATCH_TOSTRING_HPP_INCLUDED
 
 #include "catch_common.h"
+#include "catch_sfinae.hpp"
+
 #include <sstream>
+#include <iomanip>
+#include <limits>
 
 #ifdef __OBJC__
 #include "catch_objc_arc.hpp"
@@ -18,41 +22,99 @@
 namespace Catch {
 namespace Detail {
 
-    struct NonStreamable {
-        template<typename T> NonStreamable( const T& ){}
+// SFINAE is currently disabled by default for all compilers.
+// If the non SFINAE version of IsStreamInsertable is ambiguous for you
+// and your compiler supports SFINAE, try #defining CATCH_CONFIG_SFINAE
+#ifdef CATCH_CONFIG_SFINAE
+
+    template<typename T>
+    class IsStreamInsertableHelper {
+        template<int N> struct TrueIfSizeable : TrueType {};
+
+        template<typename T2>
+        static TrueIfSizeable<sizeof((*(std::ostream*)0) << *((T2 const*)0))> dummy(T2*);
+        static FalseType dummy(...);
+
+    public:
+        typedef SizedIf<sizeof(dummy((T*)0))> type;
     };
     
-    // If the type does not have its own << overload for ostream then
-    // this one will be used instead
-    inline std::ostream& operator << ( std::ostream& ss, NonStreamable ){
-        return ss << "{?}";
-    }
+    template<typename T>
+    struct IsStreamInsertable : IsStreamInsertableHelper<T>::type {};
+
+#else
+
+    struct BorgType {
+        template<typename T> BorgType( T const& );
+    };
+  
+    TrueType& testStreamable( std::ostream& );
+    FalseType testStreamable( FalseType );
+    
+    FalseType operator<<( std::ostream const&, BorgType const& );
 
     template<typename T>
-    inline std::string makeString( const T& value ) {
-        std::ostringstream oss;
-        oss << value;
-        return oss.str();
-    }    
+    struct IsStreamInsertable {
+        static std::ostream &s;
+        static T  const&t;
+        enum { value = sizeof( testStreamable(s << t) ) == sizeof( TrueType ) };
+    };
     
-    template<typename T>
-    inline std::string makeString( T* p ) {
+#endif
+
+    template<bool C>
+    struct StringMakerBase {
+        template<typename T>
+        static std::string convert( T const& ) { return "{?}"; }
+    };
+
+    template<>
+    struct StringMakerBase<true> {
+        template<typename T>
+        static std::string convert( T const& _value ) {
+            std::ostringstream oss;
+            oss << _value;
+            return oss.str();
+        }
+    };
+    
+} // end namespace Detail
+
+template<typename T>
+struct StringMaker :
+    Detail::StringMakerBase<Detail::IsStreamInsertable<T>::value> {};
+
+template<typename T>
+struct StringMaker<T*> {
+    static std::string convert( T const* p ) {
         if( !p )
             return INTERNAL_CATCH_STRINGIFY( NULL );
         std::ostringstream oss;
         oss << p;
         return oss.str();
     }
+};
 
-    template<typename T>
-    inline std::string makeString( const T* p ) {
-        if( !p )
-            return INTERNAL_CATCH_STRINGIFY( NULL );
+template<typename T>
+struct StringMaker<std::vector<T> > {
+    static std::string convert( std::vector<T> const& v ) {
         std::ostringstream oss;
-        oss << p;
+        oss << "{ ";
+        for( std::size_t i = 0; i < v.size(); ++ i ) {
+            oss << toString( v[i] );
+            if( i < v.size() - 1 )
+                oss << ", ";
+        }
+        oss << " }";
         return oss.str();
     }
+};
 
+namespace Detail {
+    template<typename T>
+    inline std::string makeString( T const& value ) {
+        return StringMaker<T>::convert( value );
+    }   
 } // end namespace Detail
 
 /// \brief converts any type to a string
@@ -63,17 +125,17 @@ namespace Detail {
 /// Overload (not specialise) this template for custom typs that you don't want
 /// to provide an ostream overload for.
 template<typename T>
-std::string toString( const T& value ) {
-    return Detail::makeString( value );
+std::string toString( T const& value ) {
+    return StringMaker<T>::convert( value );
 }
     
 // Built in overloads
 
-inline std::string toString( const std::string& value ) {
+inline std::string toString( std::string const& value ) {
     return "\"" + value + "\"";
 }
 
-inline std::string toString( const std::wstring& value ) {
+inline std::string toString( std::wstring const& value ) {
     std::ostringstream oss;
     oss << "\"";
     for(size_t i = 0; i < value.size(); ++i )
@@ -111,7 +173,8 @@ inline std::string toString( unsigned int value ) {
     
 inline std::string toString( const double value ) {
     std::ostringstream oss;
-    oss << value;
+    oss << std::setprecision (std::numeric_limits<double>::digits10 + 1)
+        << value;
     return oss.str();
 }    
 
@@ -121,7 +184,7 @@ inline std::string toString( bool value ) {
 
 inline std::string toString( char value ) {
     return value < ' '
-        ? toString( (unsigned int)value )
+        ? toString( static_cast<unsigned int>( value ) )
         : Detail::makeString( value );
 }
 
@@ -129,6 +192,10 @@ inline std::string toString( signed char value ) {
     return toString( static_cast<char>( value ) );
 }
 
+inline std::string toString( unsigned char value ) {
+    return toString( static_cast<char>( value ) );
+}
+
 #ifdef CATCH_CONFIG_CPP11_NULLPTR
 inline std::string toString( std::nullptr_t ) {
     return "nullptr";
@@ -137,9 +204,13 @@ inline std::string toString( std::nullptr_t ) {
 
 #ifdef __OBJC__
     inline std::string toString( NSString const * const& nsstring ) {
+        if( !nsstring )
+            return "nil";
         return std::string( "@\"" ) + [nsstring UTF8String] + "\"";
     }
     inline std::string toString( NSString * CATCH_ARC_STRONG const& nsstring ) {
+        if( !nsstring )
+            return "nil";
         return std::string( "@\"" ) + [nsstring UTF8String] + "\"";
     }
     inline std::string toString( NSObject* const& nsObject ) {

include/internal/catch_totals.hpp

@@ -15,13 +15,13 @@ namespace Catch {
     struct Counts {
         Counts() : passed( 0 ), failed( 0 ) {}
 
-        Counts operator - ( const Counts& other ) const {
+        Counts operator - ( Counts const& other ) const {
             Counts diff;
             diff.passed = passed - other.passed;
             diff.failed = failed - other.failed;
             return diff;
         }
-        Counts& operator += ( const Counts& other ) {
+        Counts& operator += ( Counts const& other ) {
             passed += other.passed;
             failed += other.failed;
             return *this;
@@ -37,14 +37,14 @@ namespace Catch {
     
     struct Totals {
     
-        Totals operator - ( const Totals& other ) const {
+        Totals operator - ( Totals const& other ) const {
             Totals diff;
             diff.assertions = assertions - other.assertions;
             diff.testCases = testCases - other.testCases;
             return diff;
         }
 
-        Totals delta( const Totals& prevTotals ) const {
+        Totals delta( Totals const& prevTotals ) const {
             Totals diff = *this - prevTotals;
             if( diff.assertions.failed > 0 )
                 ++diff.testCases.failed;
@@ -53,7 +53,7 @@ namespace Catch {
             return diff;
         }
 
-        Totals& operator += ( const Totals& other ) {
+        Totals& operator += ( Totals const& other ) {
             assertions += other.assertions;
             testCases += other.testCases;
             return *this;

include/internal/catch_version.h

@@ -0,0 +1,37 @@
+/*
+ *  Created by Phil on 13/11/2012.
+ *  Copyright 2012 Two Blue Cubes Ltd. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_CATCH_VERSION_H_INCLUDED
+#define TWOBLUECUBES_CATCH_VERSION_H_INCLUDED
+
+namespace Catch {
+
+    // Versioning information
+    struct Version {
+        Version(    unsigned int _majorVersion,
+                    unsigned int _minorVersion,
+                    unsigned int _buildNumber,
+                    std::string const& _branchName )
+        :   majorVersion( _majorVersion ),
+            minorVersion( _minorVersion ),
+            buildNumber( _buildNumber ),
+            branchName( _branchName )
+        {}
+
+        const unsigned int majorVersion;
+        const unsigned int minorVersion;
+        const unsigned int buildNumber;
+        const std::string branchName;
+
+	private:
+		void operator=( Version const& );
+    };
+
+    extern Version libraryVersion;
+}
+
+#endif // TWOBLUECUBES_CATCH_VERSION_H_INCLUDED

include/internal/catch_version.hpp

@@ -0,0 +1,19 @@
+/*
+ *  Created by Phil on 14/11/2012.
+ *  Copyright 2012 Two Blue Cubes Ltd. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_CATCH_VERSION_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_VERSION_HPP_INCLUDED
+
+#include "catch_version.h"
+
+namespace Catch {
+
+    // These numbers are maintained by a script
+    Version libraryVersion( 1, 0, 1, "master" );
+}
+
+#endif // TWOBLUECUBES_CATCH_VERSION_HPP_INCLUDED

include/internal/catch_xmlwriter.hpp

@@ -24,7 +24,7 @@ namespace Catch {
             :   m_writer( writer )
             {}
             
-            ScopedElement( const ScopedElement& other )
+            ScopedElement( ScopedElement const& other )
             :   m_writer( other.m_writer ){
                 other.m_writer = NULL;
             }
@@ -34,13 +34,13 @@ namespace Catch {
                     m_writer->endElement();
             }
 
-            ScopedElement& writeText( const std::string& text ) {
-                m_writer->writeText( text );
+            ScopedElement& writeText( std::string const& text, bool indent = true ) {
+                m_writer->writeText( text, indent );
                 return *this;
             }
 
             template<typename T>
-            ScopedElement& writeAttribute( const std::string& name, const T& attribute ) {
+            ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
                 m_writer->writeAttribute( name, attribute );
                 return *this;
             }
@@ -66,7 +66,7 @@ namespace Catch {
                 endElement();
         }
 
-        XmlWriter& operator = ( const XmlWriter& other ) {
+        XmlWriter& operator = ( XmlWriter const& other ) {
             XmlWriter temp( other );
             swap( temp );
             return *this;
@@ -80,7 +80,7 @@ namespace Catch {
             std::swap( m_os, other.m_os );
         }
         
-        XmlWriter& startElement( const std::string& name ) {
+        XmlWriter& startElement( std::string const& name ) {
             ensureTagClosed();
             newlineIfNecessary();
             stream() << m_indent << "<" << name;
@@ -90,7 +90,7 @@ namespace Catch {
             return *this;
         }
 
-        ScopedElement scopedElement( const std::string& name ) {
+        ScopedElement scopedElement( std::string const& name ) {
             ScopedElement scoped( this );
             startElement( name );
             return scoped;
@@ -110,7 +110,7 @@ namespace Catch {
             return *this;
         }
         
-        XmlWriter& writeAttribute( const std::string& name, const std::string& attribute ) {
+        XmlWriter& writeAttribute( std::string const& name, std::string const& attribute ) {
             if( !name.empty() && !attribute.empty() ) {
                 stream() << " " << name << "=\"";
                 writeEncodedText( attribute );
@@ -119,23 +119,23 @@ namespace Catch {
             return *this;
         }
 
-        XmlWriter& writeAttribute( const std::string& name, bool attribute ) {
+        XmlWriter& writeAttribute( std::string const& name, bool attribute ) {
             stream() << " " << name << "=\"" << ( attribute ? "true" : "false" ) << "\"";
             return *this;
         }
         
         template<typename T>
-        XmlWriter& writeAttribute( const std::string& name, const T& attribute ) {
+        XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
             if( !name.empty() )
                 stream() << " " << name << "=\"" << attribute << "\"";
             return *this;
         }
         
-        XmlWriter& writeText( const std::string& text ) {
+        XmlWriter& writeText( std::string const& text, bool indent = true ) {
             if( !text.empty() ){
                 bool tagWasOpen = m_tagIsOpen;
                 ensureTagClosed();
-                if( tagWasOpen )
+                if( tagWasOpen && indent )
                     stream() << m_indent;
                 writeEncodedText( text );
                 m_needsNewline = true;
@@ -143,7 +143,7 @@ namespace Catch {
             return *this;
         }
         
-        XmlWriter& writeComment( const std::string& text ) {
+        XmlWriter& writeComment( std::string const& text ) {
             ensureTagClosed();
             stream() << m_indent << "<!--" << text << "-->";
             m_needsNewline = true;
@@ -176,7 +176,7 @@ namespace Catch {
             }
         }
         
-        void writeEncodedText( const std::string& text ) {
+        void writeEncodedText( std::string const& text ) {
             static const char* charsToEncode = "<&\"";
             std::string mtext = text;
             std::string::size_type pos = mtext.find_first_of( charsToEncode );

include/internal/clara.h

@@ -0,0 +1,553 @@
+/*
+ *  Created by Phil on 25/05/2013.
+ *  Copyright 2013 Two Blue Cubes Ltd. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_CLARA_H_INCLUDED
+#define TWOBLUECUBES_CLARA_H_INCLUDED
+
+#include "catch_text.h" // This will get moved out too
+
+namespace Clara {
+    namespace Detail {
+        template<typename T> struct RemoveConstRef{ typedef T type; };
+        template<typename T> struct RemoveConstRef<T&>{ typedef T type; };
+        template<typename T> struct RemoveConstRef<T const&>{ typedef T type; };
+        template<typename T> struct RemoveConstRef<T const>{ typedef T type; };
+
+        template<typename T>    struct IsBool       { static const bool value = false; };
+        template<>              struct IsBool<bool> { static const bool value = true; };
+
+        template<typename T>
+        void convertInto( std::string const& _source, T& _dest ) {
+            std::stringstream ss;
+            ss << _source;
+            ss >> _dest;
+            if( ss.fail() )
+                throw std::runtime_error( "Unable to convert " + _source + " to destination type" );
+        }
+        inline void convertInto( std::string const& _source, std::string& _dest ) {
+            _dest = _source;
+        }
+        inline void convertInto( std::string const& _source, bool& _dest ) {
+            std::string sourceLC = _source;
+            std::transform( sourceLC.begin(), sourceLC.end(), sourceLC.begin(), ::tolower );
+            if( sourceLC == "1" || sourceLC == "true" || sourceLC == "yes" || sourceLC == "on" )
+                _dest = true;
+            else if( sourceLC == "0" || sourceLC == "false" || sourceLC == "no" || sourceLC == "off" )
+                _dest = false;
+            else
+                throw std::runtime_error( "Expected a boolean value but did recognise: '" + _source + "'" );
+        }
+        inline void convertInto( bool _source, bool& _dest ) {
+            _dest = _source;
+        }
+        template<typename T>
+        inline void convertInto( bool, T& ) {
+            throw std::runtime_error( "Invalid conversion" );
+        }
+
+        template<typename ConfigT>
+        struct IArgFunction {
+            virtual ~IArgFunction() {}
+            virtual void set( ConfigT& config, std::string const& value ) const = 0;
+            virtual void setFlag( ConfigT& config ) const = 0;
+            virtual bool takesArg() const = 0;
+            virtual IArgFunction* clone() const = 0;
+        };
+
+        template<typename ConfigT>
+        class BoundArgFunction {
+        public:
+            BoundArgFunction( IArgFunction<ConfigT>* _functionObj ) : functionObj( _functionObj ) {}
+            BoundArgFunction( BoundArgFunction const& other ) : functionObj( other.functionObj->clone() ) {}
+            BoundArgFunction& operator = ( BoundArgFunction const& other ) {
+                IArgFunction<ConfigT>* newFunctionObj = other.functionObj->clone();
+                delete functionObj;
+                functionObj = newFunctionObj;
+                return *this;
+            }
+            ~BoundArgFunction() { delete functionObj; }
+
+            void set( ConfigT& config, std::string const& value ) const {
+                functionObj->set( config, value );
+            }
+            void setFlag( ConfigT& config ) const {
+                functionObj->setFlag( config );
+            }
+            bool takesArg() const { return functionObj->takesArg(); }
+        private:
+            IArgFunction<ConfigT>* functionObj;
+        };
+
+
+        template<typename C>
+        struct NullBinder : IArgFunction<C>{
+            virtual void set( C&, std::string const& ) const {}
+            virtual void setFlag( C& ) const {}
+            virtual bool takesArg() const { return true; }
+            virtual IArgFunction<C>* clone() const { return new NullBinder( *this ); }
+        };
+
+        template<typename C, typename M>
+        struct BoundDataMember : IArgFunction<C>{
+            BoundDataMember( M C::* _member ) : member( _member ) {}
+            virtual void set( C& p, std::string const& stringValue ) const {
+                convertInto( stringValue, p.*member );
+            }
+            virtual void setFlag( C& p ) const {
+                convertInto( true, p.*member );
+            }
+            virtual bool takesArg() const { return !IsBool<M>::value; }
+            virtual IArgFunction<C>* clone() const { return new BoundDataMember( *this ); }
+            M C::* member;
+        };
+        template<typename C, typename M>
+        struct BoundUnaryMethod : IArgFunction<C>{
+            BoundUnaryMethod( void (C::*_member)( M ) ) : member( _member ) {}
+            virtual void set( C& p, std::string const& stringValue ) const {
+                typename RemoveConstRef<M>::type value;
+                convertInto( stringValue, value );
+                (p.*member)( value );
+            }
+            virtual void setFlag( C& p ) const {
+                typename RemoveConstRef<M>::type value;
+                convertInto( true, value );
+                (p.*member)( value );
+            }
+            virtual bool takesArg() const { return !IsBool<M>::value; }
+            virtual IArgFunction<C>* clone() const { return new BoundUnaryMethod( *this ); }
+            void (C::*member)( M );
+        };
+        template<typename C>
+        struct BoundNullaryMethod : IArgFunction<C>{
+            BoundNullaryMethod( void (C::*_member)() ) : member( _member ) {}
+            virtual void set( C& p, std::string const& stringValue ) const {
+                bool value;
+                convertInto( stringValue, value );
+                if( value )
+                    (p.*member)();
+            }
+            virtual void setFlag( C& p ) const {
+                (p.*member)();
+            }
+            virtual bool takesArg() const { return false; }
+            virtual IArgFunction<C>* clone() const { return new BoundNullaryMethod( *this ); }
+            void (C::*member)();
+        };
+
+        template<typename C>
+        struct BoundUnaryFunction : IArgFunction<C>{
+            BoundUnaryFunction( void (*_function)( C& ) ) : function( _function ) {}
+            virtual void set( C& obj, std::string const& stringValue ) const {
+                bool value;
+                convertInto( stringValue, value );
+                if( value )
+                    function( obj );
+            }
+            virtual void setFlag( C& p ) const {
+                function( p );
+            }
+            virtual bool takesArg() const { return false; }
+            virtual IArgFunction<C>* clone() const { return new BoundUnaryFunction( *this ); }
+            void (*function)( C& );
+        };
+        
+        template<typename C, typename T>
+        struct BoundBinaryFunction : IArgFunction<C>{
+            BoundBinaryFunction( void (*_function)( C&, T ) ) : function( _function ) {}
+            virtual void set( C& obj, std::string const& stringValue ) const {
+                typename RemoveConstRef<T>::type value;
+                convertInto( stringValue, value );
+                function( obj, value );
+            }
+            virtual void setFlag( C& obj ) const {
+                typename RemoveConstRef<T>::type value;
+                convertInto( true, value );
+                function( obj, value );
+            }
+            virtual bool takesArg() const { return !IsBool<T>::value; }
+            virtual IArgFunction<C>* clone() const { return new BoundBinaryFunction( *this ); }
+            void (*function)( C&, T );
+        };
+        
+        template<typename C, typename M>
+        BoundArgFunction<C> makeBoundField( M C::* _member ) {
+            return BoundArgFunction<C>( new BoundDataMember<C,M>( _member ) );
+        }
+        template<typename C, typename M>
+        BoundArgFunction<C> makeBoundField( void (C::*_member)( M ) ) {
+            return BoundArgFunction<C>( new BoundUnaryMethod<C,M>( _member ) );
+        }
+        template<typename C>
+        BoundArgFunction<C> makeBoundField( void (C::*_member)() ) {
+            return BoundArgFunction<C>( new BoundNullaryMethod<C>( _member ) );
+        }
+        template<typename C>
+        BoundArgFunction<C> makeBoundField( void (*_function)( C& ) ) {
+            return BoundArgFunction<C>( new BoundUnaryFunction<C>( _function ) );
+        }
+        template<typename C, typename T>
+        BoundArgFunction<C> makeBoundField( void (*_function)( C&, T ) ) {
+            return BoundArgFunction<C>( new BoundBinaryFunction<C, T>( _function ) );
+        }
+    } // namespace Detail
+
+    struct Parser {
+        Parser() : separators( " \t=:" ) {}
+
+        struct Token {
+            enum Type { Positional, ShortOpt, LongOpt };
+            Token( Type _type, std::string const& _data ) : type( _type ), data( _data ) {}
+            Type type;
+            std::string data;
+        };
+
+        void parseIntoTokens( int argc, char const * const * argv, std::vector<Parser::Token>& tokens ) const {
+            for( int i = 1; i < argc; ++i )
+                parseIntoTokens( argv[i] , tokens);
+        }        
+        void parseIntoTokens( std::string arg, std::vector<Parser::Token>& tokens ) const {
+            while( !arg.empty() ) {
+                Parser::Token token( Parser::Token::Positional, arg );
+                arg = "";
+                if( token.data[0] == '-' ) {
+                    if( token.data.size() > 1 && token.data[1] == '-' ) {
+                        token = Parser::Token( Parser::Token::LongOpt, token.data.substr( 2 ) );
+                    }
+                    else {
+                        token = Parser::Token( Parser::Token::ShortOpt, token.data.substr( 1 ) );
+                        if( token.data.size() > 1 && separators.find( token.data[1] ) == std::string::npos ) {
+                            arg = "-" + token.data.substr( 1 );
+                            token.data = token.data.substr( 0, 1 );
+                        }
+                    }
+                }
+                if( token.type != Parser::Token::Positional ) {
+                    std::size_t pos = token.data.find_first_of( separators );
+                    if( pos != std::string::npos ) {
+                        arg = token.data.substr( pos+1 );
+                        token.data = token.data.substr( 0, pos );
+                    }
+                }
+                tokens.push_back( token );
+            }
+        }
+        std::string separators;
+    };
+
+    template<typename ConfigT>
+    class CommandLine {
+
+        struct Arg {
+            Arg( Detail::BoundArgFunction<ConfigT> const& _boundField ) : boundField( _boundField ), position( -1 ) {}
+
+            bool hasShortName( std::string const& shortName ) const {
+                for(    std::vector<std::string>::const_iterator
+                            it = shortNames.begin(), itEnd = shortNames.end();
+                        it != itEnd;
+                        ++it )
+                    if( *it == shortName )
+                        return true;
+                return false;
+            }
+            bool hasLongName( std::string const& _longName ) const {
+                return _longName == longName;
+            }
+            bool takesArg() const {
+                return !argName.empty();
+            }
+            bool isFixedPositional() const {
+                return position != -1;
+            }
+            bool isAnyPositional() const {
+                return position == -1 && shortNames.empty() && longName.empty();
+            }
+            std::string dbgName() const {
+                if( !longName.empty() )
+                    return "--" + longName;
+                if( !shortNames.empty() )
+                    return "-" + shortNames[0];
+                return "positional args";
+            }
+            void validate() const {
+                if( boundField.takesArg() && !takesArg() )
+                    throw std::logic_error( dbgName() + " must specify an arg name" );
+            }        
+            std::string commands() const {
+                std::ostringstream oss;
+                bool first = true;
+                std::vector<std::string>::const_iterator it = shortNames.begin(), itEnd = shortNames.end();
+                for(; it != itEnd; ++it ) {
+                    if( first )
+                        first = false;
+                    else
+                        oss << ", ";
+                    oss << "-" << *it;
+                }
+                if( !longName.empty() ) {
+                    if( !first )
+                        oss << ", ";
+                    oss << "--" << longName;
+                }
+                if( !argName.empty() )
+                    oss << " <" << argName << ">";
+                return oss.str();
+            }
+        
+            Detail::BoundArgFunction<ConfigT> boundField;
+            std::vector<std::string> shortNames;
+            std::string longName;
+            std::string description;
+            std::string argName;
+            int position;
+        };
+
+        class ArgBinder {
+        public:
+            template<typename F>
+            ArgBinder( CommandLine* cl, F f )
+            :   m_cl( cl ),
+                m_arg( Detail::makeBoundField( f ) )
+            {}
+            ArgBinder( ArgBinder& other )
+            :   m_cl( other.m_cl ),
+                m_arg( other.m_arg )
+            {
+                other.m_cl = NULL;
+            }
+            ~ArgBinder() {
+                if( m_cl ) {
+                    m_arg.validate();
+                    if( m_arg.isFixedPositional() ) {
+                        m_cl->m_positionalArgs.insert( std::make_pair( m_arg.position, m_arg ) );
+                        if( m_arg.position > m_cl->m_highestSpecifiedArgPosition )
+                            m_cl->m_highestSpecifiedArgPosition = m_arg.position;
+                    }
+                    else if( m_arg.isAnyPositional() ) {
+                        if( m_cl->m_arg.get() )
+                            throw std::logic_error( "Only one unpositional argument can be added" );
+                        m_cl->m_arg = std::auto_ptr<Arg>( new Arg( m_arg ) );
+                    }
+                    else
+                        m_cl->m_options.push_back( m_arg );
+                }
+            }
+            ArgBinder& shortOpt( std::string const& name ) {
+                m_arg.shortNames.push_back( name );
+                return *this;
+            }
+            ArgBinder& longOpt( std::string const& name ) {
+                m_arg.longName = name;
+                return *this;
+            }
+            ArgBinder& describe( std::string const& description ) {
+                m_arg.description = description;
+                return *this;
+            }
+            ArgBinder& argName( std::string const& argName ) {
+                m_arg.argName = argName;
+                return *this;
+            }
+            ArgBinder& position( int position ) {
+                m_arg.position = position;
+                return *this;
+            }
+        private:
+            CommandLine* m_cl;
+            Arg m_arg;
+        };
+
+    public:
+    
+        CommandLine()
+        :   m_boundProcessName( new Detail::NullBinder<ConfigT>() ),
+            m_highestSpecifiedArgPosition( 0 )
+        {}
+        CommandLine( CommandLine const& other )
+        :   m_boundProcessName( other.m_boundProcessName ),
+            m_options ( other.m_options ),
+            m_positionalArgs( other.m_positionalArgs ),
+            m_highestSpecifiedArgPosition( other.m_highestSpecifiedArgPosition )
+        {
+            if( other.m_arg.get() )
+                m_arg = std::auto_ptr<Arg>( new Arg( *other.m_arg ) );
+        }
+
+        template<typename F>
+        ArgBinder bind( F f ) {
+            ArgBinder binder( this, f );
+            return binder;
+        }
+        template<typename F>
+        void bindProcessName( F f ) {
+            m_boundProcessName = Detail::makeBoundField( f );
+        }
+
+        void optUsage( std::ostream& os, std::size_t indent = 0, std::size_t width = CATCH_CONFIG_CONSOLE_WIDTH ) const {
+            typename std::vector<Arg>::const_iterator itBegin = m_options.begin(), itEnd = m_options.end(), it;
+            std::size_t maxWidth = 0;
+            for( it = itBegin; it != itEnd; ++it )
+                maxWidth = (std::max)( maxWidth, it->commands().size() );
+
+            for( it = itBegin; it != itEnd; ++it ) {
+                Catch::Text usage( it->commands(), Catch::TextAttributes()
+                                                        .setWidth( maxWidth+indent )
+                                                        .setIndent( indent ) );
+                // !TBD handle longer usage strings
+                Catch::Text desc( it->description, Catch::TextAttributes()
+                                                        .setWidth( width - maxWidth -3 ) );
+
+                for( std::size_t i = 0; i < std::max( usage.size(), desc.size() ); ++i ) {
+                    std::string usageCol = i < usage.size() ? usage[i] : "";
+                    os << usageCol;
+
+                    if( i < desc.size() && !desc[i].empty() )
+                        os  << std::string( indent + 2 + maxWidth - usageCol.size(), ' ' )
+                            << desc[i];
+                    os << "\n";
+                }                
+            }            
+        }
+        std::string optUsage() const {
+            std::ostringstream oss;
+            optUsage( oss );
+            return oss.str();
+        }
+        
+        void argSynopsis( std::ostream& os ) const {
+            for( int i = 1; i <= m_highestSpecifiedArgPosition; ++i ) {
+                if( i > 1 )
+                    os << " ";
+                typename std::map<int, Arg>::const_iterator it = m_positionalArgs.find( i );
+                if( it != m_positionalArgs.end() )
+                    os << "<" << it->second.argName << ">";
+                else if( m_arg.get() )
+                    os << "<" << m_arg->argName << ">";
+                else
+                    throw std::logic_error( "non consecutive positional arguments with no floating args" );
+            }
+            // !TBD No indication of mandatory args
+            if( m_arg.get() ) {
+                if( m_highestSpecifiedArgPosition > 1 )
+                    os << " ";
+                os << "[<" << m_arg->argName << "> ...]";
+            }
+        }
+        std::string argSynopsis() const {
+            std::ostringstream oss;
+            argSynopsis( oss );
+            return oss.str();
+        }
+        
+        void usage( std::ostream& os, std::string const& procName ) const {
+            os << "usage:\n  " << procName << " ";
+            argSynopsis( os );
+            if( !m_options.empty() ) {
+                os << " [options]\n\nwhere options are: \n";
+                optUsage( os, 2 );                
+            }
+            os << "\n";
+        }
+        std::string usage( std::string const& procName ) const {
+            std::ostringstream oss;
+            usage( oss, procName );
+            return oss.str();
+        }        
+        
+        std::vector<Parser::Token> parseInto( int argc, char const * const * argv, ConfigT& config ) const {
+            std::string processName = argv[0];
+            std::size_t lastSlash = processName.find_last_of( "/\\" );
+            if( lastSlash != std::string::npos )
+                processName = processName.substr( lastSlash+1 );
+            m_boundProcessName.set( config, processName );
+            std::vector<Parser::Token> tokens;
+            Parser parser;
+            parser.parseIntoTokens( argc, argv, tokens );
+            return populate( tokens, config );
+        }
+
+        std::vector<Parser::Token> populate( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
+            if( m_options.empty() && m_positionalArgs.empty() )
+                throw std::logic_error( "No options or arguments specified" );
+
+            std::vector<Parser::Token> unusedTokens = populateOptions( tokens, config );
+            unusedTokens = populateFixedArgs( unusedTokens, config );
+            unusedTokens = populateFloatingArgs( unusedTokens, config );
+            return unusedTokens;
+        }
+
+        std::vector<Parser::Token> populateOptions( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
+            std::vector<Parser::Token> unusedTokens;
+            for( std::size_t i = 0; i < tokens.size(); ++i ) {
+                Parser::Token const& token = tokens[i];
+                typename std::vector<Arg>::const_iterator it = m_options.begin(), itEnd = m_options.end();
+                for(; it != itEnd; ++it ) {
+                    Arg const& arg = *it;
+                        
+                    try {
+                        if( ( token.type == Parser::Token::ShortOpt && arg.hasShortName( token.data ) ) ||
+                            ( token.type == Parser::Token::LongOpt && arg.hasLongName( token.data ) ) ) {
+                            if( arg.takesArg() ) {
+                                if( i == tokens.size()-1 || tokens[i+1].type != Parser::Token::Positional )
+                                    throw std::domain_error( "Expected argument to option " + token.data );
+                                arg.boundField.set( config, tokens[++i].data );
+                            }
+                            else {
+                                arg.boundField.setFlag( config );
+                            }
+                            break;
+                        }
+                    }
+                    catch( std::exception& ex ) {
+                        throw std::runtime_error( std::string( ex.what() ) + " while parsing: (" + arg.commands() + ")" );
+                    }
+                }
+                if( it == itEnd )
+                    unusedTokens.push_back( token );
+            }
+            return unusedTokens;
+        }
+        std::vector<Parser::Token> populateFixedArgs( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
+            std::vector<Parser::Token> unusedTokens;
+            int position = 1;
+            for( std::size_t i = 0; i < tokens.size(); ++i ) {
+                Parser::Token const& token = tokens[i];
+                typename std::map<int, Arg>::const_iterator it = m_positionalArgs.find( position );
+                if( it != m_positionalArgs.end() )
+                    it->second.boundField.set( config, token.data );
+                else
+                    unusedTokens.push_back( token );
+                if( token.type == Parser::Token::Positional )
+                    position++;                
+            }
+            return unusedTokens;
+        }
+        std::vector<Parser::Token> populateFloatingArgs( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
+            if( !m_arg.get() )
+                return tokens;
+            std::vector<Parser::Token> unusedTokens;
+            for( std::size_t i = 0; i < tokens.size(); ++i ) {
+                Parser::Token const& token = tokens[i];
+                if( token.type == Parser::Token::Positional )
+                    m_arg->boundField.set( config, token.data );
+                else
+                    unusedTokens.push_back( token );
+            }
+            return unusedTokens;
+        }
+        
+    private:
+        Detail::BoundArgFunction<ConfigT> m_boundProcessName;
+        std::vector<Arg> m_options;
+        std::map<int, Arg> m_positionalArgs;
+        std::auto_ptr<Arg> m_arg;
+        int m_highestSpecifiedArgPosition;
+    };
+    
+} // end namespace Clara
+
+
+#endif // TWOBLUECUBES_CLARA_H_INCLUDED

include/reporters/catch_reporter_basic.hpp

@@ -54,27 +54,27 @@ namespace Catch {
 
         void ReportCounts( const std::string& label, const Counts& counts, const std::string& allPrefix = "All " ) {
             if( counts.passed )
-                m_config.stream << counts.failed << " of " << counts.total() << " " << label << "s failed";
+                m_config.stream() << counts.failed << " of " << counts.total() << " " << label << "s failed";
             else
-                m_config.stream << ( counts.failed > 1 ? allPrefix : "" ) << pluralise( counts.failed, label ) << " failed";
+                m_config.stream() << ( counts.failed > 1 ? allPrefix : "" ) << pluralise( counts.failed, label ) << " failed";
         }
 
         void ReportCounts( const Totals& totals, const std::string& allPrefix = "All " ) {
             if( totals.assertions.total() == 0 ) {
-                m_config.stream << "No tests ran";
+                m_config.stream() << "No tests ran";
             }
             else if( totals.assertions.failed ) {
-                TextColour colour( TextColour::ResultError );
+                Colour colour( Colour::ResultError );
                 ReportCounts( "test case", totals.testCases, allPrefix );
                 if( totals.testCases.failed > 0 ) {
-                    m_config.stream << " (";
+                    m_config.stream() << " (";
                     ReportCounts( "assertion", totals.assertions, allPrefix );
-                    m_config.stream << ")";
+                    m_config.stream() << ")";
                 }
             }
             else {
-                TextColour colour( TextColour::ResultSuccess );
-                m_config.stream   << allPrefix << "tests passed ("
+                Colour colour( Colour::ResultSuccess );
+                m_config.stream()   << allPrefix << "tests passed ("
                                     << pluralise( totals.assertions.passed, "assertion" ) << " in "
                                     << pluralise( totals.testCases.passed, "test case" ) << ")";
             }
@@ -97,14 +97,14 @@ namespace Catch {
         virtual void EndTesting( const Totals& totals ) {
             // Output the overall test results even if "Started Testing" was not emitted
             if( m_aborted ) {
-                m_config.stream << "\n[Testing aborted. ";
+                m_config.stream() << "\n[Testing aborted. ";
                 ReportCounts( totals, "The first " );
             }
             else {
-                m_config.stream << "\n[Testing completed. ";
+                m_config.stream() << "\n[Testing completed. ";
                 ReportCounts( totals );
             }
-            m_config.stream << "]\n" << std::endl;
+            m_config.stream() << "]\n" << std::endl;
         }
 
         virtual void StartGroup( const std::string& groupName ) {
@@ -113,15 +113,15 @@ namespace Catch {
 
         virtual void EndGroup( const std::string& groupName, const Totals& totals ) {
             if( m_groupSpan.emitted && !groupName.empty() ) {
-                m_config.stream << "[End of group: '" << groupName << "'. ";
+                m_config.stream() << "[End of group: '" << groupName << "'. ";
                 ReportCounts( totals );
-                m_config.stream << "]\n" << std::endl;
+                m_config.stream() << "]\n" << std::endl;
                 m_groupSpan = SpanInfo();
             }
         }
         
         virtual void StartTestCase( const TestCaseInfo& testInfo ) {
-            m_testSpan = testInfo.getName();
+            m_testSpan = testInfo.name;
         }
         
         virtual void StartSection( const std::string& sectionName, const std::string& ) {
@@ -130,98 +130,98 @@ namespace Catch {
 
         virtual void NoAssertionsInSection( const std::string& sectionName ) {
             startSpansLazily();
-            TextColour colour( TextColour::ResultError );
-            m_config.stream << "\nNo assertions in section, '" << sectionName << "'\n" << std::endl;
+            Colour colour( Colour::ResultError );
+            m_config.stream() << "\nNo assertions in section, '" << sectionName << "'\n" << std::endl;
         }
         virtual void NoAssertionsInTestCase( const std::string& testName ) {
             startSpansLazily();
-            TextColour colour( TextColour::ResultError );
-            m_config.stream << "\nNo assertions in test case, '" << testName << "'\n" << std::endl;
+            Colour colour( Colour::ResultError );
+            m_config.stream() << "\nNo assertions in test case, '" << testName << "'\n" << std::endl;
         }
 
         virtual void EndSection( const std::string& sectionName, const Counts& assertions ) {
 
             SpanInfo& sectionSpan = m_sectionSpans.back();
             if( sectionSpan.emitted && !sectionSpan.name.empty() ) {
-                m_config.stream << "[End of section: '" << sectionName << "' ";
+                m_config.stream() << "[End of section: '" << sectionName << "' ";
                 
                 if( assertions.failed ) {
-                    TextColour colour( TextColour::ResultError );
+                    Colour colour( Colour::ResultError );
                     ReportCounts( "assertion", assertions);
                 }
                 else {
-                    TextColour colour( TextColour::ResultSuccess );
-                    m_config.stream   << ( assertions.passed > 1 ? "All " : "" ) 
+                    Colour colour( Colour::ResultSuccess );
+                    m_config.stream()   << ( assertions.passed > 1 ? "All " : "" )
                                         << pluralise( assertions.passed, "assertion" ) << " passed" ;
                 }
-                m_config.stream << "]\n" << std::endl;
+                m_config.stream() << "]\n" << std::endl;
             }
             m_sectionSpans.pop_back();
         }
         
         virtual void Result( const AssertionResult& assertionResult ) {
-            if( !m_config.includeSuccessfulResults && assertionResult.getResultType() == ResultWas::Ok )
+            if( !m_config.fullConfig()->includeSuccessfulResults() && assertionResult.getResultType() == ResultWas::Ok )
                 return;
             
             startSpansLazily();
             
             if( !assertionResult.getSourceInfo().empty() ) {
-                TextColour colour( TextColour::FileName );
-                m_config.stream << assertionResult.getSourceInfo();
+                Colour colour( Colour::FileName );
+                m_config.stream() << assertionResult.getSourceInfo() << ": ";
             }
             
             if( assertionResult.hasExpression() ) {
-                TextColour colour( TextColour::OriginalExpression );
-                m_config.stream << assertionResult.getExpression();
+                Colour colour( Colour::OriginalExpression );
+                m_config.stream() << assertionResult.getExpression();
                 if( assertionResult.succeeded() ) {
-                    TextColour successColour( TextColour::Success );
-                    m_config.stream << " succeeded";
+                    Colour successColour( Colour::Success );
+                    m_config.stream() << " succeeded";
                 }
                 else {
-                    TextColour errorColour( TextColour::Error );
-                    m_config.stream << " failed";
+                    Colour errorColour( Colour::Error );
+                    m_config.stream() << " failed";
                     if( assertionResult.isOk() ) {
-                        TextColour okAnywayColour( TextColour::Success );
-                        m_config.stream << " - but was ok";
+                        Colour okAnywayColour( Colour::Success );
+                        m_config.stream() << " - but was ok";
                     }
                 }
             }
             switch( assertionResult.getResultType() ) {
                 case ResultWas::ThrewException:
                     {
-                        TextColour colour( TextColour::Error );
+                        Colour colour( Colour::Error );
                         if( assertionResult.hasExpression() )
-                            m_config.stream << " with unexpected";
+                            m_config.stream() << " with unexpected";
                         else
-                            m_config.stream << "Unexpected";
-                        m_config.stream << " exception with message: '" << assertionResult.getMessage() << "'";
+                            m_config.stream() << "Unexpected";
+                        m_config.stream() << " exception with message: '" << assertionResult.getMessage() << "'";
                     }
                     break;
                 case ResultWas::DidntThrowException:
                     {
-                        TextColour colour( TextColour::Error );
+                        Colour colour( Colour::Error );
                         if( assertionResult.hasExpression() )
-                            m_config.stream << " because no exception was thrown where one was expected";
+                            m_config.stream() << " because no exception was thrown where one was expected";
                         else
-                            m_config.stream << "No exception thrown where one was expected";
+                            m_config.stream() << "No exception thrown where one was expected";
                     }
                     break;
                 case ResultWas::Info:
                     {
-                        TextColour colour( TextColour::ReconstructedExpression );
+                        Colour colour( Colour::ReconstructedExpression );
                         streamVariableLengthText( "info", assertionResult.getMessage() );
                     }
                     break;
                 case ResultWas::Warning:
                     {
-                        TextColour colour( TextColour::ReconstructedExpression );
+                        Colour colour( Colour::ReconstructedExpression );
                         streamVariableLengthText( "warning", assertionResult.getMessage() );
                     }
                     break;
                 case ResultWas::ExplicitFailure:
                     {
-                        TextColour colour( TextColour::Error );
-                        m_config.stream << "failed with message: '" << assertionResult.getMessage() << "'";
+                        Colour colour( Colour::Error );
+                        m_config.stream() << "failed with message: '" << assertionResult.getMessage() << "'";
                     }
                     break;
                 case ResultWas::Unknown: // These cases are here to prevent compiler warnings
@@ -231,32 +231,37 @@ namespace Catch {
                 case ResultWas::Exception:
                     if( !assertionResult.hasExpression() ) {
                         if( assertionResult.succeeded() ) {
-                            TextColour colour( TextColour::Success );
-                            m_config.stream << " succeeded";
+                            Colour colour( Colour::Success );
+                            m_config.stream() << " succeeded";
                         }
                         else {
-                            TextColour colour( TextColour::Error );
-                            m_config.stream << " failed";
+                            Colour colour( Colour::Error );
+                            m_config.stream() << " failed";
                             if( assertionResult.isOk() ) {
-                                TextColour okAnywayColour( TextColour::Success );
-                                m_config.stream << " - but was ok";
+                                Colour okAnywayColour( Colour::Success );
+                                m_config.stream() << " - but was ok";
                             }
                         }
                     }
+                    if( assertionResult.hasMessage() ) {
+                        m_config.stream() << "\n";
+                        Colour colour( Colour::ReconstructedExpression );
+                        streamVariableLengthText( "with message", assertionResult.getMessage() );
+                    }
                     break;
             }
             
             if( assertionResult.hasExpandedExpression() ) {
-                m_config.stream << " for: ";
+                m_config.stream() << " for: ";
                 if( assertionResult.getExpandedExpression().size() > 40 ) {
-                    m_config.stream << "\n";
+                    m_config.stream() << "\n";
                     if( assertionResult.getExpandedExpression().size() < 70 )
-                        m_config.stream << "\t";
+                        m_config.stream() << "\t";
                 }
-                TextColour colour( TextColour::ReconstructedExpression );
-                m_config.stream << assertionResult.getExpandedExpression();
+                Colour colour( Colour::ReconstructedExpression );
+                m_config.stream() << assertionResult.getExpandedExpression();
             }
-            m_config.stream << std::endl;        
+            m_config.stream() << std::endl;
         }
         
         virtual void EndTestCase(   const TestCaseInfo& testInfo, 
@@ -274,9 +279,9 @@ namespace Catch {
             }
             
             if( m_testSpan.emitted ) {
-                m_config.stream << "[Finished: '" << testInfo.getName() << "' ";
+                m_config.stream() << "[Finished: '" << testInfo.name << "' ";
                 ReportCounts( totals );
-                m_config.stream << "]" << std::endl;
+                m_config.stream() << "]" << std::endl;
             }
         }    
         
@@ -284,20 +289,20 @@ namespace Catch {
         
         void startSpansLazily() {
             if( !m_testingSpan.emitted ) {
-                if( m_config.name.empty() )
-                    m_config.stream << "[Started testing]" << std::endl;
+                if( m_config.fullConfig()->name().empty() )
+                    m_config.stream() << "[Started testing]" << std::endl;
                 else
-                    m_config.stream << "[Started testing: " << m_config.name << "]" << std::endl;
+                    m_config.stream() << "[Started testing: " << m_config.fullConfig()->name() << "]" << std::endl;
                 m_testingSpan.emitted = true;
             }
             
             if( !m_groupSpan.emitted && !m_groupSpan.name.empty() ) {
-                m_config.stream << "[Started group: '" << m_groupSpan.name << "']" << std::endl;
+                m_config.stream() << "[Started group: '" << m_groupSpan.name << "']" << std::endl;
                 m_groupSpan.emitted = true;
             }
             
             if( !m_testSpan.emitted ) {
-                m_config.stream << std::endl << "[Running: " << m_testSpan.name << "]" << std::endl;
+                m_config.stream() << std::endl << "[Running: " << m_testSpan.name << "]" << std::endl;
                 m_testSpan.emitted = true;
             }
             
@@ -305,7 +310,7 @@ namespace Catch {
                 SpanInfo& sectionSpan = m_sectionSpans.back();
                 if( !sectionSpan.emitted && !sectionSpan.name.empty() ) {
                     if( m_firstSectionInTestCase ) {
-                        m_config.stream << "\n";
+                        m_config.stream() << "\n";
                         m_firstSectionInTestCase = false;
                     }
                     std::vector<SpanInfo>::iterator it = m_sectionSpans.begin();
@@ -313,7 +318,7 @@ namespace Catch {
                     for(; it != itEnd; ++it ) {
                         SpanInfo& prevSpan = *it;
                         if( !prevSpan.emitted && !prevSpan.name.empty() ) {
-                            m_config.stream << "[Started section: '" << prevSpan.name << "']" << std::endl;
+                            m_config.stream() << "[Started section: '" << prevSpan.name << "']" << std::endl;
                             prevSpan.emitted = true;
                         }                        
                     }
@@ -324,10 +329,10 @@ namespace Catch {
         void streamVariableLengthText( const std::string& prefix, const std::string& text ) {
             std::string trimmed = trim( text );
             if( trimmed.find_first_of( "\r\n" ) == std::string::npos ) {
-                m_config.stream << "[" << prefix << ": " << trimmed << "]";
+                m_config.stream() << "[" << prefix << ": " << trimmed << "]";
             }
             else {
-                m_config.stream << "\n[" << prefix << "] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n" << trimmed 
+                m_config.stream() << "\n[" << prefix << "] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n" << trimmed 
                 << "\n[end of " << prefix << "] <<<<<<<<<<<<<<<<<<<<<<<<\n";
             }
         }

include/reporters/catch_reporter_console.hpp

@@ -0,0 +1,396 @@
+/*
+ *  Created by Phil on 5/12/2012.
+ *  Copyright 2012 Two Blue Cubes Ltd. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_CATCH_REPORTER_CONSOLE_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_REPORTER_CONSOLE_HPP_INCLUDED
+
+#include "../internal/catch_interfaces_reporter.h"
+#include "../internal/catch_reporter_registrars.hpp"
+#include "../internal/catch_console_colour.hpp"
+
+namespace Catch {
+
+    struct ConsoleReporter : StreamingReporterBase {
+        ConsoleReporter( ReporterConfig const& _config )
+        :   StreamingReporterBase( _config ),
+            m_headerPrinted( false ),
+            m_atLeastOneTestCasePrinted( false )
+        {}
+
+        virtual ~ConsoleReporter();
+        static std::string getDescription() {
+            return "Reports test results as plain lines of text";
+        }
+        virtual ReporterPreferences getPreferences() const {
+            ReporterPreferences prefs;
+            prefs.shouldRedirectStdOut = false;
+            return prefs;
+
+        }
+
+        virtual void noMatchingTestCases( std::string const& spec ) {
+            stream << "No test cases matched '" << spec << "'" << std::endl;
+        }
+        
+        virtual void assertionStarting( AssertionInfo const& ) {
+        }
+
+        virtual void assertionEnded( AssertionStats const& _assertionStats ) {
+            AssertionResult const& result = _assertionStats.assertionResult;
+            
+            // Drop out if result was successful and we're not printing those
+            if( !m_config->includeSuccessfulResults() && result.isOk() )
+                return;
+            
+            lazyPrint();
+
+            AssertionPrinter printer( stream, _assertionStats );
+            printer.print();
+            stream << std::endl;
+        }
+
+        virtual void sectionStarting( SectionInfo const& _sectionInfo ) {
+            m_headerPrinted = false;
+            StreamingReporterBase::sectionStarting( _sectionInfo );
+        }
+        virtual void sectionEnded( SectionStats const& _sectionStats ) {
+            if( _sectionStats.missingAssertions ) {
+                lazyPrint();
+                Colour colour( Colour::ResultError );
+                stream << "\nNo assertions in section, '" << _sectionStats.sectionInfo.name << "'\n" << std::endl;
+            }
+            m_headerPrinted = false;
+            StreamingReporterBase::sectionEnded( _sectionStats );
+        }
+
+        virtual void testCaseEnded( TestCaseStats const& _testCaseStats ) {
+
+            if( _testCaseStats.missingAssertions ) {
+                lazyPrint();
+                Colour colour( Colour::ResultError );
+                stream << "\nNo assertions in test case, '" << _testCaseStats.testInfo.name << "'\n" << std::endl;
+            }
+            StreamingReporterBase::testCaseEnded( _testCaseStats );
+            m_headerPrinted = false;
+        }
+        virtual void testGroupEnded( TestGroupStats const& _testGroupStats ) {
+            if( !unusedGroupInfo ) {
+                printSummaryDivider();
+                stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
+                printTotals( _testGroupStats.totals );
+                stream << "\n" << std::endl;
+            }
+            StreamingReporterBase::testGroupEnded( _testGroupStats );
+        }
+        virtual void testRunEnded( TestRunStats const& _testRunStats ) {
+            if( m_atLeastOneTestCasePrinted )
+                printTotalsDivider();
+            printTotals( _testRunStats.totals );
+            stream << "\n" << std::endl;
+            StreamingReporterBase::testRunEnded( _testRunStats );
+        }
+
+    private:
+        
+        class AssertionPrinter {
+			void operator= ( AssertionPrinter const& );
+        public:
+            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats )
+            :   stream( _stream ),
+                stats( _stats ),
+                result( _stats.assertionResult ),
+                colour( Colour::None ),
+                message( result.getMessage() ),
+                messages( _stats.infoMessages )
+            {
+                switch( result.getResultType() ) {
+                    case ResultWas::Ok:
+                        colour = Colour::Success;
+                        passOrFail = "PASSED";
+                        //if( result.hasMessage() )
+                        if( _stats.infoMessages.size() == 1 )
+                            messageLabel = "with message";
+                        if( _stats.infoMessages.size() > 1 )
+                            messageLabel = "with messages";
+                        break;
+                    case ResultWas::ExpressionFailed:
+                        if( result.isOk() ) {
+                            colour = Colour::Success;
+                            passOrFail = "FAILED - but was ok";
+                        }
+                        else {
+                            colour = Colour::Error;
+                            passOrFail = "FAILED";
+                        }
+                        if( _stats.infoMessages.size() == 1 )
+                            messageLabel = "with message";
+                        if( _stats.infoMessages.size() > 1 )
+                            messageLabel = "with messages";
+                        break;
+                    case ResultWas::ThrewException:
+                        colour = Colour::Error;
+                        passOrFail = "FAILED";
+                        messageLabel = "due to unexpected exception with message";
+                        break;
+                    case ResultWas::DidntThrowException:
+                        colour = Colour::Error;
+                        passOrFail = "FAILED";
+                        messageLabel = "because no exception was thrown where one was expected";
+                        break;
+                    case ResultWas::Info:
+                        messageLabel = "info";
+                        break;
+                    case ResultWas::Warning:
+                        messageLabel = "warning";
+                        break;
+                    case ResultWas::ExplicitFailure:
+                        passOrFail = "FAILED";
+                        colour = Colour::Error;
+                        if( _stats.infoMessages.size() == 1 )
+                            messageLabel = "explicitly with message";
+                        if( _stats.infoMessages.size() > 1 )
+                            messageLabel = "explicitly with messages";
+                        break;
+                    // These cases are here to prevent compiler warnings
+                    case ResultWas::Unknown:
+                    case ResultWas::FailureBit:
+                    case ResultWas::Exception:
+                        passOrFail = "** internal error **";
+                        colour = Colour::Error;
+                        break;
+                }
+            }
+            
+            void print() const {
+                printSourceInfo();
+                if( stats.totals.assertions.total() > 0 ) {
+                    if( result.isOk() )
+                        stream << "\n";
+                    printResultType();
+                    printOriginalExpression();
+                    printReconstructedExpression();
+                }
+                else {
+                    stream << "\n";
+                }
+                printMessage();
+            }
+            
+        private:
+            void printResultType() const {
+                if( !passOrFail.empty() ) {
+                    Colour colourGuard( colour );
+                    stream << passOrFail << ":\n";
+                }
+            }
+            void printOriginalExpression() const {
+                if( result.hasExpression() ) {
+                    Colour colourGuard( Colour::OriginalExpression );
+                    stream  << "  ";
+                    stream << result.getExpressionInMacro();
+                    stream << "\n";
+                }
+            }
+            void printReconstructedExpression() const {
+                if( result.hasExpandedExpression() ) {
+                    stream << "with expansion:\n";
+                    Colour colourGuard( Colour::ReconstructedExpression );
+                    stream << Text( result.getExpandedExpression(), TextAttributes().setIndent(2) ) << "\n";
+                }
+            }
+            void printMessage() const {
+                if( !messageLabel.empty() )
+                    stream << messageLabel << ":" << "\n";
+                for( std::vector<MessageInfo>::const_iterator it = messages.begin(), itEnd = messages.end();
+                        it != itEnd;
+                        ++it ) {                    
+                    stream << Text( it->message, TextAttributes().setIndent(2) ) << "\n";
+                }
+            }
+            void printSourceInfo() const {
+                Colour colourGuard( Colour::FileName );
+                stream << result.getSourceInfo() << ": ";
+            }
+            
+            std::ostream& stream;
+            AssertionStats const& stats;
+            AssertionResult const& result;
+            Colour::Code colour;
+            std::string passOrFail;
+            std::string messageLabel;
+            std::string message;
+            std::vector<MessageInfo> messages;
+        };
+        
+        void lazyPrint() {
+            
+            if( testRunInfo )
+                lazyPrintRunInfo();
+            if( unusedGroupInfo )
+                lazyPrintGroupInfo();
+            
+            if( !m_headerPrinted ) {
+                printTestCaseAndSectionHeader();
+                m_headerPrinted = true;
+            }
+            m_atLeastOneTestCasePrinted = true;
+        }
+        void lazyPrintRunInfo() {
+            stream  << "\n" << getTildes() << "\n";
+            Colour colour( Colour::SecondaryText );
+            stream  << testRunInfo->name
+                    << " is a Catch v"  << libraryVersion.majorVersion << "."
+                    << libraryVersion.minorVersion << " b"
+                    << libraryVersion.buildNumber;
+            if( libraryVersion.branchName != "master" )
+                stream << " (" << libraryVersion.branchName << ")";
+            stream  << " host application.\n"
+                    << "Run with -? for options\n\n";
+            
+            testRunInfo.reset();
+        }
+        void lazyPrintGroupInfo() {
+            if( !unusedGroupInfo->name.empty() && unusedGroupInfo->groupsCounts > 1 ) {
+                printClosedHeader( "Group: " + unusedGroupInfo->name );
+                unusedGroupInfo.reset();
+            }
+        }
+        void printTestCaseAndSectionHeader() {
+            printOpenHeader( unusedTestCaseInfo->name );
+            if( currentSectionInfo ) {
+                Colour colourGuard( Colour::Headers );
+                std::vector<ThreadedSectionInfo*> sections;
+                for(    ThreadedSectionInfo* section = currentSectionInfo.get();
+                        section;
+                        section = section->parent )
+                    sections.push_back( section );
+                
+                // Sections
+                if( !sections.empty() ) {                    
+                    typedef std::vector<ThreadedSectionInfo*>::const_reverse_iterator It;
+                    for( It it = sections.rbegin(), itEnd = sections.rend(); it != itEnd; ++it )
+                        printHeaderString( (*it)->name, 2 );
+
+                }
+            }
+            SourceLineInfo lineInfo = currentSectionInfo
+                                    ? currentSectionInfo->lineInfo
+                                    : unusedTestCaseInfo->lineInfo;
+            
+            if( !lineInfo.empty() ){
+                stream << getDashes() << "\n";
+                Colour colourGuard( Colour::FileName );
+                stream << lineInfo << "\n";
+            }
+            stream << getDots() << "\n" << std::endl;
+        }
+
+        void printClosedHeader( std::string const& _name ) {
+            printOpenHeader( _name );
+            stream << getDots() << "\n";
+        }
+        void printOpenHeader( std::string const& _name ) {
+            stream  << getDashes() << "\n";
+            {
+                Colour colourGuard( Colour::Headers );
+                printHeaderString( _name );
+            }
+        }
+
+        // if string has a : in first line will set indent to follow it on
+        // subsequent lines
+        void printHeaderString( std::string const& _string, std::size_t indent = 0 ) {
+            std::size_t i = _string.find( ": " );
+            if( i != std::string::npos )
+                i+=2;
+            else
+                i = 0;
+            stream << Text( _string, TextAttributes()
+                                        .setIndent( indent+i)
+                                        .setInitialIndent( indent ) ) << "\n";
+        }
+        
+        void printTotals( const Totals& totals ) {
+            if( totals.assertions.total() == 0 ) {
+                stream << "No tests ran";
+            }
+            else if( totals.assertions.failed ) {
+                Colour colour( Colour::ResultError );
+                printCounts( "test case", totals.testCases );
+                if( totals.testCases.failed > 0 ) {
+                    stream << " (";
+                    printCounts( "assertion", totals.assertions );
+                    stream << ")";
+                }
+            }
+            else {
+                Colour colour( Colour::ResultSuccess );
+                stream << "All tests passed ("
+                        << pluralise( totals.assertions.passed, "assertion" ) << " in "
+                        << pluralise( totals.testCases.passed, "test case" ) << ")";
+            }
+        }
+        void printCounts( std::string const& label, Counts const& counts ) {
+            if( counts.total() == 1 ) {
+                stream << "1 " << label << " - ";
+                if( counts.failed )
+                    stream << "failed";
+                else
+                    stream << "passed";
+            }
+            else {
+                stream << counts.total() << " " << label << "s ";
+                if( counts.passed ) {
+                    if( counts.failed )
+                        stream << "- " << counts.failed << " failed";
+                    else if( counts.passed == 2 )
+                        stream << "- both passed";
+                    else
+                        stream << "- all passed";
+                }
+                else {
+                    if( counts.failed == 2 )
+                        stream << "- both failed";
+                    else
+                        stream << "- all failed";
+                }
+            }
+        }
+                
+        void printTotalsDivider() {
+            stream << getDoubleDashes() << "\n";
+        }
+        void printSummaryDivider() {
+            stream << getDashes() << "\n";
+        }
+        static std::string const& getDashes() {
+            static const std::string dashes( CATCH_CONFIG_CONSOLE_WIDTH-1, '-' );
+            return dashes;
+        }
+        static std::string const& getDots() {
+            static const std::string dots( CATCH_CONFIG_CONSOLE_WIDTH-1, '.' );
+            return dots;
+        }
+        static std::string const& getDoubleDashes() {
+            static const std::string doubleDashes( CATCH_CONFIG_CONSOLE_WIDTH-1, '=' );
+            return doubleDashes;
+        }
+        static std::string const& getTildes() {
+            static const std::string dots( CATCH_CONFIG_CONSOLE_WIDTH-1, '~' );
+            return dots;
+        }
+        
+    private:
+        bool m_headerPrinted;
+        bool m_atLeastOneTestCasePrinted;
+    };
+
+    INTERNAL_CATCH_REGISTER_REPORTER( "console", ConsoleReporter )
+
+} // end namespace Catch
+
+#endif // TWOBLUECUBES_CATCH_REPORTER_CONSOLE_HPP_INCLUDED

include/reporters/catch_reporter_junit.hpp

@@ -13,6 +13,8 @@
 #include "../internal/catch_reporter_registrars.hpp"
 #include "../internal/catch_xmlwriter.hpp"
 
+#include <assert.h>
+
 namespace Catch {
 
     class JunitReporter : public SharedImpl<IReporter> {
@@ -35,7 +37,10 @@ namespace Catch {
             std::string m_status;
             std::string m_className;
             std::string m_name;
+            std::string m_stdOut;
+            std::string m_stdErr;
             std::vector<TestStats> m_testStats;
+            std::vector<TestCaseStats> m_sections;
         };
         
         struct Stats {
@@ -60,7 +65,7 @@ namespace Catch {
         };
         
     public:
-        JunitReporter( const ReporterConfig& config )
+        JunitReporter( ReporterConfig const& config )
         :   m_config( config ),
             m_testSuiteStats( "AllTests" ),
             m_currentStats( &m_testSuiteStats )
@@ -80,7 +85,10 @@ namespace Catch {
         virtual void StartTesting(){}
         
         virtual void StartGroup( const std::string& groupName ) {
-            m_statsForSuites.push_back( Stats( groupName ) );
+            if( groupName.empty() )
+                m_statsForSuites.push_back( Stats( m_config.fullConfig()->name() ) );
+            else
+                m_statsForSuites.push_back( Stats( groupName ) );
             m_currentStats = &m_statsForSuites.back();
         }
 
@@ -97,11 +105,12 @@ namespace Catch {
         virtual void EndSection( const std::string&, const Counts& ) {}
         
         virtual void StartTestCase( const Catch::TestCaseInfo& testInfo ) {
-            m_currentStats->m_testCaseStats.push_back( TestCaseStats( testInfo.getClassName(), testInfo.getName() ) );
+            m_currentStats->m_testCaseStats.push_back( TestCaseStats( testInfo.className, testInfo.name ) );
+            m_currentTestCaseStats.push_back( &m_currentStats->m_testCaseStats.back() );
         }
         
         virtual void Result( const Catch::AssertionResult& assertionResult ) {
-            if( assertionResult.getResultType() != ResultWas::Ok || m_config.includeSuccessfulResults ) {
+            if( assertionResult.getResultType() != ResultWas::Ok || m_config.fullConfig()->includeSuccessfulResults() ) {
                 TestCaseStats& testCaseStats = m_currentStats->m_testCaseStats.back();
                 TestStats stats;
                 std::ostringstream oss;
@@ -134,10 +143,14 @@ namespace Catch {
                     case ResultWas::Ok:
                         stats.m_element = "success";
                         break;
+                    case ResultWas::DidntThrowException:
+                        stats.m_element = "failure";
+                        m_currentStats->m_failuresCount++;
+                        break;
                     case ResultWas::Unknown:
                     case ResultWas::FailureBit:
                     case ResultWas::Exception:
-                    case ResultWas::DidntThrowException:
+                        stats.m_element = "* internal error *";
                         break;
                 }
                 testCaseStats.m_testStats.push_back( stats );                
@@ -145,6 +158,11 @@ namespace Catch {
         }
         
         virtual void EndTestCase( const Catch::TestCaseInfo&, const Totals&, const std::string& stdOut, const std::string& stdErr ) {
+            m_currentTestCaseStats.pop_back();
+            assert( m_currentTestCaseStats.empty() );
+            TestCaseStats& testCaseStats = m_currentStats->m_testCaseStats.back();
+            testCaseStats.m_stdOut = stdOut;
+            testCaseStats.m_stdErr = stdErr;
             if( !stdOut.empty() )
                 m_stdOut << stdOut << "\n";
             if( !stdErr.empty() )
@@ -156,40 +174,35 @@ namespace Catch {
         }
 
         virtual void EndTesting( const Totals& ) {
-            std::ostream& str = m_config.stream;
-            {
-                XmlWriter xml( str );
+            XmlWriter xml( m_config.stream() );
             
-                if( m_statsForSuites.size() > 0 )
-                    xml.startElement( "testsuites" );
+            if( m_statsForSuites.size() > 0 )
+                xml.startElement( "testsuites" );
                         
-                std::vector<Stats>::const_iterator it = m_statsForSuites.begin();
-                std::vector<Stats>::const_iterator itEnd = m_statsForSuites.end();
+            std::vector<Stats>::const_iterator it = m_statsForSuites.begin();
+            std::vector<Stats>::const_iterator itEnd = m_statsForSuites.end();
             
-                for(; it != itEnd; ++it ) {
-                    XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
-                    xml.writeAttribute( "name", it->m_name );
-                    xml.writeAttribute( "errors", it->m_errorsCount );
-                    xml.writeAttribute( "failures", it->m_failuresCount );
-                    xml.writeAttribute( "tests", it->m_testsCount );
-                    xml.writeAttribute( "hostname", "tbd" );
-                    xml.writeAttribute( "time", "tbd" );
-                    xml.writeAttribute( "timestamp", "tbd" );
+            for(; it != itEnd; ++it ) {
+                XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
+                xml.writeAttribute( "name", it->m_name );
+                xml.writeAttribute( "errors", it->m_errorsCount );
+                xml.writeAttribute( "failures", it->m_failuresCount );
+                xml.writeAttribute( "tests", it->m_testsCount );
+                xml.writeAttribute( "hostname", "tbd" );
+                xml.writeAttribute( "time", "tbd" );
+                xml.writeAttribute( "timestamp", "tbd" );
                 
-                    OutputTestCases( xml, *it );
-                }
-      
-                xml.scopedElement( "system-out" ).writeText( trim( m_stdOut.str() ) );                
-                xml.scopedElement( "system-err" ).writeText( trim( m_stdErr.str() ) );
+                OutputTestCases( xml, *it );
             }
+  
+            xml.scopedElement( "system-out" ).writeText( trim( m_stdOut.str() ), false );
+            xml.scopedElement( "system-err" ).writeText( trim( m_stdErr.str() ), false );
         }
         
         void OutputTestCases( XmlWriter& xml, const Stats& stats ) {
             std::vector<TestCaseStats>::const_iterator it = stats.m_testCaseStats.begin();
             std::vector<TestCaseStats>::const_iterator itEnd = stats.m_testCaseStats.end();
             for(; it != itEnd; ++it ) {
-                xml.writeBlankLine();
-                xml.writeComment( "Test case" );
                 
                 XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
                 xml.writeAttribute( "classname", it->m_className );
@@ -197,6 +210,13 @@ namespace Catch {
                 xml.writeAttribute( "time", "tbd" );
 
                 OutputTestResult( xml, *it );
+
+                std::string stdOut = trim( it->m_stdOut );
+                if( !stdOut.empty() )
+                    xml.scopedElement( "system-out" ).writeText( stdOut, false );
+                std::string stdErr = trim( it->m_stdErr );
+                if( !stdErr.empty() )
+                    xml.scopedElement( "system-err" ).writeText( stdErr, false );
             }
         }
 
@@ -218,11 +238,11 @@ namespace Catch {
         
     private:
         ReporterConfig m_config;
-        bool m_currentTestSuccess;
         
         Stats m_testSuiteStats;
         Stats* m_currentStats;
         std::vector<Stats> m_statsForSuites;
+        std::vector<const TestCaseStats*> m_currentTestCaseStats;
         std::ostringstream m_stdOut;
         std::ostringstream m_stdErr;
     };

include/reporters/catch_reporter_xml.hpp

@@ -16,7 +16,7 @@
 namespace Catch {
     class XmlReporter : public SharedImpl<IReporter> {
     public:
-        XmlReporter( const ReporterConfig& config ) : m_config( config ) {}
+        XmlReporter( ReporterConfig const& config ) : m_config( config ) {}
 
         static std::string getDescription() {
             return "Reports test results as an XML document";
@@ -30,10 +30,10 @@ namespace Catch {
         }        
 
         virtual void StartTesting() {
-            m_xml = XmlWriter( m_config.stream );
+            m_xml = XmlWriter( m_config.stream() );
             m_xml.startElement( "Catch" );
-            if( !m_config.name.empty() )
-                m_xml.writeAttribute( "name", m_config.name );
+            if( !m_config.fullConfig()->name().empty() )
+                m_xml.writeAttribute( "name", m_config.fullConfig()->name() );
         }
         
         virtual void EndTesting( const Totals& totals ) {
@@ -71,12 +71,12 @@ namespace Catch {
         }
         
         virtual void StartTestCase( const Catch::TestCaseInfo& testInfo ) {
-            m_xml.startElement( "TestCase" ).writeAttribute( "name", testInfo.getName() );
+            m_xml.startElement( "TestCase" ).writeAttribute( "name", testInfo.name );
             m_currentTestSuccess = true;
         }
         
         virtual void Result( const Catch::AssertionResult& assertionResult ) {
-            if( !m_config.includeSuccessfulResults && assertionResult.getResultType() == ResultWas::Ok )
+            if( !m_config.fullConfig()->includeSuccessfulResults() && assertionResult.getResultType() == ResultWas::Ok )
                 return;
 
             if( assertionResult.hasExpression() ) {

projects/SelfTest/ApproxTests.cpp

@@ -101,3 +101,12 @@ TEST_CASE
     REQUIRE( approx( d ) != 1.25 );
 }
 
+inline double divide( double a, double b ) {
+    return a/b;
+}
+
+TEST_CASE( "Approximate PI", "[Approx][PI]" )
+{
+    REQUIRE( divide( 22, 7 ) == Approx( 3.141 ).epsilon( 0.001 ) );
+    REQUIRE( divide( 22, 7 ) != Approx( 3.141 ).epsilon( 0.0001 ) );
+}

projects/SelfTest/BDDTests.cpp

@@ -0,0 +1,68 @@
+/*
+ *  Created by Phil on 29/11/2010.
+ *  Copyright 2010 Two Blue Cubes Ltd. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#include "catch.hpp"
+
+inline bool itDoesThis(){ return true; }
+inline bool itDoesThat(){ return true; }
+
+SCENARIO( "Do that thing with the thing", "[Tags]" ) {
+    GIVEN( "This stuff exists" ) {
+        // make stuff exist
+        WHEN( "I do this" ) {
+            // do this
+            THEN( "it should do this")
+            {
+                REQUIRE( itDoesThis() );
+                AND_THEN( "do that")
+                    REQUIRE( itDoesThat() );
+            }
+        }
+    }
+}
+
+SCENARIO( "Vector resizing affects size and capacity", "[vector][bdd][size][capacity]" ) {
+    GIVEN( "an empty vector" ) {
+        std::vector<int> v;
+        REQUIRE( v.size() == 0 );
+        
+        WHEN( "it is made larger" ) {
+            v.resize( 10 );
+            THEN( "the size and capacity go up" ) {
+                REQUIRE( v.size() == 10 );
+                REQUIRE( v.capacity() >= 10 );
+                
+                AND_WHEN( "it is made smaller again" ) {
+                    v.resize( 5 );
+                    THEN( "the size goes down but the capacity stays the same" ) {
+                        REQUIRE( v.size() == 5 );
+                        REQUIRE( v.capacity() >= 10 );
+                    }
+                }
+            }
+        }
+        
+        WHEN( "we reserve more space" ) {
+            v.reserve( 10 );
+            THEN( "The capacity is increased but the size remains the same" ) {
+                REQUIRE( v.capacity() >= 10 );
+                REQUIRE( v.size() == 0 );
+            }
+        }
+    }
+}
+
+SCENARIO(   "This is a really long scenario name to see how the list command deals with wrapping",
+            "[very long tags][lots][long][tags][verbose]"
+            "[one very long tag name that should cause line wrapping writing out using the list command]"
+            "[anotherReallyLongTagNameButThisOneHasNoObviousWrapPointsSoShouldSplitWithinAWordUsingADashCharacter]" ) {
+    GIVEN( "A section name that is so long that it cannot fit in a single console width" )
+        WHEN( "The test headers are printed as part of the normal running of the scenario" )
+            THEN( "The, deliberately very long and overly verbose (you see what I did there?) section names must wrap, along with an indent" )
+                SUCCEED("boo!");
+}

projects/SelfTest/Baselines/failingResults.txt

@@ -1,169 +0,0 @@
-[Started testing]
-[Started group: './failing*']
-
-[Running: ./failing/TestClass/failingCase]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ClassTests.cpp:28: s == "world" failed for: "hello" == "world"
-[Finished: './failing/TestClass/failingCase' 1 test case failed (1 assertion failed)]
-
-[Running: ./failing/Fixture/failingCase]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ClassTests.cpp:55: m_a == 2 failed for: 1 == 2
-[Finished: './failing/Fixture/failingCase' 1 test case failed (1 assertion failed)]
-
-[Running: ./failing/conditions/equality]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:71: data.int_seven == 6 failed for: 7 == 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:72: data.int_seven == 8 failed for: 7 == 8
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:73: data.int_seven == 0 failed for: 7 == 0
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:74: data.float_nine_point_one == Approx( 9.11f ) failed for: 9.1 == Approx( 9.11 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:75: data.float_nine_point_one == Approx( 9.0f ) failed for: 9.1 == Approx( 9 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:76: data.float_nine_point_one == Approx( 1 ) failed for: 9.1 == Approx( 1 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:77: data.float_nine_point_one == Approx( 0 ) failed for: 9.1 == Approx( 0 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:78: data.double_pi == Approx( 3.1415 ) failed for: 3.14159 == Approx( 3.1415 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:79: data.str_hello == "goodbye" failed for: "hello" == "goodbye"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:80: data.str_hello == "hell" failed for: "hello" == "hell"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:81: data.str_hello == "hello1" failed for: "hello" == "hello1"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:82: data.str_hello.size() == 6 failed for: 5 == 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:85: x == Approx( 1.301 ) failed for: 1.3 == Approx( 1.301 )
-[Finished: './failing/conditions/equality' 1 test case failed (All 13 assertions failed)]
-
-[Running: ./failing/conditions/inequality]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:111: data.int_seven != 7 failed for: 7 != 7
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:112: data.float_nine_point_one != Approx( 9.1f ) failed for: 9.1 != Approx( 9.1 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:113: data.double_pi != Approx( 3.1415926535 ) failed for: 3.14159 != Approx( 3.14159 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:114: data.str_hello != "hello" failed for: "hello" != "hello"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:115: data.str_hello.size() != 5 failed for: 5 != 5
-[Finished: './failing/conditions/inequality' 1 test case failed (All 5 assertions failed)]
-
-[Running: ./failing/conditions/ordered]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:152: data.int_seven > 7 failed for: 7 > 7
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:153: data.int_seven < 7 failed for: 7 < 7
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:154: data.int_seven > 8 failed for: 7 > 8
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:155: data.int_seven < 6 failed for: 7 < 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:156: data.int_seven < 0 failed for: 7 < 0
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:157: data.int_seven < -1 failed for: 7 < -1
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:159: data.int_seven >= 8 failed for: 7 >= 8
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:160: data.int_seven <= 6 failed for: 7 <= 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:162: data.float_nine_point_one < 9 failed for: 9.1 < 9
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:163: data.float_nine_point_one > 10 failed for: 9.1 > 10
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:164: data.float_nine_point_one > 9.2 failed for: 9.1 > 9.2
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:166: data.str_hello > "hello" failed for: "hello" > "hello"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:167: data.str_hello < "hello" failed for: "hello" < "hello"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:168: data.str_hello > "hellp" failed for: "hello" > "hellp"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:169: data.str_hello > "z" failed for: "hello" > "z"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:170: data.str_hello < "hellm" failed for: "hello" < "hellm"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:171: data.str_hello < "a" failed for: "hello" < "a"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:173: data.str_hello >= "z" failed for: "hello" >= "z"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:174: data.str_hello <= "a" failed for: "hello" <= "a"
-[Finished: './failing/conditions/ordered' 1 test case failed (All 19 assertions failed)]
-
-[Running: ./failing/conditions/not]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:320: false != false failed
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:321: true != true failed
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:322: !true failed for: false
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:323: !true failed
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:325: !trueValue failed for: false
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:326: !trueValue failed for: !true
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:328: !(1 == 1) failed for: false
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:329: !1 == 1 failed for: !(1 == 1)
-[Finished: './failing/conditions/not' 1 test case failed (All 8 assertions failed)]
-
-[Running: ./failing/exceptions/explicit]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:47: thisThrows() failed with unexpected exception with message: 'expected exception'
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:48: thisDoesntThrow() failed because no exception was thrown where one was expected
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:49: thisThrows() failed with unexpected exception with message: 'expected exception'
-[Finished: './failing/exceptions/explicit' 1 test case failed (All 3 assertions failed)]
-
-[Running: ./failing/exceptions/implicit]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:52: Unexpected exception with message: 'unexpected exception'
-[Finished: './failing/exceptions/implicit' 1 test case failed (1 assertion failed)]
-
-[Running: ./failing/exceptions/custom]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:95: Unexpected exception with message: 'custom exception'
-[Finished: './failing/exceptions/custom' 1 test case failed (1 assertion failed)]
-
-[Running: ./failing/exceptions/custom/nothrow]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:102: throw CustomException( "unexpected custom exception" ) failed with unexpected exception with message: 'unexpected custom exception'
-[Finished: './failing/exceptions/custom/nothrow' 1 test case failed (1 assertion failed)]
-
-[Running: ./failing/exceptions/custom/throw]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:107: throw CustomException( "custom exception - not std" ) failed with unexpected exception with message: 'custom exception - not std'
-[Finished: './failing/exceptions/custom/throw' 1 test case failed (1 assertion failed)]
-
-[Running: ./failing/exceptions/custom/double]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:111: Unexpected exception with message: '3.14'
-[Finished: './failing/exceptions/custom/double' 1 test case failed (1 assertion failed)]
-
-[Running: ./failing/exceptions/in-section]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:125: Unexpected exception with message: 'Exception from section'
-[Finished: './failing/exceptions/in-section' 1 test case failed (1 assertion failed)]
-
-[Running: ./failing/message/info/1]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MessageTests.cpp:19: [info: this message should be logged]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MessageTests.cpp:20: [info: so should this]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MessageTests.cpp:22: a == 1 failed for: 2 == 1
-[Finished: './failing/message/info/1' 1 test case failed (1 assertion failed)]
-
-[Running: ./failing/message/fail]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MessageTests.cpp:46: failed with message: 'This is a failure'
-[Finished: './failing/message/fail' 1 test case failed (1 assertion failed)]
-
-[Running: ./failing/message/sections]
-
-[Started section: 'one']
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MessageTests.cpp:53: failed with message: 'Message from section one'
-[End of section: 'one' 1 assertion failed]
-
-[Started section: 'two']
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MessageTests.cpp:58: failed with message: 'Message from section two'
-[End of section: 'two' 1 assertion failed]
-
-[Finished: './failing/message/sections' 1 test case failed (All 2 assertions failed)]
-
-[Running: ./failing/info]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:169: [info: hi]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:171: [info: i := 7]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:172: false failed
-[Finished: './failing/info' 1 test case failed (1 assertion failed)]
-
-[Running: ./failing/checkedif]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:177: flag failed for: false
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:190: testCheckedIf( false ) failed for: false
-[Finished: './failing/checkedif' 1 test case failed (All 2 assertions failed)]
-
-[Running: ./failing/checkedelse]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:195: flag failed for: false
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:208: testCheckedElse( false ) failed for: false
-[Finished: './failing/checkedelse' 1 test case failed (All 2 assertions failed)]
-
-[Running: ./failing/matchers/Contains]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:255: testStringForMatching() Contains( "not there" ) failed for: 
-	"this string contains 'abc' as a substring" contains: "not there"
-[Finished: './failing/matchers/Contains' 1 test case failed (1 assertion failed)]
-
-[Running: ./failing/matchers/StartsWith]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:260: testStringForMatching() StartsWith( "string" ) failed for: 
-	"this string contains 'abc' as a substring" starts with: "string"
-[Finished: './failing/matchers/StartsWith' 1 test case failed (1 assertion failed)]
-
-[Running: ./failing/matchers/EndsWith]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:265: testStringForMatching() EndsWith( "this" ) failed for: 
-	"this string contains 'abc' as a substring" ends with: "this"
-[Finished: './failing/matchers/EndsWith' 1 test case failed (1 assertion failed)]
-
-[Running: ./failing/matchers/Equals]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:270: testStringForMatching() Equals( "something else" ) failed for: 
-	"this string contains 'abc' as a substring" equals: "something else"
-[Finished: './failing/matchers/Equals' 1 test case failed (1 assertion failed)]
-
-[Running: ./failing/Tricky/non streamable type]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:95: &o1 == &o2 failed for: 0x7fff522b88b8 == 0x7fff522b88b0
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:96: o1 == o2 failed for: {?} == {?}
-[Finished: './failing/Tricky/non streamable type' 1 test case failed (All 2 assertions failed)]
-
-[Running: ./failing/string literals]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:106: std::string( "first" ) == "second" failed for: "first" == "second"
-[Finished: './failing/string literals' 1 test case failed (1 assertion failed)]
-[End of group: './failing*'. All 25 test cases failed (All 72 assertions failed)]
-
-
-[Testing completed. All 25 test cases failed (All 72 assertions failed)]
-

projects/SelfTest/Baselines/results.txt

@@ -1,646 +0,0 @@
-[Started testing]
-[Started group: './failing* ./succeeding*']
-
-[Running: ./succeeding/Approx/simple]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:20: d == Approx( 1.23 ) succeeded for: 1.23 == Approx( 1.23 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:21: d != Approx( 1.22 ) succeeded for: 1.23 != Approx( 1.22 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:22: d != Approx( 1.24 ) succeeded for: 1.23 != Approx( 1.24 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:24: Approx( d ) == 1.23 succeeded for: Approx( 1.23 ) == 1.23
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:25: Approx( d ) != 1.22 succeeded for: Approx( 1.23 ) != 1.22
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:26: Approx( d ) != 1.24 succeeded for: Approx( 1.23 ) != 1.24
-[Finished: './succeeding/Approx/simple' All tests passed (6 assertions in 1 test case)]
-
-[Running: ./succeeding/Approx/epsilon]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:38: d != Approx( 1.231 ) succeeded for: 1.23 != Approx( 1.231 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:39: d == Approx( 1.231 ).epsilon( 0.1 ) succeeded for: 1.23 == Approx( 1.231 )
-[Finished: './succeeding/Approx/epsilon' All tests passed (2 assertions in 1 test case)]
-
-[Running: ./succeeding/Approx/float]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:49: 1.23f == Approx( 1.23f ) succeeded for: 1.23 == Approx( 1.23 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:50: 0.0f == Approx( 0.0f ) succeeded for: 0 == Approx( 0 )
-[Finished: './succeeding/Approx/float' All tests passed (2 assertions in 1 test case)]
-
-[Running: ./succeeding/Approx/int]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:60: 1 == Approx( 1 ) succeeded
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:61: 0 == Approx( 0 ) succeeded
-[Finished: './succeeding/Approx/int' All tests passed (2 assertions in 1 test case)]
-
-[Running: ./succeeding/Approx/mixed]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:75: 1.0f == Approx( 1 ) succeeded for: 1 == Approx( 1 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:76: 0 == Approx( dZero) succeeded for: 0 == Approx( 0 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:77: 0 == Approx( dSmall ).epsilon( 0.001 ) succeeded for: 0 == Approx( 1e-05 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:78: 1.234f == Approx( dMedium ) succeeded for: 1.234 == Approx( 1.234 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:79: dMedium == Approx( 1.234f ) succeeded for: 1.234 == Approx( 1.234 )
-[Finished: './succeeding/Approx/mixed' All tests passed (5 assertions in 1 test case)]
-
-[Running: ./succeeding/Approx/custom]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:93: d == approx( 1.23 ) succeeded for: 1.23 == Approx( 1.23 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:94: d == approx( 1.22 ) succeeded for: 1.23 == Approx( 1.22 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:95: d == approx( 1.24 ) succeeded for: 1.23 == Approx( 1.24 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:96: d != approx( 1.25 ) succeeded for: 1.23 != Approx( 1.25 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:98: approx( d ) == 1.23 succeeded for: Approx( 1.23 ) == 1.23
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:99: approx( d ) == 1.22 succeeded for: Approx( 1.23 ) == 1.22
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:100: approx( d ) == 1.24 succeeded for: Approx( 1.23 ) == 1.24
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:101: approx( d ) != 1.25 succeeded for: Approx( 1.23 ) != 1.25
-[Finished: './succeeding/Approx/custom' All tests passed (8 assertions in 1 test case)]
-
-[Running: ./succeeding/TestClass/succeedingCase]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ClassTests.cpp:24: s == "hello" succeeded for: "hello" == "hello"
-[Finished: './succeeding/TestClass/succeedingCase' All tests passed (1 assertion in 1 test case)]
-
-[Running: ./failing/TestClass/failingCase]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ClassTests.cpp:28: s == "world" failed for: "hello" == "world"
-[Finished: './failing/TestClass/failingCase' 1 test case failed (1 assertion failed)]
-
-[Running: ./succeeding/Fixture/succeedingCase]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ClassTests.cpp:47: m_a == 1 succeeded for: 1 == 1
-[Finished: './succeeding/Fixture/succeedingCase' All tests passed (1 assertion in 1 test case)]
-
-[Running: ./failing/Fixture/failingCase]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ClassTests.cpp:55: m_a == 2 failed for: 1 == 2
-[Finished: './failing/Fixture/failingCase' 1 test case failed (1 assertion failed)]
-
-[Running: ./succeeding/conditions/equality]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:55: data.int_seven == 7 succeeded for: 7 == 7
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:56: data.float_nine_point_one == Approx( 9.1f ) succeeded for: 9.1 == Approx( 9.1 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:57: data.double_pi == Approx( 3.1415926535 ) succeeded for: 3.14159 == Approx( 3.14159 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:58: data.str_hello == "hello" succeeded for: "hello" == "hello"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:59: "hello" == data.str_hello succeeded for: "hello" == "hello"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:60: data.str_hello.size() == 5 succeeded for: 5 == 5
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:63: x == Approx( 1.3 ) succeeded for: 1.3 == Approx( 1.3 )
-[Finished: './succeeding/conditions/equality' All tests passed (7 assertions in 1 test case)]
-
-[Running: ./failing/conditions/equality]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:71: data.int_seven == 6 failed for: 7 == 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:72: data.int_seven == 8 failed for: 7 == 8
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:73: data.int_seven == 0 failed for: 7 == 0
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:74: data.float_nine_point_one == Approx( 9.11f ) failed for: 9.1 == Approx( 9.11 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:75: data.float_nine_point_one == Approx( 9.0f ) failed for: 9.1 == Approx( 9 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:76: data.float_nine_point_one == Approx( 1 ) failed for: 9.1 == Approx( 1 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:77: data.float_nine_point_one == Approx( 0 ) failed for: 9.1 == Approx( 0 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:78: data.double_pi == Approx( 3.1415 ) failed for: 3.14159 == Approx( 3.1415 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:79: data.str_hello == "goodbye" failed for: "hello" == "goodbye"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:80: data.str_hello == "hell" failed for: "hello" == "hell"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:81: data.str_hello == "hello1" failed for: "hello" == "hello1"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:82: data.str_hello.size() == 6 failed for: 5 == 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:85: x == Approx( 1.301 ) failed for: 1.3 == Approx( 1.301 )
-[Finished: './failing/conditions/equality' 1 test case failed (All 13 assertions failed)]
-
-[Running: ./succeeding/conditions/inequality]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:93: data.int_seven != 6 succeeded for: 7 != 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:94: data.int_seven != 8 succeeded for: 7 != 8
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:95: data.float_nine_point_one != Approx( 9.11f ) succeeded for: 9.1 != Approx( 9.11 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:96: data.float_nine_point_one != Approx( 9.0f ) succeeded for: 9.1 != Approx( 9 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:97: data.float_nine_point_one != Approx( 1 ) succeeded for: 9.1 != Approx( 1 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:98: data.float_nine_point_one != Approx( 0 ) succeeded for: 9.1 != Approx( 0 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:99: data.double_pi != Approx( 3.1415 ) succeeded for: 3.14159 != Approx( 3.1415 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:100: data.str_hello != "goodbye" succeeded for: "hello" != "goodbye"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:101: data.str_hello != "hell" succeeded for: "hello" != "hell"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:102: data.str_hello != "hello1" succeeded for: "hello" != "hello1"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:103: data.str_hello.size() != 6 succeeded for: 5 != 6
-[Finished: './succeeding/conditions/inequality' All tests passed (11 assertions in 1 test case)]
-
-[Running: ./failing/conditions/inequality]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:111: data.int_seven != 7 failed for: 7 != 7
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:112: data.float_nine_point_one != Approx( 9.1f ) failed for: 9.1 != Approx( 9.1 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:113: data.double_pi != Approx( 3.1415926535 ) failed for: 3.14159 != Approx( 3.14159 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:114: data.str_hello != "hello" failed for: "hello" != "hello"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:115: data.str_hello.size() != 5 failed for: 5 != 5
-[Finished: './failing/conditions/inequality' 1 test case failed (All 5 assertions failed)]
-
-[Running: ./succeeding/conditions/ordered]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:124: data.int_seven < 8 succeeded for: 7 < 8
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:125: data.int_seven > 6 succeeded for: 7 > 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:126: data.int_seven > 0 succeeded for: 7 > 0
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:127: data.int_seven > -1 succeeded for: 7 > -1
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:129: data.int_seven >= 7 succeeded for: 7 >= 7
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:130: data.int_seven >= 6 succeeded for: 7 >= 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:131: data.int_seven <= 7 succeeded for: 7 <= 7
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:132: data.int_seven <= 8 succeeded for: 7 <= 8
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:134: data.float_nine_point_one > 9 succeeded for: 9.1 > 9
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:135: data.float_nine_point_one < 10 succeeded for: 9.1 < 10
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:136: data.float_nine_point_one < 9.2 succeeded for: 9.1 < 9.2
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:138: data.str_hello <= "hello" succeeded for: "hello" <= "hello"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:139: data.str_hello >= "hello" succeeded for: "hello" >= "hello"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:141: data.str_hello < "hellp" succeeded for: "hello" < "hellp"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:142: data.str_hello < "zebra" succeeded for: "hello" < "zebra"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:143: data.str_hello > "hellm" succeeded for: "hello" > "hellm"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:144: data.str_hello > "a" succeeded for: "hello" > "a"
-[Finished: './succeeding/conditions/ordered' All tests passed (17 assertions in 1 test case)]
-
-[Running: ./failing/conditions/ordered]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:152: data.int_seven > 7 failed for: 7 > 7
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:153: data.int_seven < 7 failed for: 7 < 7
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:154: data.int_seven > 8 failed for: 7 > 8
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:155: data.int_seven < 6 failed for: 7 < 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:156: data.int_seven < 0 failed for: 7 < 0
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:157: data.int_seven < -1 failed for: 7 < -1
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:159: data.int_seven >= 8 failed for: 7 >= 8
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:160: data.int_seven <= 6 failed for: 7 <= 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:162: data.float_nine_point_one < 9 failed for: 9.1 < 9
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:163: data.float_nine_point_one > 10 failed for: 9.1 > 10
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:164: data.float_nine_point_one > 9.2 failed for: 9.1 > 9.2
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:166: data.str_hello > "hello" failed for: "hello" > "hello"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:167: data.str_hello < "hello" failed for: "hello" < "hello"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:168: data.str_hello > "hellp" failed for: "hello" > "hellp"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:169: data.str_hello > "z" failed for: "hello" > "z"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:170: data.str_hello < "hellm" failed for: "hello" < "hellm"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:171: data.str_hello < "a" failed for: "hello" < "a"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:173: data.str_hello >= "z" failed for: "hello" >= "z"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:174: data.str_hello <= "a" failed for: "hello" <= "a"
-[Finished: './failing/conditions/ordered' 1 test case failed (All 19 assertions failed)]
-
-[Running: ./succeeding/conditions/int literals]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:188: i == 1 succeeded for: 1 == 1
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:189: ui == 2 succeeded for: 2 == 2
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:190: l == 3 succeeded for: 3 == 3
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:191: ul == 4 succeeded for: 4 == 4
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:192: c == 5 succeeded for: 5 == 5
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:193: uc == 6 succeeded for:  == 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:195: 1 == i succeeded for: 1 == 1
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:196: 2 == ui succeeded for: 2 == 2
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:197: 3 == l succeeded for: 3 == 3
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:198: 4 == ul succeeded for: 4 == 4
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:199: 5 == c succeeded for: 5 == 5
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:200: 6 == uc succeeded for: 6 == 
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:202: (std::numeric_limits<unsigned long>::max)() > ul succeeded for: 0xffffffffffffffff > 4
-[Finished: './succeeding/conditions/int literals' All tests passed (13 assertions in 1 test case)]
-
-[Running: ./succeeding/conditions//long_to_unsigned_x]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:223: long_var == unsigned_char_var succeeded for: 1 == 

-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:224: long_var == unsigned_short_var succeeded for: 1 == 1
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:225: long_var == unsigned_int_var succeeded for: 1 == 1
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:226: long_var == unsigned_long_var succeeded for: 1 == 1
-[Finished: './succeeding/conditions//long_to_unsigned_x' All tests passed (4 assertions in 1 test case)]
-
-[Running: ./succeeding/conditions/negative ints]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:232: ( -1 > 2u ) succeeded for: true
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:233: -1 > 2u succeeded for: -1 > 2
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:235: ( 2u < -1 ) succeeded for: true
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:236: 2u < -1 succeeded for: 2 < -1
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:239: ( minInt > 2u ) succeeded for: true
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:240: minInt > 2u succeeded for: -2147483648 > 2
-[Finished: './succeeding/conditions/negative ints' All tests passed (6 assertions in 1 test case)]
-
-[Running: ./succeeding/conditions/computed ints]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:255: 54 == 6*9 succeeded for: 54 == 54
-[Finished: './succeeding/conditions/computed ints' All tests passed (1 assertion in 1 test case)]
-
-[Running: ./succeeding/conditions/ptr]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:271: p == __null succeeded for: __null == 0
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:272: p == pNULL succeeded for: __null == __null
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:277: p != __null succeeded for: 0x7fff54208078 != 0
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:280: cp != __null succeeded for: 0x7fff54208078 != 0
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:283: cpc != __null succeeded for: 0x7fff54208078 != 0
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:285: returnsNull() == __null succeeded for: {null string} == 0
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:286: returnsConstNull() == __null succeeded for: {null string} == 0
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:288: __null != p succeeded for: 0 != 0x7fff54208078
-[Finished: './succeeding/conditions/ptr' All tests passed (8 assertions in 1 test case)]
-
-[Running: ./succeeding/conditions/not]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:303: false == false succeeded
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:304: true == true succeeded
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:305: !false succeeded for: true
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:306: !false succeeded
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:308: !falseValue succeeded for: true
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:309: !falseValue succeeded for: !false
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:311: !(1 == 2) succeeded for: true
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:312: !1 == 2 succeeded for: !(1 == 2)
-[Finished: './succeeding/conditions/not' All tests passed (8 assertions in 1 test case)]
-
-[Running: ./failing/conditions/not]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:320: false != false failed
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:321: true != true failed
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:322: !true failed for: false
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:323: !true failed
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:325: !trueValue failed for: false
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:326: !trueValue failed for: !true
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:328: !(1 == 1) failed for: false
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:329: !1 == 1 failed for: !(1 == 1)
-[Finished: './failing/conditions/not' 1 test case failed (All 8 assertions failed)]
-
-[Running: ./succeeding/exceptions/explicit]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:39: thisThrows() succeeded
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:40: thisDoesntThrow() succeeded
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:41: thisThrows() succeeded
-[Finished: './succeeding/exceptions/explicit' All tests passed (3 assertions in 1 test case)]
-
-[Running: ./failing/exceptions/explicit]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:47: thisThrows() failed with unexpected exception with message: 'expected exception'
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:48: thisDoesntThrow() failed because no exception was thrown where one was expected
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:49: thisThrows() failed with unexpected exception with message: 'expected exception'
-[Finished: './failing/exceptions/explicit' 1 test case failed (All 3 assertions failed)]
-
-[Running: ./failing/exceptions/implicit]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:52: Unexpected exception with message: 'unexpected exception'
-[Finished: './failing/exceptions/implicit' 1 test case failed (1 assertion failed)]
-
-[Running: ./failing/exceptions/custom]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:95: Unexpected exception with message: 'custom exception'
-[Finished: './failing/exceptions/custom' 1 test case failed (1 assertion failed)]
-
-[Running: ./failing/exceptions/custom/nothrow]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:102: throw CustomException( "unexpected custom exception" ) failed with unexpected exception with message: 'unexpected custom exception'
-[Finished: './failing/exceptions/custom/nothrow' 1 test case failed (1 assertion failed)]
-
-[Running: ./failing/exceptions/custom/throw]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:107: throw CustomException( "custom exception - not std" ) failed with unexpected exception with message: 'custom exception - not std'
-[Finished: './failing/exceptions/custom/throw' 1 test case failed (1 assertion failed)]
-
-[Running: ./failing/exceptions/custom/double]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:111: Unexpected exception with message: '3.14'
-[Finished: './failing/exceptions/custom/double' 1 test case failed (1 assertion failed)]
-
-[Running: ./failing/exceptions/in-section]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:125: Unexpected exception with message: 'Exception from section'
-[Finished: './failing/exceptions/in-section' 1 test case failed (1 assertion failed)]
-
-[Running: ./succeeding/exceptions/error messages]
-
-[Started section: 'custom, unexpected']
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:145: runner.getLog() Contains( "custom exception" ) succeeded for: 
-"\[g] ./failing/exceptions/custom
- \[tc] ./failing/exceptions/custom
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:95:  ThrewException'custom exception' /[tc] ./failing/exceptions/custom
-/[g] ./failing/exceptions/custom
-" contains: "custom exception"
-[End of section: 'custom, unexpected' 1 assertion passed]
-
-[Started section: 'in section']
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:153: runner.getLog() Contains( "Exception from section" ) succeeded for: 
-"\[g] ./failing/exceptions/in-section
- \[tc] ./failing/exceptions/in-section
-  \ [s] the section
-   \ [s] the section2
-   / [s] the section2
-  / [s] the section
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:125:  ThrewException'Exception from section'  \ [s] the section
-  / [s] the section
- /[tc] ./failing/exceptions/in-section
-/[g] ./failing/exceptions/in-section
-" contains: "Exception from section"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:154: runner.getLog() Contains( ::Catch::LineInfoRegistry::get().infoForName( "the section2" ) ) succeeded for: 
-"\[g] ./failing/exceptions/in-section
- \[tc] ./failing/exceptions/in-section
-  \ [s] the section
-   \ [s] the section2
-   / [s] the section2
-  / [s] the section
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:125:  ThrewException'Exception from section'  \ [s] the section
-  / [s] the section
- /[tc] ./failing/exceptions/in-section
-/[g] ./failing/exceptions/in-section
-" contains: "/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:125: "
-[End of section: 'in section' All 2 assertions passed]
-
-[Finished: './succeeding/exceptions/error messages' All tests passed (3 assertions in 1 test case)]
-
-[Running: ./succeeding/exceptions/notimplemented]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:165: thisFunctionNotImplemented( 7 ) succeeded
-[Finished: './succeeding/exceptions/notimplemented' All tests passed (1 assertion in 1 test case)]
-
-[Running: ./succeeding/generators/1]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 2 == 2
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 200 == 200
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 4 == 4
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 200 == 200
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 6 == 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 200 == 200
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 8 == 8
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 200 == 200
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 10 == 10
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 200 == 200
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 30 == 30
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 200 == 200
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 40 == 40
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 200 == 200
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 42 == 42
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 200 == 200
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 72 == 72
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 200 == 200
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 2 == 2
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 202 == 202
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 4 == 4
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 202 == 202
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 6 == 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 202 == 202
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 8 == 8
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 202 == 202
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 10 == 10
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 202 == 202
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 30 == 30
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 202 == 202
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 40 == 40
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 202 == 202
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 42 == 42
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 202 == 202
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 72 == 72
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 202 == 202
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 2 == 2
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 204 == 204
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 4 == 4
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 204 == 204
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 6 == 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 204 == 204
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 8 == 8
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 204 == 204
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 10 == 10
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 204 == 204
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 30 == 30
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 204 == 204
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 40 == 40
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 204 == 204
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 42 == 42
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 204 == 204
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 72 == 72
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 204 == 204
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 2 == 2
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 206 == 206
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 4 == 4
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 206 == 206
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 6 == 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 206 == 206
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 8 == 8
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 206 == 206
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 10 == 10
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 206 == 206
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 30 == 30
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 206 == 206
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 40 == 40
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 206 == 206
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 42 == 42
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 206 == 206
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 72 == 72
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 206 == 206
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 2 == 2
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 208 == 208
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 4 == 4
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 208 == 208
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 6 == 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 208 == 208
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 8 == 8
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 208 == 208
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 10 == 10
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 208 == 208
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 30 == 30
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 208 == 208
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 40 == 40
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 208 == 208
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 42 == 42
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 208 == 208
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 72 == 72
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 208 == 208
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 2 == 2
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 210 == 210
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 4 == 4
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 210 == 210
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 6 == 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 210 == 210
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 8 == 8
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 210 == 210
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 10 == 10
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 210 == 210
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 30 == 30
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 210 == 210
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 40 == 40
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 210 == 210
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 42 == 42
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 210 == 210
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 72 == 72
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 210 == 210
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 2 == 2
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 212 == 212
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 4 == 4
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 212 == 212
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 6 == 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 212 == 212
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 8 == 8
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 212 == 212
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 10 == 10
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 212 == 212
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 30 == 30
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 212 == 212
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 40 == 40
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 212 == 212
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 42 == 42
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 212 == 212
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 72 == 72
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 212 == 212
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 2 == 2
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 214 == 214
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 4 == 4
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 214 == 214
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 6 == 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 214 == 214
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 8 == 8
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 214 == 214
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 10 == 10
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 214 == 214
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 30 == 30
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 214 == 214
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 40 == 40
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 214 == 214
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 42 == 42
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 214 == 214
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 72 == 72
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 214 == 214
-[Finished: './succeeding/generators/1' All tests passed (144 assertions in 1 test case)]
-
-[Running: ./succeeding/message]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MessageTests.cpp:14: [warning: this is a warning]
-[Finished: './succeeding/message' No tests ran]
-
-[Running: ./failing/message/info/1]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MessageTests.cpp:19: [info: this message should be logged]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MessageTests.cpp:20: [info: so should this]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MessageTests.cpp:22: a == 1 failed for: 2 == 1
-[Finished: './failing/message/info/1' 1 test case failed (1 assertion failed)]
-
-[Running: ./failing/message/fail]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MessageTests.cpp:47: failed with message: 'This is a failure'
-[Finished: './failing/message/fail' 1 test case failed (1 assertion failed)]
-
-[Running: ./failing/message/sections]
-[Started section: 'one']
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MessageTests.cpp:54: failed with message: 'Message from section one'
-[End of section: 'one' 1 assertion failed]
-
-[Started section: 'two']
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MessageTests.cpp:59: failed with message: 'Message from section two'
-[End of section: 'two' 1 assertion failed]
-
-[Finished: './failing/message/sections' 1 test case failed (All 2 assertions failed)]
-
-[Running: ./succeeding/nofail]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MessageTests.cpp:88: 1 == 2 failed - but was ok
-[Finished: './succeeding/nofail' No tests ran]
-
-[Running: ./succeeding/Misc/Sections]
-[Started section: 's1']
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:25: a != b succeeded for: 1 != 2
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:26: b != a succeeded for: 2 != 1
-[End of section: 's1' All 2 assertions passed]
-
-[Started section: 's2']
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:31: a != b succeeded for: 1 != 2
-[End of section: 's2' 1 assertion passed]
-
-[Finished: './succeeding/Misc/Sections' All tests passed (3 assertions in 1 test case)]
-
-[Running: ./succeeding/Misc/Sections/nested]
-[Started section: 's1']
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:42: a != b succeeded for: 1 != 2
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:43: b != a succeeded for: 2 != 1
-[Started section: 's2']
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:47: a != b succeeded for: 1 != 2
-[End of section: 's2' 1 assertion passed]
-
-[End of section: 's1' All 3 assertions passed]
-
-[Finished: './succeeding/Misc/Sections/nested' All tests passed (3 assertions in 1 test case)]
-
-[Running: ./succeeding/Misc/null strings]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:163: makeString( false ) != static_cast<char*>(__null) succeeded for: "valid string" != {null string}
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:164: makeString( true ) == static_cast<char*>(__null) succeeded for: {null string} == {null string}
-[Finished: './succeeding/Misc/null strings' All tests passed (2 assertions in 1 test case)]
-
-[Running: ./failing/info]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:169: [info: hi]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:171: [info: i := 7]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:172: false failed
-[Finished: './failing/info' 1 test case failed (1 assertion failed)]
-
-[Running: ./succeeding/checkedif]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:177: flag succeeded for: true
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:185: testCheckedIf( true ) succeeded for: true
-[Finished: './succeeding/checkedif' All tests passed (2 assertions in 1 test case)]
-
-[Running: ./failing/checkedif]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:177: flag failed for: false
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:190: testCheckedIf( false ) failed for: false
-[Finished: './failing/checkedif' 1 test case failed (All 2 assertions failed)]
-
-[Running: ./succeeding/checkedelse]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:195: flag succeeded for: true
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:203: testCheckedElse( true ) succeeded for: true
-[Finished: './succeeding/checkedelse' All tests passed (2 assertions in 1 test case)]
-
-[Running: ./failing/checkedelse]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:195: flag failed for: false
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:208: testCheckedElse( false ) failed for: false
-[Finished: './failing/checkedelse' 1 test case failed (All 2 assertions failed)]
-
-[Running: ./succeeding/atomic if]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:236: x == 0 succeeded for: 0 == 0
-[Finished: './succeeding/atomic if' All tests passed (1 assertion in 1 test case)]
-
-[Running: ./succeeding/matchers]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:246: testStringForMatching() Contains( "string" ) succeeded for: 
-	"this string contains 'abc' as a substring" contains: "string"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:247: testStringForMatching() Contains( "abc" ) succeeded for: 
-	"this string contains 'abc' as a substring" contains: "abc"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:249: testStringForMatching() StartsWith( "this" ) succeeded for: 
-	"this string contains 'abc' as a substring" starts with: "this"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:250: testStringForMatching() EndsWith( "substring" ) succeeded for: 
-	"this string contains 'abc' as a substring" ends with: "substring"
-[Finished: './succeeding/matchers' All tests passed (4 assertions in 1 test case)]
-
-[Running: ./failing/matchers/Contains]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:255: testStringForMatching() Contains( "not there" ) failed for: 
-	"this string contains 'abc' as a substring" contains: "not there"
-[Finished: './failing/matchers/Contains' 1 test case failed (1 assertion failed)]
-
-[Running: ./failing/matchers/StartsWith]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:260: testStringForMatching() StartsWith( "string" ) failed for: 
-	"this string contains 'abc' as a substring" starts with: "string"
-[Finished: './failing/matchers/StartsWith' 1 test case failed (1 assertion failed)]
-
-[Running: ./failing/matchers/EndsWith]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:265: testStringForMatching() EndsWith( "this" ) failed for: 
-	"this string contains 'abc' as a substring" ends with: "this"
-[Finished: './failing/matchers/EndsWith' 1 test case failed (1 assertion failed)]
-
-[Running: ./failing/matchers/Equals]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:270: testStringForMatching() Equals( "something else" ) failed for: 
-	"this string contains 'abc' as a substring" equals: "something else"
-[Finished: './failing/matchers/Equals' 1 test case failed (1 assertion failed)]
-
-[Running: ./succeeding/matchers/Equals]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:285: testStringForMatching() Equals( "this string contains 'abc' as a substring" ) succeeded for: 
-"this string contains 'abc' as a substring" equals: "this string contains 'abc' as a substring"
-[Finished: './succeeding/matchers/Equals' All tests passed (1 assertion in 1 test case)]
-
-[Running: ./succeeding/Tricky/std::pair]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:37: (std::pair<int, int>( 1, 2 )) == aNicePair succeeded for: 
-	
-	std::pair( 1, 2 )
-	==
-	std::pair( 1, 2 )
-[Finished: './succeeding/Tricky/std::pair' All tests passed (1 assertion in 1 test case)]
-
-[Running: ./failing/Tricky/non streamable type]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:95: &o1 == &o2 failed for: 0x7fff54208858 == 0x7fff54208850
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:96: o1 == o2 failed for: {?} == {?}
-[Finished: './failing/Tricky/non streamable type' 1 test case failed (All 2 assertions failed)]
-
-[Running: ./failing/string literals]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:106: std::string( "first" ) == "second" failed for: "first" == "second"
-[Finished: './failing/string literals' 1 test case failed (1 assertion failed)]
-
-[Running: ./succeeding/side-effects]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:119: i++ == 7 succeeded for: 7 == 7
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:120: i++ == 8 succeeded for: 8 == 8
-[Finished: './succeeding/side-effects' All tests passed (2 assertions in 1 test case)]
-
-[Running: ./succeeding/koenig]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:186: 0xc0000000 == o succeeded for: 0xc0000000 == {?}
-[Finished: './succeeding/koenig' All tests passed (1 assertion in 1 test case)]
-
-[Running: ./succeeding/non-const==]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:212: t == 1u succeeded for: {?} == 1
-[Finished: './succeeding/non-const==' All tests passed (1 assertion in 1 test case)]
-
-[Running: ./succeeding/enum/bits]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:224: 0xc0000000 == bit30and31 succeeded for: 0xc0000000 == 3221225472
-[Finished: './succeeding/enum/bits' All tests passed (1 assertion in 1 test case)]
-
-[Running: ./succeeding/boolean member]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:239: obj.prop != __null succeeded for: 0x7fff54208850 != 0
-[Finished: './succeeding/boolean member' All tests passed (1 assertion in 1 test case)]
-
-[Running: ./succeeding/unimplemented static bool]
-[Started section: 'compare to true']
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:259: is_true<true>::value == true succeeded for: true == true
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:260: true == is_true<true>::value succeeded for: true == true
-[End of section: 'compare to true' All 2 assertions passed]
-
-[Started section: 'compare to false']
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:264: is_true<false>::value == false succeeded for: false == false
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:265: false == is_true<false>::value succeeded for: false == false
-[End of section: 'compare to false' All 2 assertions passed]
-
-[Started section: 'negation']
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:270: !is_true<false>::value succeeded for: true
-[End of section: 'negation' 1 assertion passed]
-
-[Started section: 'double negation']
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:275: !!is_true<true>::value succeeded for: true
-[End of section: 'double negation' 1 assertion passed]
-
-[Started section: 'direct']
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:280: is_true<true>::value succeeded for: true
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:281: !is_true<false>::value succeeded for: !false
-[End of section: 'direct' All 2 assertions passed]
-
-[Finished: './succeeding/unimplemented static bool' All tests passed (8 assertions in 1 test case)]
-
-[Running: ./succeeding/SafeBool]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:313: True succeeded for: true
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:314: !False succeeded for: true
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:315: !False succeeded for: !false
-[Finished: './succeeding/SafeBool' All tests passed (3 assertions in 1 test case)]
-[End of group: './failing* ./succeeding*'. 25 of 67 test cases failed (72 of 361 assertions failed)]
-
-
-[Testing completed. 25 of 67 test cases failed (72 of 361 assertions failed)]
-

projects/SelfTest/Baselines/successfulResults.txt

@@ -1,469 +0,0 @@
-[Started testing]
-[Started group: './succeeding*']
-
-[Running: ./succeeding/Approx/simple]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:20: d == Approx( 1.23 ) succeeded for: 1.23 == Approx( 1.23 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:21: d != Approx( 1.22 ) succeeded for: 1.23 != Approx( 1.22 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:22: d != Approx( 1.24 ) succeeded for: 1.23 != Approx( 1.24 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:24: Approx( d ) == 1.23 succeeded for: Approx( 1.23 ) == 1.23
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:25: Approx( d ) != 1.22 succeeded for: Approx( 1.23 ) != 1.22
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:26: Approx( d ) != 1.24 succeeded for: Approx( 1.23 ) != 1.24
-[Finished: './succeeding/Approx/simple' All tests passed (6 assertions in 1 test case)]
-
-[Running: ./succeeding/Approx/epsilon]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:38: d != Approx( 1.231 ) succeeded for: 1.23 != Approx( 1.231 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:39: d == Approx( 1.231 ).epsilon( 0.1 ) succeeded for: 1.23 == Approx( 1.231 )
-[Finished: './succeeding/Approx/epsilon' All tests passed (2 assertions in 1 test case)]
-
-[Running: ./succeeding/Approx/float]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:49: 1.23f == Approx( 1.23f ) succeeded for: 1.23 == Approx( 1.23 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:50: 0.0f == Approx( 0.0f ) succeeded for: 0 == Approx( 0 )
-[Finished: './succeeding/Approx/float' All tests passed (2 assertions in 1 test case)]
-
-[Running: ./succeeding/Approx/int]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:60: 1 == Approx( 1 ) succeeded
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:61: 0 == Approx( 0 ) succeeded
-[Finished: './succeeding/Approx/int' All tests passed (2 assertions in 1 test case)]
-
-[Running: ./succeeding/Approx/mixed]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:75: 1.0f == Approx( 1 ) succeeded for: 1 == Approx( 1 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:76: 0 == Approx( dZero) succeeded for: 0 == Approx( 0 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:77: 0 == Approx( dSmall ).epsilon( 0.001 ) succeeded for: 0 == Approx( 1e-05 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:78: 1.234f == Approx( dMedium ) succeeded for: 1.234 == Approx( 1.234 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:79: dMedium == Approx( 1.234f ) succeeded for: 1.234 == Approx( 1.234 )
-[Finished: './succeeding/Approx/mixed' All tests passed (5 assertions in 1 test case)]
-
-[Running: ./succeeding/Approx/custom]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:93: d == approx( 1.23 ) succeeded for: 1.23 == Approx( 1.23 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:94: d == approx( 1.22 ) succeeded for: 1.23 == Approx( 1.22 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:95: d == approx( 1.24 ) succeeded for: 1.23 == Approx( 1.24 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:96: d != approx( 1.25 ) succeeded for: 1.23 != Approx( 1.25 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:98: approx( d ) == 1.23 succeeded for: Approx( 1.23 ) == 1.23
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:99: approx( d ) == 1.22 succeeded for: Approx( 1.23 ) == 1.22
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:100: approx( d ) == 1.24 succeeded for: Approx( 1.23 ) == 1.24
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ApproxTests.cpp:101: approx( d ) != 1.25 succeeded for: Approx( 1.23 ) != 1.25
-[Finished: './succeeding/Approx/custom' All tests passed (8 assertions in 1 test case)]
-
-[Running: ./succeeding/TestClass/succeedingCase]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ClassTests.cpp:24: s == "hello" succeeded for: "hello" == "hello"
-[Finished: './succeeding/TestClass/succeedingCase' All tests passed (1 assertion in 1 test case)]
-
-[Running: ./succeeding/Fixture/succeedingCase]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ClassTests.cpp:47: m_a == 1 succeeded for: 1 == 1
-[Finished: './succeeding/Fixture/succeedingCase' All tests passed (1 assertion in 1 test case)]
-
-[Running: ./succeeding/conditions/equality]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:55: data.int_seven == 7 succeeded for: 7 == 7
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:56: data.float_nine_point_one == Approx( 9.1f ) succeeded for: 9.1 == Approx( 9.1 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:57: data.double_pi == Approx( 3.1415926535 ) succeeded for: 3.14159 == Approx( 3.14159 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:58: data.str_hello == "hello" succeeded for: "hello" == "hello"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:59: "hello" == data.str_hello succeeded for: "hello" == "hello"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:60: data.str_hello.size() == 5 succeeded for: 5 == 5
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:63: x == Approx( 1.3 ) succeeded for: 1.3 == Approx( 1.3 )
-[Finished: './succeeding/conditions/equality' All tests passed (7 assertions in 1 test case)]
-
-[Running: ./succeeding/conditions/inequality]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:93: data.int_seven != 6 succeeded for: 7 != 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:94: data.int_seven != 8 succeeded for: 7 != 8
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:95: data.float_nine_point_one != Approx( 9.11f ) succeeded for: 9.1 != Approx( 9.11 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:96: data.float_nine_point_one != Approx( 9.0f ) succeeded for: 9.1 != Approx( 9 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:97: data.float_nine_point_one != Approx( 1 ) succeeded for: 9.1 != Approx( 1 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:98: data.float_nine_point_one != Approx( 0 ) succeeded for: 9.1 != Approx( 0 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:99: data.double_pi != Approx( 3.1415 ) succeeded for: 3.14159 != Approx( 3.1415 )
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:100: data.str_hello != "goodbye" succeeded for: "hello" != "goodbye"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:101: data.str_hello != "hell" succeeded for: "hello" != "hell"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:102: data.str_hello != "hello1" succeeded for: "hello" != "hello1"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:103: data.str_hello.size() != 6 succeeded for: 5 != 6
-[Finished: './succeeding/conditions/inequality' All tests passed (11 assertions in 1 test case)]
-
-[Running: ./succeeding/conditions/ordered]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:124: data.int_seven < 8 succeeded for: 7 < 8
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:125: data.int_seven > 6 succeeded for: 7 > 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:126: data.int_seven > 0 succeeded for: 7 > 0
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:127: data.int_seven > -1 succeeded for: 7 > -1
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:129: data.int_seven >= 7 succeeded for: 7 >= 7
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:130: data.int_seven >= 6 succeeded for: 7 >= 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:131: data.int_seven <= 7 succeeded for: 7 <= 7
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:132: data.int_seven <= 8 succeeded for: 7 <= 8
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:134: data.float_nine_point_one > 9 succeeded for: 9.1 > 9
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:135: data.float_nine_point_one < 10 succeeded for: 9.1 < 10
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:136: data.float_nine_point_one < 9.2 succeeded for: 9.1 < 9.2
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:138: data.str_hello <= "hello" succeeded for: "hello" <= "hello"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:139: data.str_hello >= "hello" succeeded for: "hello" >= "hello"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:141: data.str_hello < "hellp" succeeded for: "hello" < "hellp"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:142: data.str_hello < "zebra" succeeded for: "hello" < "zebra"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:143: data.str_hello > "hellm" succeeded for: "hello" > "hellm"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:144: data.str_hello > "a" succeeded for: "hello" > "a"
-[Finished: './succeeding/conditions/ordered' All tests passed (17 assertions in 1 test case)]
-
-[Running: ./succeeding/conditions/int literals]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:188: i == 1 succeeded for: 1 == 1
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:189: ui == 2 succeeded for: 2 == 2
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:190: l == 3 succeeded for: 3 == 3
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:191: ul == 4 succeeded for: 4 == 4
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:192: c == 5 succeeded for: 5 == 5
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:193: uc == 6 succeeded for:  == 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:195: 1 == i succeeded for: 1 == 1
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:196: 2 == ui succeeded for: 2 == 2
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:197: 3 == l succeeded for: 3 == 3
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:198: 4 == ul succeeded for: 4 == 4
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:199: 5 == c succeeded for: 5 == 5
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:200: 6 == uc succeeded for: 6 == 
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:202: (std::numeric_limits<unsigned long>::max)() > ul succeeded for: 0xffffffffffffffff > 4
-[Finished: './succeeding/conditions/int literals' All tests passed (13 assertions in 1 test case)]
-
-[Running: ./succeeding/conditions//long_to_unsigned_x]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:223: long_var == unsigned_char_var succeeded for: 1 == 

-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:224: long_var == unsigned_short_var succeeded for: 1 == 1
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:225: long_var == unsigned_int_var succeeded for: 1 == 1
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:226: long_var == unsigned_long_var succeeded for: 1 == 1
-[Finished: './succeeding/conditions//long_to_unsigned_x' All tests passed (4 assertions in 1 test case)]
-
-[Running: ./succeeding/conditions/negative ints]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:232: ( -1 > 2u ) succeeded for: true
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:233: -1 > 2u succeeded for: -1 > 2
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:235: ( 2u < -1 ) succeeded for: true
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:236: 2u < -1 succeeded for: 2 < -1
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:239: ( minInt > 2u ) succeeded for: true
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:240: minInt > 2u succeeded for: -2147483648 > 2
-[Finished: './succeeding/conditions/negative ints' All tests passed (6 assertions in 1 test case)]
-
-[Running: ./succeeding/conditions/computed ints]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:255: 54 == 6*9 succeeded for: 54 == 54
-[Finished: './succeeding/conditions/computed ints' All tests passed (1 assertion in 1 test case)]
-
-[Running: ./succeeding/conditions/ptr]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:271: p == __null succeeded for: __null == 0
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:272: p == pNULL succeeded for: __null == __null
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:277: p != __null succeeded for: 0x7fff556be0f8 != 0
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:280: cp != __null succeeded for: 0x7fff556be0f8 != 0
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:283: cpc != __null succeeded for: 0x7fff556be0f8 != 0
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:285: returnsNull() == __null succeeded for: {null string} == 0
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:286: returnsConstNull() == __null succeeded for: {null string} == 0
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:288: __null != p succeeded for: 0 != 0x7fff556be0f8
-[Finished: './succeeding/conditions/ptr' All tests passed (8 assertions in 1 test case)]
-
-[Running: ./succeeding/conditions/not]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:303: false == false succeeded
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:304: true == true succeeded
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:305: !false succeeded for: true
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:306: !false succeeded
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:308: !falseValue succeeded for: true
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:309: !falseValue succeeded for: !false
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:311: !(1 == 2) succeeded for: true
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ConditionTests.cpp:312: !1 == 2 succeeded for: !(1 == 2)
-[Finished: './succeeding/conditions/not' All tests passed (8 assertions in 1 test case)]
-
-[Running: ./succeeding/exceptions/explicit]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:39: thisThrows() succeeded
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:40: thisDoesntThrow() succeeded
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:41: thisThrows() succeeded
-[Finished: './succeeding/exceptions/explicit' All tests passed (3 assertions in 1 test case)]
-
-[Running: ./succeeding/exceptions/error messages]
-
-[Started section: 'custom, unexpected']
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:145: runner.getLog() Contains( "custom exception" ) succeeded for: 
-"\[g] ./failing/exceptions/custom
- \[tc] ./failing/exceptions/custom
-ThrewException'custom exception' /[tc] ./failing/exceptions/custom
-/[g] ./failing/exceptions/custom
-" contains: "custom exception"
-[End of section: 'custom, unexpected' 1 assertion passed]
-
-[Started section: 'in section']
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:153: runner.getLog() Contains( "Exception from section" ) succeeded for: 
-"\[g] ./failing/exceptions/in-section
- \[tc] ./failing/exceptions/in-section
-  \ [s] the section
-   \ [s] the section2
-   / [s] the section2
-  / [s] the section
-ThrewException'Exception from section'  \ [s] the section
-  / [s] the section
- /[tc] ./failing/exceptions/in-section
-/[g] ./failing/exceptions/in-section
-" contains: "Exception from section"
-[End of section: 'in section' 1 assertion passed]
-
-[Finished: './succeeding/exceptions/error messages' All tests passed (2 assertions in 1 test case)]
-
-[Running: ./succeeding/exceptions/notimplemented]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/ExceptionTests.cpp:165: thisFunctionNotImplemented( 7 ) succeeded
-[Finished: './succeeding/exceptions/notimplemented' All tests passed (1 assertion in 1 test case)]
-
-[Running: ./succeeding/generators/1]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 2 == 2
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 200 == 200
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 4 == 4
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 200 == 200
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 6 == 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 200 == 200
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 8 == 8
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 200 == 200
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 10 == 10
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 200 == 200
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 30 == 30
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 200 == 200
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 40 == 40
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 200 == 200
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 42 == 42
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 200 == 200
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 72 == 72
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 200 == 200
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 2 == 2
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 202 == 202
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 4 == 4
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 202 == 202
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 6 == 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 202 == 202
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 8 == 8
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 202 == 202
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 10 == 10
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 202 == 202
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 30 == 30
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 202 == 202
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 40 == 40
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 202 == 202
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 42 == 42
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 202 == 202
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 72 == 72
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 202 == 202
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 2 == 2
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 204 == 204
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 4 == 4
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 204 == 204
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 6 == 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 204 == 204
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 8 == 8
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 204 == 204
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 10 == 10
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 204 == 204
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 30 == 30
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 204 == 204
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 40 == 40
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 204 == 204
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 42 == 42
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 204 == 204
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 72 == 72
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 204 == 204
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 2 == 2
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 206 == 206
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 4 == 4
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 206 == 206
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 6 == 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 206 == 206
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 8 == 8
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 206 == 206
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 10 == 10
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 206 == 206
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 30 == 30
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 206 == 206
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 40 == 40
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 206 == 206
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 42 == 42
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 206 == 206
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 72 == 72
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 206 == 206
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 2 == 2
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 208 == 208
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 4 == 4
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 208 == 208
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 6 == 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 208 == 208
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 8 == 8
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 208 == 208
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 10 == 10
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 208 == 208
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 30 == 30
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 208 == 208
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 40 == 40
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 208 == 208
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 42 == 42
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 208 == 208
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 72 == 72
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 208 == 208
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 2 == 2
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 210 == 210
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 4 == 4
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 210 == 210
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 6 == 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 210 == 210
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 8 == 8
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 210 == 210
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 10 == 10
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 210 == 210
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 30 == 30
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 210 == 210
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 40 == 40
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 210 == 210
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 42 == 42
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 210 == 210
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 72 == 72
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 210 == 210
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 2 == 2
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 212 == 212
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 4 == 4
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 212 == 212
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 6 == 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 212 == 212
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 8 == 8
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 212 == 212
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 10 == 10
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 212 == 212
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 30 == 30
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 212 == 212
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 40 == 40
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 212 == 212
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 42 == 42
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 212 == 212
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 72 == 72
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 212 == 212
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 2 == 2
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 214 == 214
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 4 == 4
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 214 == 214
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 6 == 6
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 214 == 214
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 8 == 8
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 214 == 214
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 10 == 10
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 214 == 214
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 30 == 30
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 214 == 214
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 40 == 40
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 214 == 214
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 42 == 42
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 214 == 214
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 72 == 72
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 214 == 214
-[Finished: './succeeding/generators/1' All tests passed (144 assertions in 1 test case)]
-
-[Running: ./succeeding/message]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MessageTests.cpp:14: [warning: this is a warning]
-[Finished: './succeeding/message' No tests ran]
-
-[Running: ./succeeding/Misc/Sections]
-[Started section: 's1']
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:25: a != b succeeded for: 1 != 2
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:26: b != a succeeded for: 2 != 1
-[End of section: 's1' All 2 assertions passed]
-
-[Started section: 's2']
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:31: a != b succeeded for: 1 != 2
-[End of section: 's2' 1 assertion passed]
-
-[Finished: './succeeding/Misc/Sections' All tests passed (3 assertions in 1 test case)]
-
-[Running: ./succeeding/Misc/Sections/nested]
-[Started section: 's1']
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:42: a != b succeeded for: 1 != 2
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:43: b != a succeeded for: 2 != 1
-[Started section: 's2']
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:47: a != b succeeded for: 1 != 2
-[End of section: 's2' 1 assertion passed]
-
-[End of section: 's1' All 3 assertions passed]
-
-[Finished: './succeeding/Misc/Sections/nested' All tests passed (3 assertions in 1 test case)]
-
-[Running: ./succeeding/Misc/null strings]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:163: makeString( false ) != static_cast<char*>(__null) succeeded for: "valid string" != {null string}
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:164: makeString( true ) == static_cast<char*>(__null) succeeded for: {null string} == {null string}
-[Finished: './succeeding/Misc/null strings' All tests passed (2 assertions in 1 test case)]
-
-[Running: ./succeeding/checkedif]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:177: flag succeeded for: true
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:185: testCheckedIf( true ) succeeded for: true
-[Finished: './succeeding/checkedif' All tests passed (2 assertions in 1 test case)]
-
-[Running: ./succeeding/checkedelse]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:195: flag succeeded for: true
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:203: testCheckedElse( true ) succeeded for: true
-[Finished: './succeeding/checkedelse' All tests passed (2 assertions in 1 test case)]
-
-[Running: ./succeeding/atomic if]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:236: x == 0 succeeded for: 0 == 0
-[Finished: './succeeding/atomic if' All tests passed (1 assertion in 1 test case)]
-
-[Running: ./succeeding/matchers]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:246: testStringForMatching() Contains( "string" ) succeeded for: 
-	"this string contains 'abc' as a substring" contains: "string"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:247: testStringForMatching() Contains( "abc" ) succeeded for: 
-	"this string contains 'abc' as a substring" contains: "abc"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:249: testStringForMatching() StartsWith( "this" ) succeeded for: 
-	"this string contains 'abc' as a substring" starts with: "this"
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:250: testStringForMatching() EndsWith( "substring" ) succeeded for: 
-	"this string contains 'abc' as a substring" ends with: "substring"
-[Finished: './succeeding/matchers' All tests passed (4 assertions in 1 test case)]
-
-[Running: ./succeeding/matchers/Equals]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/MiscTests.cpp:285: testStringForMatching() Equals( "this string contains 'abc' as a substring" ) succeeded for: 
-"this string contains 'abc' as a substring" equals: "this string contains 'abc' as a substring"
-[Finished: './succeeding/matchers/Equals' All tests passed (1 assertion in 1 test case)]
-
-[Running: ./succeeding/Tricky/std::pair]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:37: (std::pair<int, int>( 1, 2 )) == aNicePair succeeded for: 
-	
-	std::pair( 1, 2 )
-	==
-	std::pair( 1, 2 )
-[Finished: './succeeding/Tricky/std::pair' All tests passed (1 assertion in 1 test case)]
-
-[Running: ./succeeding/side-effects]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:119: i++ == 7 succeeded for: 7 == 7
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:120: i++ == 8 succeeded for: 8 == 8
-[Finished: './succeeding/side-effects' All tests passed (2 assertions in 1 test case)]
-
-[Running: ./succeeding/koenig]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:186: 0xc0000000 == o succeeded for: 0xc0000000 == {?}
-[Finished: './succeeding/koenig' All tests passed (1 assertion in 1 test case)]
-
-[Running: ./succeeding/non-const==]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:212: t == 1u succeeded for: {?} == 1
-[Finished: './succeeding/non-const==' All tests passed (1 assertion in 1 test case)]
-
-[Running: ./succeeding/enum/bits]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:224: 0xc0000000 == bit30and31 succeeded for: 0xc0000000 == 3221225472
-[Finished: './succeeding/enum/bits' All tests passed (1 assertion in 1 test case)]
-
-[Running: ./succeeding/boolean member]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:239: obj.prop != __null succeeded for: 0x7fff556be8e0 != 0
-[Finished: './succeeding/boolean member' All tests passed (1 assertion in 1 test case)]
-
-[Running: ./succeeding/unimplemented static bool]
-[Started section: 'compare to true']
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:259: is_true<true>::value == true succeeded for: true == true
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:260: true == is_true<true>::value succeeded for: true == true
-[End of section: 'compare to true' All 2 assertions passed]
-
-[Started section: 'compare to false']
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:264: is_true<false>::value == false succeeded for: false == false
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:265: false == is_true<false>::value succeeded for: false == false
-[End of section: 'compare to false' All 2 assertions passed]
-
-[Started section: 'negation']
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:270: !is_true<false>::value succeeded for: true
-[End of section: 'negation' 1 assertion passed]
-
-[Started section: 'double negation']
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:275: !!is_true<true>::value succeeded for: true
-[End of section: 'double negation' 1 assertion passed]
-
-[Started section: 'direct']
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:280: is_true<true>::value succeeded for: true
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:281: !is_true<false>::value succeeded for: !false
-[End of section: 'direct' All 2 assertions passed]
-
-[Finished: './succeeding/unimplemented static bool' All tests passed (8 assertions in 1 test case)]
-
-[Running: ./succeeding/SafeBool]
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:313: True succeeded for: true
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:314: !False succeeded for: true
-/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/TrickyTests.cpp:315: !False succeeded for: !false
-[Finished: './succeeding/SafeBool' All tests passed (3 assertions in 1 test case)]
-[End of group: './succeeding*'. All tests passed (288 assertions in 41 test cases)]
-
-
-[Testing completed. All tests passed (288 assertions in 41 test cases)]
-

projects/SelfTest/CmdLineTests.cpp

@@ -0,0 +1,191 @@
+/*
+ *  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)
+ */
+#ifdef __clang__
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+#include "internal/clara.h"
+
+#include "catch.hpp"
+
+
+// Helper to deduce size from array literals and pass on to parser
+template<size_t size, typename ConfigT>
+std::vector<Clara::Parser::Token> parseInto( Clara::CommandLine<ConfigT>& cli, char const * (&argv)[size], ConfigT& config ) {
+    return cli.parseInto( size, argv, config );
+}
+
+
+struct TestOpt {
+    TestOpt() : number( 0 ), index( 0 ), flag( false ) {}
+
+    std::string processName;
+    std::string fileName;
+    int number;
+    int index;
+    bool flag;
+    std::string firstPos;
+    std::string secondPos;
+    std::string unpositional;
+    
+    void setValidIndex( int i ) {
+        if( i < 0 || i > 10 )
+            throw std::domain_error( "index must be between 0 and 10" );
+        index = i;
+    }
+};
+
+struct TestOpt2 {
+    std::string description;
+};
+
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+
+TEST_CASE( "cmdline" ) {
+
+    TestOpt config;
+    Clara::CommandLine<TestOpt> cli;
+    cli.bindProcessName( &TestOpt::processName );
+    cli.bind( &TestOpt::fileName )
+        .describe( "specifies output file" )
+        .shortOpt( "o" )
+        .longOpt( "output" )
+        .argName( "filename" );
+
+    SECTION( "process name" ) {
+        char const * argv[] = { "test", "-o filename.ext" };
+        parseInto( cli, argv, config );
+        
+        CHECK( config.processName == "test" );
+    }
+    SECTION( "arg separated by spaces" ) {
+        char const * argv[] = { "test", "-o filename.ext" };
+        parseInto( cli, argv, config );
+        
+        CHECK( config.fileName == "filename.ext" );
+    }
+    SECTION( "arg separated by colon" ) {
+        const char* argv[] = { "test", "-o:filename.ext" };
+        parseInto( cli, argv, config );
+
+        CHECK( config.fileName == "filename.ext" );
+    }
+    SECTION( "arg separated by =" ) {
+        const char* argv[] = { "test", "-o=filename.ext" };
+        parseInto( cli, argv, config );
+
+        CHECK( config.fileName == "filename.ext" );
+    }
+    SECTION( "long opt" ) {
+        const char* argv[] = { "test", "--output %stdout" };
+        parseInto( cli, argv, config );
+
+        CHECK( config.fileName == "%stdout" );
+    }
+    
+    cli.bind( &TestOpt::number )
+            .shortOpt( "n" )
+            .argName( "an integral value" );
+    
+    SECTION( "a number" ) {
+        const char* argv[] = { "test", "-n 42" };
+        parseInto( cli, argv, config );
+
+        CHECK( config.number == 42 );
+    }
+    SECTION( "not a number" ) {
+        const char* argv[] = { "test", "-n forty-two" };
+        CHECK_THROWS( parseInto( cli, argv, config ) );
+
+        CHECK( config.number == 0 );
+    }
+    
+    SECTION( "two parsers" ) {
+
+        TestOpt config1;
+        TestOpt2 config2;
+        Clara::CommandLine<TestOpt2> cli2;
+
+        cli2.bind( &TestOpt2::description )
+            .describe( "description" )
+            .shortOpt( "d" )
+            .longOpt( "description" )
+            .argName( "some text" );
+        
+        const char* argv[] = { "test", "-n 42", "-d some text" };
+        std::vector<Clara::Parser::Token> unusedTokens = parseInto( cli, argv, config1 );
+
+        CHECK( config1.number == 42 );
+
+        REQUIRE_FALSE( unusedTokens.empty() );
+        cli2.populate( unusedTokens, config2 );
+        CHECK( config2.description == "some text" );        
+    }
+
+    SECTION( "methods" ) {
+        cli.bind( &TestOpt::setValidIndex )
+            .describe( "An index, which is an integer between 0 and 10, inclusive" )
+            .shortOpt( "i" )
+            .argName( "index" );
+
+        SECTION( "in range" ) {
+            const char* argv[] = { "test", "-i 3" };
+            parseInto( cli, argv, config );
+
+            REQUIRE( config.index == 3 );
+        }
+        SECTION( "out of range" ) {
+            const char* argv[] = { "test", "-i 42" };
+
+            REQUIRE_THROWS( parseInto( cli, argv, config ) );
+        }
+    }
+    
+    SECTION( "flags" ) {
+        cli.bind( &TestOpt::flag )
+            .describe( "A flag" )
+            .shortOpt( "f" );
+        
+        SECTION( "set" ) {
+            const char* argv[] = { "test", "-f" };
+            parseInto( cli, argv, config );
+
+            REQUIRE( config.flag );
+        }
+        SECTION( "not set" ) {
+            const char* argv[] = { "test" };
+            parseInto( cli, argv, config );
+
+            REQUIRE( config.flag == false );
+        }
+    }
+    SECTION( "positional" ) {
+        cli.bind( &TestOpt::secondPos )
+            .describe( "Second position" )
+            .argName( "second arg" )
+            .position( 2 );
+        cli.bind( &TestOpt::unpositional )
+            .argName( "any arg" )
+            .describe( "Unpositional" );
+        cli.bind( &TestOpt::firstPos )
+            .describe( "First position" )
+            .argName( "first arg" )
+            .position( 1 );
+
+//        std::cout << cli.usage( "testApp" ) << std::endl;
+
+        const char* argv[] = { "test", "-f", "1st", "-o", "filename", "2nd", "3rd" };
+        parseInto( cli, argv, config );
+
+        REQUIRE( config.firstPos == "1st" );
+        REQUIRE( config.secondPos == "2nd" );
+        REQUIRE( config.unpositional == "3rd" );
+    }
+}
+
+#endif

projects/SelfTest/ConditionTests.cpp

@@ -204,12 +204,15 @@ TEST_CASE(  "./succeeding/conditions/int literals",
 
 // Disable warnings about sign conversions for the next two tests
 // (as we are deliberately invoking them)
-// - Current only disabled for GCC/ LLVM. Should add VC++ too
+// - Currently only disabled for GCC/ LLVM. Should add VC++ too
 #ifdef  __GNUC__
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wsign-compare"
 #pragma GCC diagnostic ignored "-Wsign-conversion"
 #endif
+#ifdef _MSC_VER
+#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
+#endif
 
 TEST_CASE(  "./succeeding/conditions//long_to_unsigned_x",
             "comparisons between int variables" )
@@ -226,6 +229,20 @@ TEST_CASE(  "./succeeding/conditions//long_to_unsigned_x",
 	REQUIRE( long_var == unsigned_long_var );
 }
 
+TEST_CASE(  "./succeeding/conditions/const ints to int literal",
+            "comparisons between const int variables" )
+{
+	const unsigned char     unsigned_char_var = 1;
+	const unsigned short    unsigned_short_var = 1;
+	const unsigned int      unsigned_int_var = 1;
+	const unsigned long     unsigned_long_var = 1L;
+
+	REQUIRE( unsigned_char_var == 1 );
+	REQUIRE( unsigned_short_var == 1 );
+	REQUIRE( unsigned_int_var == 1 );
+	REQUIRE( unsigned_long_var == 1 );
+}
+
 TEST_CASE(  "./succeeding/conditions/negative ints",
             "Comparisons between unsigned ints and negative signed ints match c++ standard behaviour" )
 {

projects/SelfTest/ExceptionTests.cpp

@@ -6,10 +6,6 @@
  *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  */
 
-#ifdef __clang__
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
 #include "catch.hpp"
 
 #include <string>
@@ -19,13 +15,11 @@
 
 namespace
 {
-    CATCH_ATTRIBUTE_NORETURN
-    int thisThrows();
-    
-    int thisThrows()
+    inline int thisThrows()
     {
-        throw std::domain_error( "expected exception" );
-        /*NOTREACHED*/    
+		if( Catch::isTrue( true ) )
+		    throw std::domain_error( "expected exception" );
+		return 1;
     }
 
     int thisDoesntThrow()
@@ -41,7 +35,6 @@ TEST_CASE( "./succeeding/exceptions/explicit", "When checked exceptions are thro
     REQUIRE_THROWS( thisThrows() );
 }
 
-CATCH_ATTRIBUTE_NORETURN
 TEST_CASE( "./failing/exceptions/explicit", "When checked exceptions are thrown they can be expected or unexpected" )
 {
     CHECK_THROWS_AS( thisThrows(), std::string );
@@ -49,10 +42,30 @@ TEST_CASE( "./failing/exceptions/explicit", "When checked exceptions are thrown
     CHECK_NOTHROW( thisThrows() );
 }
 
-TEST_CASE_NORETURN( "./failing/exceptions/implicit", "When unchecked exceptions are thrown they are always failures" )
+TEST_CASE( "./failing/exceptions/implicit", "When unchecked exceptions are thrown they are always failures" )
 {
-    throw std::domain_error( "unexpected exception" );
-    /*NOTREACHED*/    
+	if( Catch::isTrue( true ) )
+	    throw std::domain_error( "unexpected exception" );
+}
+
+TEST_CASE( "./failing/exceptions/implicit/2", "An unchecked exception reports the line of the last assertion" )
+{
+    CHECK( 1 == 1 );
+	if( Catch::isTrue( true ) )
+	    throw std::domain_error( "unexpected exception" );
+}
+TEST_CASE( "./failing/exceptions/implicit/3", "When unchecked exceptions are thrown they are always failures" )
+{
+    SECTION( "section name", "" )
+    {
+		if( Catch::isTrue( true ) )
+			throw std::domain_error( "unexpected exception" );
+    }
+}
+
+TEST_CASE( "./failing/exceptions/implicit/4", "When unchecked exceptions are thrown they are always failures" )
+{
+    CHECK( thisThrows() == 0 );
 }
 
 TEST_CASE( "./succeeding/exceptions/implicit", "When unchecked exceptions are thrown, but caught, they do not affect the test" )
@@ -92,68 +105,32 @@ CATCH_TRANSLATE_EXCEPTION( double& ex )
     return Catch::toString( ex );
 }
 
-TEST_CASE_NORETURN( "./failing/exceptions/custom", "Unexpected custom exceptions can be translated" )
+TEST_CASE( "./failing/exceptions/custom", "Unexpected custom exceptions can be translated" )
 {
-    throw CustomException( "custom exception" );
+	if( Catch::isTrue( true ) )
+	    throw CustomException( "custom exception" );
+}
+
+inline void throwCustom() {
+	if( Catch::isTrue( true ) )
+		throw CustomException( "custom exception - not std" );
 }
 
 TEST_CASE( "./failing/exceptions/custom/nothrow", "Custom exceptions can be translated when testing for nothrow" )
 {
-    REQUIRE_NOTHROW( throw CustomException( "unexpected custom exception" ) );
+    REQUIRE_NOTHROW( throwCustom() );
 }
 
 TEST_CASE( "./failing/exceptions/custom/throw", "Custom exceptions can be translated when testing for throwing as something else" )
 {
-    REQUIRE_THROWS_AS( throw CustomException( "custom exception - not std" ), std::exception );
+    REQUIRE_THROWS_AS( throwCustom(), std::exception );
 }
 
 
-TEST_CASE_NORETURN( "./failing/exceptions/custom/double", "Unexpected custom exceptions can be translated"  )
+TEST_CASE( "./failing/exceptions/custom/double", "Unexpected custom exceptions can be translated"  )
 {
-    throw double( 3.14 );
-}
-
-#ifdef  __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-variable"
-#endif
-
-TEST_CASE( "./failing/exceptions/in-section", "Exceptions thrown from sections report file/ line or section" )
-{
-    SECTION( "the section", "" )
-    {
-        CATCH_REGISTER_LINE_INFO( "the section2" ) SECTION( "the section2", "" )
-        {
-            throw std::domain_error( "Exception from section" );
-        }
-    }
-}
-
-#ifdef  __GNUC__
-#pragma GCC diagnostic pop
-#endif
-
-TEST_CASE( "./succeeding/exceptions/error messages", "The error messages produced by exceptions caught by Catch matched the expected form" )
-{
-    Catch::EmbeddedRunner runner;
-    using namespace Catch::Matchers;
-    
-    SECTION( "custom, unexpected", "" )
-    {    
-        runner.runMatching( "./failing/exceptions/custom" );
-//        CHECK_THAT( runner.getLog(), Contains( "Unexpected exception" ) ); // Mock reporter doesn't say this
-        CHECK_THAT( runner.getLog(), Contains( "custom exception" ) );
-    }
-    
-    SECTION( "in section", "" )
-    {    
-        runner.runMatching( "./failing/exceptions/in-section" );
-        INFO( runner.getLog() );
-//        CHECK( runner.getLog().find( "Unexpected exception" ) != std::string::npos ); // Mock reporter doesn't say this
-        CHECK_THAT( runner.getLog(), Contains( "Exception from section" ) );
-        CHECK_THAT( runner.getLog(), Contains( CATCH_GET_LINE_INFO( "the section2" ) ) );
-    }
-    
+	if( Catch::isTrue( true ) )
+	    throw double( 3.14 );
 }
 
 inline int thisFunctionNotImplemented( int ) {

projects/SelfTest/GeneratorTests.cpp

@@ -26,3 +26,17 @@ CATCH_TEST_CASE( "./succeeding/generators/1", "Generators over two ranges" )
     CATCH_REQUIRE( multiply( i, 2 ) == i*2 );
     CATCH_REQUIRE( multiply( j, 2 ) == j*2 );
 }
+
+struct IntPair { int first, second; };
+
+CATCH_TEST_CASE( "./succeeding/generators/2", "Generator over a range of pairs" )
+{
+    using namespace Catch::Generators;
+ 
+    IntPair p[] = { { 0, 1 }, { 2, 3 } };
+    
+    IntPair* i = CATCH_GENERATE( between( p, &p[1] ) );
+    
+    CATCH_REQUIRE( i->first == i->second-1 );
+    
+}

projects/SelfTest/MessageTests.cpp

@@ -13,6 +13,10 @@ TEST_CASE( "./succeeding/message", "INFO and WARN do not abort tests" )
     INFO( "this is a " << "message" );    // This should output the message if a failure occurs
     WARN( "this is a " << "warning" );    // This should always output the message but then continue
 }
+TEST_CASE( "./succeeding/succeed", "SUCCEED counts as a test pass" )
+{
+    SUCCEED( "this is a " << "success" );
+}
 
 TEST_CASE( "./failing/message/info/1", "INFO gets logged on failure" )
 {
@@ -24,11 +28,11 @@ TEST_CASE( "./failing/message/info/1", "INFO gets logged on failure" )
 
 TEST_CASE( "./mixed/message/info/2", "INFO gets logged on failure" )
 {
-    INFO( "this message should be logged" );
+    INFO( "this message should not be logged" );
     int a = 2;
     CHECK( a == 2 );
 
-    INFO( "this message should be logged, too" );
+    INFO( "this message should be logged" );
     
     CHECK( a == 1 );
 
@@ -43,7 +47,7 @@ TEST_CASE( "./mixed/message/info/2", "INFO gets logged on failure" )
 
 TEST_CASE( "./failing/message/fail", "FAIL aborts the test" )
 {
-    if( true )
+	if( Catch::isTrue( true ) )
         FAIL( "This is a " << "failure" );    // This should output the message and abort
 }
 
@@ -87,3 +91,12 @@ TEST_CASE( "./succeeding/nofail", "The NO_FAIL macro reports a failure but does
 {
     CHECK_NOFAIL( 1 == 2 );
 }
+
+TEST_CASE( "just info", "[info][isolated info][hide]" )
+{
+    INFO( "this should never be seen" );
+}
+TEST_CASE( "just failure", "[fail][isolated info][hide]" )
+{
+    FAIL( "Previous info should not be seen" );
+}

projects/SelfTest/MiscTests.cpp

@@ -6,10 +6,6 @@
  *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  */
 
-#ifdef __clang__
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
 #include "catch.hpp"
 #include "catch_self_test.hpp"
 
@@ -90,36 +86,6 @@ TEST_CASE( "./Sections/nested/a/b", "nested SECTION tests" )
     }
 }
 
-TEST_CASE( "Sections/nested3", "nested SECTION tests" )
-{
-    Catch::EmbeddedRunner runner;
-    
-    runner.runMatching( "./Sections/nested/a/b", "mock" );
-    CHECK( runner.getLog() == 
-        "\\[g] ./Sections/nested/a/b\n"
-        " \\[tc] ./Sections/nested/a/b\n"
-        
-        "  \\ [s] c\n"
-        "   \\ [s] d (leaf)\n"
-        "   / [s] d (leaf)\n"
-        "  / [s] c\n"
-        
-        "  \\ [s] c\n"
-        "   \\ [s] e (leaf)\n"
-        "   / [s] e (leaf)\n"
-        "  / [s] c\n"
-        
-        "  \\ [s] c\n"
-        "  / [s] c\n"
-        
-        "  \\ [s] f (leaf)\n"
-        "  / [s] f (leaf)\n"
-        
-        " /[tc] ./Sections/nested/a/b\n"
-        "/[g] ./Sections/nested/a/b\n" );
-    
-}
-
 TEST_CASE( "./mixed/Misc/Sections/loops", "looped SECTION tests" )
 {
     int a = 1;
@@ -269,12 +235,15 @@ TEST_CASE("./failing/matchers/Equals", "")
 {
     CHECK_THAT( testStringForMatching(), Equals( "something else" ) );
 }
-
-TEST_CASE("/succeeding/matchers/AllOf", "")
+TEST_CASE("string", "Equals with NULL")
+{
+    REQUIRE_THAT("", Equals(NULL));
+}
+TEST_CASE("./succeeding/matchers/AllOf", "")
 {
     CHECK_THAT( testStringForMatching(), AllOf( Catch::Contains( "string" ), Catch::Contains( "abc" ) ) );
 }
-TEST_CASE("/succeeding/matchers/AnyOf", "")
+TEST_CASE("./succeeding/matchers/AnyOf", "")
 {
     CHECK_THAT( testStringForMatching(), AnyOf( Catch::Contains( "string" ), Catch::Contains( "not there" ) ) );
     CHECK_THAT( testStringForMatching(), AnyOf( Catch::Contains( "not there" ), Catch::Contains( "string" ) ) );
@@ -291,8 +260,7 @@ inline unsigned int Factorial( unsigned int number )
   return number > 1 ? Factorial(number-1)*number : 1;
 }
 
-TEST_CASE( "example/factorial", "The Factorial function should return the factorial of the number passed in" )
-{
+TEST_CASE( "Factorials are computed", "[factorial]" ) {
   REQUIRE( Factorial(0) == 1 );
   REQUIRE( Factorial(1) == 1 );
   REQUIRE( Factorial(2) == 2 );
@@ -323,3 +291,53 @@ TEST_CASE( "second tag", "[tag2]" )
 //    while ( fgets(line, 199, output) )
 //        std::cout << line;
 //}
+
+TEST_CASE( "vectors can be sized and resized", "[vector]" ) {
+
+    std::vector<int> v( 5 );
+    
+    REQUIRE( v.size() == 5 );
+    REQUIRE( v.capacity() >= 5 );
+    
+    SECTION( "resizing bigger changes size and capacity", "" ) {
+        v.resize( 10 );
+        
+        REQUIRE( v.size() == 10 );
+        REQUIRE( v.capacity() >= 10 );
+    }
+    SECTION( "resizing smaller changes size but not capacity", "" ) {
+        v.resize( 0 );
+        
+        REQUIRE( v.size() == 0 );
+        REQUIRE( v.capacity() >= 5 );
+        
+        SECTION( "We can use the 'swap trick' to reset the capacity", "" ) {
+            std::vector<int> empty;
+            empty.swap( v );
+            
+            REQUIRE( v.capacity() == 0 );
+        }
+    }
+    SECTION( "reserving bigger changes capacity but not size", "" ) {
+        v.reserve( 10 );
+        
+        REQUIRE( v.size() == 5 );
+        REQUIRE( v.capacity() >= 10 );
+    }
+    SECTION( "reserving smaller does not change size or capacity", "" ) {
+        v.reserve( 0 );
+        
+        REQUIRE( v.size() == 5 );
+        REQUIRE( v.capacity() >= 5 );
+    }
+}
+
+// https://github.com/philsquared/Catch/issues/166
+//TEST_CASE("CatchSectionInfiniteLoop", "")
+//{
+//    SECTION("Outer", "")
+//        SECTION("Inner", "")
+//            SUCCEED("that's not flying - that's failing in style");
+//
+//    FAIL("to infinity and beyond");
+//}

projects/SelfTest/SurrogateCpps/catch_message.cpp

@@ -0,0 +1,2 @@
+// This file is only here to verify (to the extent possible) the self sufficiency of the header
+#include "catch_message.h"

projects/SelfTest/SurrogateCpps/catch_option.cpp

@@ -0,0 +1,2 @@
+// This file is only here to verify (to the extent possible) the self sufficiency of the header
+#include "catch_option.hpp"

projects/SelfTest/TestMain.cpp

@@ -10,6 +10,7 @@
 #endif
 
 #include "catch_self_test.hpp"
+#include "internal/catch_text.h"
 
 TEST_CASE( "selftest/main", "Runs all Catch self tests and checks their results" ) {
     using namespace Catch;
@@ -20,12 +21,12 @@ TEST_CASE( "selftest/main", "Runs all Catch self tests and checks their results"
                 
         SECTION(    "selftest/expected result/failing tests", 
                     "Tests in the 'failing' branch fail" ) {
-            MetaTestRunner::runMatching( "./failing/*",  MetaTestRunner::Expected::ToFail );
+            MetaTestRunner::runMatching( "./failing/*",  MetaTestRunner::Expected::ToFail, 0, 2 );
         }
         
         SECTION(    "selftest/expected result/succeeding tests", 
                     "Tests in the 'succeeding' branch succeed" ) {
-            MetaTestRunner::runMatching( "./succeeding/*",  MetaTestRunner::Expected::ToSucceed );
+            MetaTestRunner::runMatching( "./succeeding/*",  MetaTestRunner::Expected::ToSucceed, 1, 2 );
         }
     }
 
@@ -36,16 +37,16 @@ TEST_CASE( "selftest/main", "Runs all Catch self tests and checks their results"
         
         SECTION(    "selftest/test counts/succeeding tests", 
                     "Number of 'succeeding' tests is fixed" ) {
-            Totals totals = runner.runMatching( "./succeeding/*" );
-            CHECK( totals.assertions.passed == 289 );
+            Totals totals = runner.runMatching( "./succeeding/*", 0, 2 );
+            CHECK( totals.assertions.passed == 296 );
             CHECK( totals.assertions.failed == 0 );
         }
 
         SECTION(    "selftest/test counts/failing tests", 
                     "Number of 'failing' tests is fixed" ) {
-            Totals totals = runner.runMatching( "./failing/*" );        
-            CHECK( totals.assertions.passed == 0 );
-            CHECK( totals.assertions.failed == 72 );
+            Totals totals = runner.runMatching( "./failing/*", 1, 2 );
+            CHECK( totals.assertions.passed == 1 );
+            CHECK( totals.assertions.failed == 74 );
         }
     }
 }
@@ -53,7 +54,7 @@ TEST_CASE( "selftest/main", "Runs all Catch self tests and checks their results"
 TEST_CASE( "meta/Misc/Sections", "looped tests" ) {
     Catch::EmbeddedRunner runner;
     
-    Catch::Totals totals = runner.runMatching( "./mixed/Misc/Sections/nested2" );
+    Catch::Totals totals = runner.runMatching( "./mixed/Misc/Sections/nested2", 0, 1 );
     CHECK( totals.assertions.passed == 2 );
     CHECK( totals.assertions.failed == 1 );
 }
@@ -70,8 +71,8 @@ TEST_CASE( "meta/Misc/Sections", "looped tests" ) {
 
 template<size_t size>
 void parseIntoConfig( const char * (&argv)[size], Catch::ConfigData& config ) {
-    static Catch::AllOptions options;
-    options.parseIntoConfig( Catch::CommandParser( size, argv ), config );
+    Clara::CommandLine<Catch::ConfigData> parser = Catch::makeCommandLineParser();
+    parser.parseInto( size, argv, config );
 }
 
 template<size_t size>
@@ -86,105 +87,82 @@ std::string parseIntoConfigAndReturnError( const char * (&argv)[size], Catch::Co
     return "";
 }
 
-inline Catch::TestCaseInfo makeTestCase( const char* name ){ return Catch::TestCaseInfo( NULL, "", name, "", CATCH_INTERNAL_LINEINFO ); }
+inline Catch::TestCase fakeTestCase( const char* name ){ return Catch::makeTestCase( NULL, "", name, "", CATCH_INTERNAL_LINEINFO ); }
 
-TEST_CASE( "selftest/parser/2", "ConfigData" ) {
+TEST_CASE( "Process can be configured on command line", "[config][command-line]" ) {
 
     Catch::ConfigData config;
 
-    SECTION( "default", "" ) {
+    SECTION( "default - no arguments", "" ) {
         const char* argv[] = { "test" };
         CHECK_NOTHROW( parseIntoConfig( argv, config ) );
         
         CHECK( config.shouldDebugBreak == false );
-        CHECK( config.cutoff == -1 );
-        CHECK( config.allowThrows == true );
-        CHECK( config.reporter.empty() );
+        CHECK( config.abortAfter == -1 );
+        CHECK( config.noThrow == false );
+        CHECK( config.reporterName.empty() );
     }
     
     SECTION( "test lists", "" ) {
-        SECTION( "-t/1", "Specify one test case using -t" ) {
-            const char* argv[] = { "test", "-t", "test1" };
+        SECTION( "1 test", "Specify one test case using" ) {
+            const char* argv[] = { "test", "test1" };
             CHECK_NOTHROW( parseIntoConfig( argv, config ) );
 
-            REQUIRE( config.filters.size() == 1 );
-            REQUIRE( config.filters[0].shouldInclude( makeTestCase( "notIncluded" ) ) == false );
-            REQUIRE( config.filters[0].shouldInclude( makeTestCase( "test1" ) ) );
+            Catch::Config cfg( config );
+            REQUIRE( cfg.filters().size() == 1 );
+            REQUIRE( cfg.filters()[0].shouldInclude( fakeTestCase( "notIncluded" ) ) == false );
+            REQUIRE( cfg.filters()[0].shouldInclude( fakeTestCase( "test1" ) ) );
         }
-        SECTION( "-t/exclude:1", "Specify one test case exclusion using -t exclude:" ) {
-            const char* argv[] = { "test", "-t", "exclude:test1" };
+        SECTION( "Specify one test case exclusion using exclude:", "" ) {
+            const char* argv[] = { "test", "exclude:test1" };
             CHECK_NOTHROW( parseIntoConfig( argv, config ) );
 
-            REQUIRE( config.filters.size() == 1 );
-            REQUIRE( config.filters[0].shouldInclude( makeTestCase( "test1" ) ) == false );
-            REQUIRE( config.filters[0].shouldInclude( makeTestCase( "alwaysIncluded" ) ) );
+            Catch::Config cfg( config );
+            REQUIRE( cfg.filters().size() == 1 );
+            REQUIRE( cfg.filters()[0].shouldInclude( fakeTestCase( "test1" ) ) == false );
+            REQUIRE( cfg.filters()[0].shouldInclude( fakeTestCase( "alwaysIncluded" ) ) );
         }
 
-        SECTION( "--test/1", "Specify one test case using --test" ) {
-            const char* argv[] = { "test", "--test", "test1" };
+        SECTION( "Specify one test case exclusion using ~", "" ) {
+            const char* argv[] = { "test", "~test1" };
             CHECK_NOTHROW( parseIntoConfig( argv, config ) );
 
-            REQUIRE( config.filters.size() == 1 );
-            REQUIRE( config.filters[0].shouldInclude( makeTestCase( "notIncluded" ) ) == false );
-            REQUIRE( config.filters[0].shouldInclude( makeTestCase( "test1" ) ) );
+            Catch::Config cfg( config );
+            REQUIRE( cfg.filters().size() == 1 );
+            REQUIRE( cfg.filters()[0].shouldInclude( fakeTestCase( "test1" ) ) == false );
+            REQUIRE( cfg.filters()[0].shouldInclude( fakeTestCase( "alwaysIncluded" ) ) );
         }
         
-        SECTION( "--test/exclude:1", "Specify one test case exclusion using --test exclude:" ) {
-            const char* argv[] = { "test", "--test", "exclude:test1" };
-            CHECK_NOTHROW( parseIntoConfig( argv, config ) );
-
-            REQUIRE( config.filters.size() == 1 );
-            REQUIRE( config.filters[0].shouldInclude( makeTestCase( "test1" ) ) == false );
-            REQUIRE( config.filters[0].shouldInclude( makeTestCase( "alwaysIncluded" ) ) );
-        }
-
-        SECTION( "--test/exclude:2", "Specify one test case exclusion using --test ~" ) {
-            const char* argv[] = { "test", "--test", "~test1" };
-            CHECK_NOTHROW( parseIntoConfig( argv, config ) );
-
-            REQUIRE( config.filters.size() == 1 );
-            REQUIRE( config.filters[0].shouldInclude( makeTestCase( "test1" ) ) == false );
-            REQUIRE( config.filters[0].shouldInclude( makeTestCase( "alwaysIncluded" ) ) );
-        }
-        
-        SECTION( "-t/2", "Specify two test cases using -t" ) {
+        SECTION( "Specify two test cases using -t", "" ) {
             const char* argv[] = { "test", "-t", "test1", "test2" };
             CHECK_NOTHROW( parseIntoConfig( argv, config ) );
 
-            REQUIRE( config.filters.size() == 1 );
-            REQUIRE( config.filters[0].shouldInclude( makeTestCase( "notIncluded" ) ) == false );
-            REQUIRE( config.filters[0].shouldInclude( makeTestCase( "test1" ) ) );
-            REQUIRE( config.filters[0].shouldInclude( makeTestCase( "test2" ) ) );
-        }
-
-        SECTION( "-t/0", "When no test names are supplied it is an error" ) {
-            const char* argv[] = { "test", "-t" };
-            REQUIRE_THAT( parseIntoConfigAndReturnError( argv, config ), Contains( "at least 1" ) );
+            Catch::Config cfg( config );
+            REQUIRE( cfg.filters().size() == 1 );
+            REQUIRE( cfg.filters()[0].shouldInclude( fakeTestCase( "notIncluded" ) ) == false );
+            REQUIRE( cfg.filters()[0].shouldInclude( fakeTestCase( "test1" ) ) );
+            REQUIRE( cfg.filters()[0].shouldInclude( fakeTestCase( "test2" ) ) );
         }
     }
     
     SECTION( "reporter", "" ) {
-        SECTION( "-r/basic", "" ) {
-            const char* argv[] = { "test", "-r", "basic" };
+        SECTION( "-r/console", "" ) {
+            const char* argv[] = { "test", "-r", "console" };
             CHECK_NOTHROW( parseIntoConfig( argv, config ) );
             
-            REQUIRE( config.reporter == "basic" );
+            REQUIRE( config.reporterName == "console" );
         }
         SECTION( "-r/xml", "" ) {
             const char* argv[] = { "test", "-r", "xml" };
             CHECK_NOTHROW( parseIntoConfig( argv, config ) );
             
-            REQUIRE( config.reporter == "xml" );
+            REQUIRE( config.reporterName == "xml" );
         }
         SECTION( "--reporter/junit", "" ) {
             const char* argv[] = { "test", "--reporter", "junit" };
             CHECK_NOTHROW( parseIntoConfig( argv, config ) );
             
-            REQUIRE( config.reporter == "junit" );
-        }
-        SECTION( "-r/error", "reporter config only accepts one argument" ) {
-            const char* argv[] = { "test", "-r", "one", "two" };
-            REQUIRE_THAT( parseIntoConfigAndReturnError( argv, config ), Contains( "1 argument" ) );
+            REQUIRE( config.reporterName == "junit" );
         }
     }
     
@@ -201,68 +179,52 @@ TEST_CASE( "selftest/parser/2", "ConfigData" ) {
             
             REQUIRE( config.shouldDebugBreak );
         }
-        SECTION( "-b", "break option has no arguments" ) {
-            const char* argv[] = { "test", "-b", "unexpected" };
-            REQUIRE_THAT( parseIntoConfigAndReturnError( argv, config ), Contains( "0 arguments" ) );
-        }
     }
         
     SECTION( "abort", "" ) {
-        SECTION( "-a", "" ) {
+        SECTION( "-a aborts after first failure", "" ) {
             const char* argv[] = { "test", "-a" };
             CHECK_NOTHROW( parseIntoConfig( argv, config ) );
 
-            REQUIRE( config.cutoff == 1 );
+            REQUIRE( config.abortAfter == 1 );
         }
-        SECTION( "-a/2", "" ) {
-            const char* argv[] = { "test", "-a", "2" };
+        SECTION( "-x 2 aborts after two failures", "" ) {
+            const char* argv[] = { "test", "-x", "2" };
             CHECK_NOTHROW( parseIntoConfig( argv, config ) );
 
-            REQUIRE( config.cutoff == 2 );
+            REQUIRE( config.abortAfter == 2 );
         }
-        SECTION( "-a/error/0", "" ) {
-            const char* argv[] = { "test", "-a", "0" };
+        SECTION( "-x must be greater than zero", "" ) {
+            const char* argv[] = { "test", "-x", "0" };
             REQUIRE_THAT( parseIntoConfigAndReturnError( argv, config ), Contains( "greater than zero" ) );
         }
-        SECTION( "-a/error/non numeric", "" ) {
-            const char* argv[] = { "test", "-a", "oops" };
-            REQUIRE_THAT( parseIntoConfigAndReturnError( argv, config ), Contains( "greater than zero" ) );
-        }
-        SECTION( "-a/error/two args", "cutoff only takes one argument" ) {
-            const char* argv[] = { "test", "-a", "1", "2" };
-            REQUIRE_THAT( parseIntoConfigAndReturnError( argv, config ), Contains( "0 and 1 argument" ) );
+        SECTION( "-x must be numeric", "" ) {
+            const char* argv[] = { "test", "-x", "oops" };
+            REQUIRE_THAT( parseIntoConfigAndReturnError( argv, config ), Contains( "-x" ) );
         }
     }
     
     SECTION( "nothrow", "" ) {
-        SECTION( "-nt", "" ) {
-            const char* argv[] = { "test", "-nt" };
+        SECTION( "-e", "" ) {
+            const char* argv[] = { "test", "-e" };
             CHECK_NOTHROW( parseIntoConfig( argv, config ) );
 
-            REQUIRE( config.allowThrows == false );
+            REQUIRE( config.noThrow == true );
         }
         SECTION( "--nothrow", "" ) {
             const char* argv[] = { "test", "--nothrow" };
             CHECK_NOTHROW( parseIntoConfig( argv, config ) );
 
-            REQUIRE( config.allowThrows == false );
+            REQUIRE( config.noThrow == true );
         }
     }
 
-    SECTION( "streams", "" ) {
+    SECTION( "output filename", "" ) {
         SECTION( "-o filename", "" ) {
             const char* argv[] = { "test", "-o", "filename.ext" };
             CHECK_NOTHROW( parseIntoConfig( argv, config ) );
 
             REQUIRE( config.outputFilename == "filename.ext" );
-            REQUIRE( config.stream.empty() );
-        }
-        SECTION( "-o %stdout", "" ) {
-            const char* argv[] = { "test", "-o", "%stdout" };
-            CHECK_NOTHROW( parseIntoConfig( argv, config ) );
-
-            REQUIRE( config.stream == "stdout" );
-            REQUIRE( config.outputFilename.empty() );
         }
         SECTION( "--out", "" ) {
             const char* argv[] = { "test", "--out", "filename.ext" };
@@ -273,13 +235,13 @@ TEST_CASE( "selftest/parser/2", "ConfigData" ) {
     }
 
     SECTION( "combinations", "" ) {
-        SECTION( "-a -b", "" ) {
-            const char* argv[] = { "test", "-a", "-b", "-nt" };
+        SECTION( "Single character flags can be combined", "" ) {
+            const char* argv[] = { "test", "-abe" };
             CHECK_NOTHROW( parseIntoConfig( argv, config ) );
 
-            CHECK( config.cutoff == 1 );
+            CHECK( config.abortAfter == 1 );
             CHECK( config.shouldDebugBreak );
-            CHECK( config.allowThrows == false );
+            CHECK( config.noThrow == true );
         }
     }        
 }
@@ -288,17 +250,17 @@ TEST_CASE( "selftest/test filter", "Individual filters" ) {
 
     Catch::TestCaseFilter matchAny( "*" );
     Catch::TestCaseFilter matchNone( "*", Catch::IfFilterMatches::ExcludeTests );
-    CHECK( matchAny.shouldInclude( makeTestCase( "any" ) ));
-    CHECK( matchNone.shouldInclude( makeTestCase( "any" ) ) == false );
+    CHECK( matchAny.shouldInclude( fakeTestCase( "any" ) ));
+    CHECK( matchNone.shouldInclude( fakeTestCase( "any" ) ) == false );
 
     Catch::TestCaseFilter matchHidden( "./*" );
     Catch::TestCaseFilter matchNonHidden( "./*", Catch::IfFilterMatches::ExcludeTests );
 
-    CHECK( matchHidden.shouldInclude( makeTestCase( "any" ) ) == false );
-    CHECK( matchNonHidden.shouldInclude( makeTestCase( "any" ) ) );
+    CHECK( matchHidden.shouldInclude( fakeTestCase( "any" ) ) == false );
+    CHECK( matchNonHidden.shouldInclude( fakeTestCase( "any" ) ) );
 
-    CHECK( matchHidden.shouldInclude( makeTestCase( "./any" ) ) );
-    CHECK( matchNonHidden.shouldInclude( makeTestCase( "./any" ) ) == false );
+    CHECK( matchHidden.shouldInclude( fakeTestCase( "./any" ) ) );
+    CHECK( matchNonHidden.shouldInclude( fakeTestCase( "./any" ) ) == false );
 }
 
 TEST_CASE( "selftest/test filters", "Sets of filters" ) {
@@ -309,26 +271,26 @@ TEST_CASE( "selftest/test filters", "Sets of filters" ) {
     filters.addFilter( matchHidden );
     filters.addFilter( dontMatchA );
 
-    CHECK( matchHidden.shouldInclude( makeTestCase( "./something" ) ) );
+    CHECK( matchHidden.shouldInclude( fakeTestCase( "./something" ) ) );
 
-    CHECK( filters.shouldInclude( makeTestCase( "any" ) ) == false );
-    CHECK( filters.shouldInclude( makeTestCase( "./something" ) ) );
-    CHECK( filters.shouldInclude( makeTestCase( "./anything" ) ) == false );
+    CHECK( filters.shouldInclude( fakeTestCase( "any" ) ) == false );
+    CHECK( filters.shouldInclude( fakeTestCase( "./something" ) ) );
+    CHECK( filters.shouldInclude( fakeTestCase( "./anything" ) ) == false );
 }
 
 TEST_CASE( "selftest/filter/prefix wildcard", "Individual filters with wildcards at the start" ) {
     Catch::TestCaseFilter matchBadgers( "*badger" );
 
-    CHECK( matchBadgers.shouldInclude( makeTestCase( "big badger" ) ));
-    CHECK( matchBadgers.shouldInclude( makeTestCase( "little badgers" ) ) == false );
+    CHECK( matchBadgers.shouldInclude( fakeTestCase( "big badger" ) ));
+    CHECK( matchBadgers.shouldInclude( fakeTestCase( "little badgers" ) ) == false );
 }
 TEST_CASE( "selftest/filter/wildcard at both ends", "Individual filters with wildcards at both ends" ) {
     Catch::TestCaseFilter matchBadgers( "*badger*" );
 
-    CHECK( matchBadgers.shouldInclude( makeTestCase( "big badger" ) ));
-    CHECK( matchBadgers.shouldInclude( makeTestCase( "little badgers" ) ) );
-    CHECK( matchBadgers.shouldInclude( makeTestCase( "badgers are big" ) ) );
-    CHECK( matchBadgers.shouldInclude( makeTestCase( "hedgehogs" ) ) == false );
+    CHECK( matchBadgers.shouldInclude( fakeTestCase( "big badger" ) ));
+    CHECK( matchBadgers.shouldInclude( fakeTestCase( "little badgers" ) ) );
+    CHECK( matchBadgers.shouldInclude( fakeTestCase( "badgers are big" ) ) );
+    CHECK( matchBadgers.shouldInclude( fakeTestCase( "hedgehogs" ) ) == false );
 }
 
 
@@ -337,24 +299,6 @@ int getArgc( const char * (&)[size] ) {
     return size;
 }
 
-TEST_CASE( "selftest/option parsers", "" )
-{
-    Catch::ConfigData config;
-    
-    Catch::SharedImpl<Catch::Options::TestCaseOptionParser> tcOpt;
-    Catch::OptionParser& opt = tcOpt;
-
-    const char* argv[] = { "test", "-t", "test1" };
-
-    Catch::CommandParser parser( getArgc( argv ), argv );
-
-    CHECK_NOTHROW( opt.parseIntoConfig( parser, config ) );
-
-    REQUIRE( config.filters.size() == 1 );
-    REQUIRE( config.filters[0].shouldInclude( makeTestCase( "notIncluded" ) ) == false );
-    REQUIRE( config.filters[0].shouldInclude( makeTestCase( "test1" ) ) );
-}
-
 TEST_CASE( "selftest/tags", "" ) {
 
     std::string p1 = "[one]";
@@ -364,9 +308,9 @@ TEST_CASE( "selftest/tags", "" ) {
     std::string p5 = "[one][two]~[hide],[three]";
     
     SECTION( "one tag", "" ) {
-        Catch::TestCaseInfo oneTag( NULL, "", "test", "[one]", CATCH_INTERNAL_LINEINFO );
+        Catch::TestCase oneTag = makeTestCase( NULL, "", "test", "[one]", CATCH_INTERNAL_LINEINFO );
 
-        CHECK( oneTag.getDescription() == "" );
+        CHECK( oneTag.getTestCaseInfo().description == "" );
         CHECK( oneTag.hasTag( "one" ) );
         CHECK( oneTag.getTags().size() == 1 );
 
@@ -378,11 +322,12 @@ TEST_CASE( "selftest/tags", "" ) {
     }
 
     SECTION( "two tags", "" ) {
-        Catch::TestCaseInfo twoTags( NULL, "", "test", "[one][two]", CATCH_INTERNAL_LINEINFO );
+        Catch::TestCase twoTags= makeTestCase( NULL, "", "test", "[one][two]", CATCH_INTERNAL_LINEINFO );
 
-        CHECK( twoTags.getDescription() == "" );
+        CHECK( twoTags.getTestCaseInfo().description == "" );
         CHECK( twoTags.hasTag( "one" ) );
         CHECK( twoTags.hasTag( "two" ) );
+        CHECK( twoTags.hasTag( "Two" ) );
         CHECK( twoTags.hasTag( "three" ) == false );
         CHECK( twoTags.getTags().size() == 2 );
 
@@ -395,8 +340,8 @@ TEST_CASE( "selftest/tags", "" ) {
 
     SECTION( "one tag with characters either side", "" ) {
 
-        Catch::TestCaseInfo oneTagWithExtras( NULL, "", "test", "12[one]34", CATCH_INTERNAL_LINEINFO );
-        CHECK( oneTagWithExtras.getDescription() == "1234" );
+        Catch::TestCase oneTagWithExtras = makeTestCase( NULL, "", "test", "12[one]34", CATCH_INTERNAL_LINEINFO );
+        CHECK( oneTagWithExtras.getTestCaseInfo().description == "1234" );
         CHECK( oneTagWithExtras.hasTag( "one" ) );
         CHECK( oneTagWithExtras.hasTag( "two" ) == false );
         CHECK( oneTagWithExtras.getTags().size() == 1 );
@@ -404,22 +349,213 @@ TEST_CASE( "selftest/tags", "" ) {
     
     SECTION( "start of a tag, but not closed", "" ) {
 
-        Catch::TestCaseInfo oneTagOpen( NULL, "", "test", "[one", CATCH_INTERNAL_LINEINFO );
+        Catch::TestCase oneTagOpen = makeTestCase( NULL, "", "test", "[one", CATCH_INTERNAL_LINEINFO );
 
-        CHECK( oneTagOpen.getDescription() == "[one" );
+        CHECK( oneTagOpen.getTestCaseInfo().description == "[one" );
         CHECK( oneTagOpen.hasTag( "one" ) == false );
         CHECK( oneTagOpen.getTags().size() == 0 );
     }
 
     SECTION( "hidden", "" ) {
-        Catch::TestCaseInfo oneTag( NULL, "", "test", "[hide]", CATCH_INTERNAL_LINEINFO );
+        Catch::TestCase oneTag = makeTestCase( NULL, "", "test", "[hide]", CATCH_INTERNAL_LINEINFO );
 
-        CHECK( oneTag.getDescription() == "" );
+        CHECK( oneTag.getTestCaseInfo().description == "" );
         CHECK( oneTag.hasTag( "hide" ) );
         CHECK( oneTag.isHidden() );
 
         CHECK( oneTag.matchesTags( "~[hide]" ) == false );
 
     }
+}
+
+TEST_CASE( "Long strings can be wrapped", "[wrap]" ) {
+
+    using namespace Catch;
+    SECTION( "plain string", "" ) {
+        // guide:                 123456789012345678
+        std::string testString = "one two three four";
+        
+        SECTION( "No wrapping", "" ) {
+            CHECK( Text( testString, TextAttributes().setWidth( 80 ) ).toString() == testString );
+            CHECK( Text( testString, TextAttributes().setWidth( 18 ) ).toString() == testString );
+        }
+        SECTION( "Wrapped once", "" ) {
+            CHECK( Text( testString, TextAttributes().setWidth( 17 ) ).toString() == "one two three\nfour" );
+            CHECK( Text( testString, TextAttributes().setWidth( 16 ) ).toString() == "one two three\nfour" );
+            CHECK( Text( testString, TextAttributes().setWidth( 14 ) ).toString() == "one two three\nfour" );
+            CHECK( Text( testString, TextAttributes().setWidth( 13 ) ).toString() == "one two three\nfour" );
+            CHECK( Text( testString, TextAttributes().setWidth( 12 ) ).toString() == "one two\nthree four" );
+        }
+        SECTION( "Wrapped twice", "" ) {
+            CHECK( Text( testString, TextAttributes().setWidth( 9 ) ).toString() == "one two\nthree\nfour" );
+            CHECK( Text( testString, TextAttributes().setWidth( 8 ) ).toString() == "one two\nthree\nfour" );
+            CHECK( Text( testString, TextAttributes().setWidth( 7 ) ).toString() == "one two\nthree\nfour" );
+        }
+        SECTION( "Wrapped three times", "" ) {
+            CHECK( Text( testString, TextAttributes().setWidth( 6 ) ).toString() == "one\ntwo\nthree\nfour" );
+            CHECK( Text( testString, TextAttributes().setWidth( 5 ) ).toString() == "one\ntwo\nthree\nfour" );
+        }
+        SECTION( "Short wrap", "" ) {
+            CHECK( Text( "abcdef", TextAttributes().setWidth( 4 ) ).toString() == "abc-\ndef" );
+            CHECK( Text( "abcdefg", TextAttributes().setWidth( 4 ) ).toString() == "abc-\ndefg" );
+            CHECK( Text( "abcdefgh", TextAttributes().setWidth( 4 ) ).toString() == "abc-\ndef-\ngh" );
+
+            CHECK( Text( testString, TextAttributes().setWidth( 4 ) ).toString() == "one\ntwo\nthr-\nee\nfour" );
+            CHECK( Text( testString, TextAttributes().setWidth( 3 ) ).toString() == "one\ntwo\nth-\nree\nfo-\nur" );
+        }
+        SECTION( "As container", "" ) {
+            Text text( testString, TextAttributes().setWidth( 6 ) );
+            REQUIRE( text.size() == 4 );
+            CHECK( text[0] == "one" );
+            CHECK( text[1] == "two" );
+            CHECK( text[2] == "three" );
+            CHECK( text[3] == "four" );
+        }
+        SECTION( "Indent first line differently", "" ) {
+            Text text( testString, TextAttributes()
+                                        .setWidth( 10 )
+                                        .setIndent( 4 )
+                                        .setInitialIndent( 1 ) );
+            CHECK( text.toString() == " one two\n    three\n    four" );
+        }
+        
+    }
+    
+    SECTION( "With newlines", "" ) {
+        
+        // guide:                 1234567890123456789
+        std::string testString = "one two\nthree four";
+        
+        SECTION( "No wrapping" , "" ) {
+            CHECK( Text( testString, TextAttributes().setWidth( 80 ) ).toString() == testString );
+            CHECK( Text( testString, TextAttributes().setWidth( 18 ) ).toString() == testString );
+            CHECK( Text( testString, TextAttributes().setWidth( 10 ) ).toString() == testString );
+        }
+        SECTION( "Trailing newline" , "" ) {
+            CHECK( Text( "abcdef\n", TextAttributes().setWidth( 10 ) ).toString() == "abcdef\n" );
+            CHECK( Text( "abcdef", TextAttributes().setWidth( 6 ) ).toString() == "abcdef" );
+            CHECK( Text( "abcdef\n", TextAttributes().setWidth( 6 ) ).toString() == "abcdef\n" );
+        }
+        SECTION( "Wrapped once", "" ) {
+            CHECK( Text( testString, TextAttributes().setWidth( 9 ) ).toString() == "one two\nthree\nfour" );
+            CHECK( Text( testString, TextAttributes().setWidth( 8 ) ).toString() == "one two\nthree\nfour" );
+            CHECK( Text( testString, TextAttributes().setWidth( 7 ) ).toString() == "one two\nthree\nfour" );
+        }
+        SECTION( "Wrapped twice", "" ) {
+            CHECK( Text( testString, TextAttributes().setWidth( 6 ) ).toString() == "one\ntwo\nthree\nfour" );
+        }
+    }
+    
+    SECTION( "With tabs", "" ) {
+
+        // guide:                 1234567890123456789
+        std::string testString = "one two \tthree four five six";
+        
+        CHECK( Text( testString, TextAttributes().setWidth( 15 ) ).toString()
+            == "one two three\n        four\n        five\n        six" );
+    }
+    
     
 }
+
+using namespace Catch;
+
+class ColourString {
+public:
+
+    struct ColourIndex {
+        ColourIndex( Colour::Code _colour, std::size_t _fromIndex, std::size_t _toIndex )
+        :   colour( _colour ),
+            fromIndex( _fromIndex ),
+            toIndex( _toIndex )
+        {}
+
+        Colour::Code colour;
+        std::size_t fromIndex;
+        std::size_t toIndex;
+    };
+
+    ColourString( std::string const& _string )
+    : string( _string )
+    {}
+    ColourString( std::string const& _string, std::vector<ColourIndex> const& _colours )
+    : string( _string ), colours( _colours )
+    {}
+    
+    ColourString& addColour( Colour::Code colour, int _index ) {
+        colours.push_back( ColourIndex( colour,
+                                        resolveRelativeIndex( _index ),
+                                        resolveRelativeIndex( _index )+1 ) );
+        return *this;
+    }
+    ColourString& addColour( Colour::Code colour, int _fromIndex, int _toIndex ) {
+        colours.push_back( ColourIndex( colour,
+                                        resolveRelativeIndex(_fromIndex),
+                                        resolveLastRelativeIndex( _toIndex ) ) );
+        return *this;
+    }
+    
+    void writeToStream( std::ostream& _stream ) const {
+        std::size_t last = 0;
+        for( std::size_t i = 0; i < colours.size(); ++i ) {
+            ColourIndex const& index = colours[i];
+            if( index.fromIndex > last )
+                _stream << string.substr( last, index.fromIndex-last );
+            {
+                Colour colourGuard( index.colour );
+                _stream << string.substr( index.fromIndex, index.toIndex-index.fromIndex );
+            }
+            last = index.toIndex;
+        }
+        if( last < string.size() )
+            _stream << string.substr( last );        
+    }
+    friend std::ostream& operator << ( std::ostream& _stream, ColourString const& _colourString ) {
+        _colourString.writeToStream( _stream );
+        return _stream;
+    }
+
+private:
+
+    std::size_t resolveLastRelativeIndex( int _index ) {
+        std::size_t index = resolveRelativeIndex( _index );
+        return index == 0 ? string.size() : index;
+    }
+    std::size_t resolveRelativeIndex( int _index ) {
+        return static_cast<std::size_t>( _index >= 0
+            ? _index
+            : static_cast<int>( string.size() )+_index );
+    }
+    std::string string;
+    std::vector<ColourIndex> colours;
+};
+
+// !TBD: This will be folded into Text class
+TEST_CASE( "Strings can be rendered with colour", "[colour]" ) {
+    
+    {
+        ColourString cs( "hello" );
+        cs  .addColour( Colour::Red, 0 )
+            .addColour( Colour::Green, -1 );
+
+        std::cout << cs << std::endl;
+    }
+
+    {
+        ColourString cs( "hello" );
+        cs  .addColour( Colour::Blue, 1, -2 );
+        
+        std::cout << cs << std::endl;
+    }
+    
+}
+
+TEST_CASE( "Text can be formatted using the Text class", "" ) {
+    
+    CHECK( Text( "hi there" ).toString() == "hi there" );
+    
+    TextAttributes narrow;
+    narrow.setWidth( 6 );
+    
+    CHECK( Text( "hi there", narrow ).toString() == "hi\nthere" );
+}

projects/SelfTest/TrickyTests.cpp

@@ -314,3 +314,49 @@ TEST_CASE( "./succeeding/SafeBool", "Objects that evaluated in boolean contexts
     CHECK( !False );
     CHECK_FALSE( False );
 }
+
+TEST_CASE( "Assertions then sections", "" )
+{
+    // This was causing a failure due to the way the console reporter was handling
+    // the current section
+    
+    REQUIRE( Catch::isTrue( true ) );
+    
+    SECTION( "A section", "" )
+    {
+        REQUIRE( Catch::isTrue( true ) );
+        
+        SECTION( "Another section", "" )
+        {
+            REQUIRE( Catch::isTrue( true ) );
+        }
+        SECTION( "Another other section", "" )
+        {
+            REQUIRE( Catch::isTrue( true ) );
+        }
+    }
+}
+
+struct Awkward
+{
+    operator int() const { return 7; }
+};
+
+TEST_CASE( "non streamable - with conv. op", "" )
+{
+    Awkward awkward;
+    std::string s = Catch::toString( awkward );
+    REQUIRE( s == "7" );
+}
+
+#ifdef CATCH_CONFIG_CPP11_NULLPTR
+
+#include <memory>
+
+TEST_CASE( "null_ptr", "" )
+{
+    std::unique_ptr<int> ptr;
+    REQUIRE(ptr.get() == nullptr);
+}
+
+#endif

projects/SelfTest/VariadicMacrosTests.cpp

@@ -0,0 +1,31 @@
+/*
+ *  Created by Phil on 15/03/2013.
+ *  Copyright 2013 Two Blue Cubes Ltd. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#include "catch.hpp"
+
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+
+TEST_CASE()
+{
+    SUCCEED( "anonymous test case" );
+}
+
+TEST_CASE( "Test case with one argument" )
+{
+    SUCCEED( "no assertions" );
+}
+
+TEST_CASE( "Variadic macros", "[variadic][sections]" )
+{
+    SECTION( "Section with one argument" )
+    {
+        SUCCEED( "no assertions" );
+    }
+}
+
+#endif