Re-org

projects/SelfTest/ClassTests.cpp

@@ -0,0 +1,61 @@
+/*
+ *  ClassTests.cpp
+ *  Catch - Test
+ *
+ *  Created by Phil on 09/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"
+
+namespace
+{
+    class TestClass
+    {
+        std::string s;
+        
+    public:
+        TestClass()
+        : s( "hello" )
+        {}
+        
+        void succeedingCase()
+        {            
+            REQUIRE( s == "hello" );
+        }
+        void failingCase()
+        {            
+            REQUIRE( s == "world" );
+        }
+    };
+}
+
+
+METHOD_AS_TEST_CASE( TestClass::succeedingCase, "./succeeding/TestClass/succeedingCase", "A method based test run that succeeds" )
+METHOD_AS_TEST_CASE( TestClass::failingCase, "./failing/TestClass/failingCase", "A method based test run that fails" )
+
+
+struct Fixture
+{
+    Fixture() : m_a( 1 ) {}
+    
+    int m_a;
+};
+
+TEST_CASE_METHOD( Fixture, "./succeeding/Fixture/succeedingCase", "A method based test run that succeeds" )
+{   
+    REQUIRE( m_a == 1 );        
+}
+
+// We should be able to write our tests within a different namespace
+namespace Inner
+{
+    TEST_CASE_METHOD( Fixture, "./failing/Fixture/failingCase", "A method based test run that fails" )
+    {   
+        REQUIRE( m_a == 2 );        
+    }
+}

projects/SelfTest/ConditionTests.cpp

@@ -0,0 +1,267 @@
+/*
+ *  ConditionTests.cpp
+ *  Catch - Test
+ *
+ *  Created by Phil on 08/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"
+
+#include <string>
+#include <limits>
+
+struct TestData
+{
+    TestData()
+    :   int_seven( 7 ),
+        str_hello( "hello" ),
+        float_nine_point_one( 9.1f ),
+        double_pi( 3.1415926535 )
+    {}
+    
+    int int_seven;
+    std::string str_hello;
+    float float_nine_point_one;
+    double double_pi;
+};
+
+// The "failing" tests all use the CHECK macro, which continues if the specific test fails.
+// This allows us to see all results, even if an earlier check fails
+
+// Equality tests
+TEST_CASE(  "./succeeding/conditions/equality", 
+            "Equality checks that should succeed" )
+{
+    TestData data;
+    
+    REQUIRE( data.int_seven == 7 );
+    REQUIRE( data.float_nine_point_one == Approx( 9.1f ) );
+    REQUIRE( data.double_pi == Approx( 3.1415926535 ) );
+    REQUIRE( data.str_hello == "hello" );
+    REQUIRE( data.str_hello.size() == 5 );
+
+    double x = 1.1 + 0.1 + 0.1;
+    REQUIRE( x == Approx( 1.3 ) );
+}
+
+TEST_CASE(  "./failing/conditions/equality", 
+            "Equality checks that should fail" )
+{
+    TestData data;
+    
+    CHECK( data.int_seven == 6 );
+    CHECK( data.int_seven == 8 );
+    CHECK( data.int_seven == 0 );
+    CHECK( data.float_nine_point_one == Approx( 9.11f ) );
+    CHECK( data.float_nine_point_one == Approx( 9.0f ) );
+    CHECK( data.float_nine_point_one == Approx( 1 ) );
+    CHECK( data.float_nine_point_one == Approx( 0 ) );
+    CHECK( data.double_pi == Approx( 3.1415 ) );
+    CHECK( data.str_hello == "goodbye" );
+    CHECK( data.str_hello == "hell" );
+    CHECK( data.str_hello == "hello1" );
+    CHECK( data.str_hello.size() == 6 );
+
+    double x = 1.1 + 0.1 + 0.1;
+    CHECK( x == Approx( 1.301 ) );
+}
+
+TEST_CASE(  "./succeeding/conditions/inequality", 
+            "Inequality checks that should succeed" )
+{
+    TestData data;
+    
+    REQUIRE( data.int_seven != 6 );
+    REQUIRE( data.int_seven != 8 );
+    REQUIRE( data.float_nine_point_one != Approx( 9.11f ) );
+    REQUIRE( data.float_nine_point_one != Approx( 9.0f ) );
+    REQUIRE( data.float_nine_point_one != Approx( 1 ) );
+    REQUIRE( data.float_nine_point_one != Approx( 0 ) );
+    REQUIRE( data.double_pi != Approx( 3.1415 ) );
+    REQUIRE( data.str_hello != "goodbye" );
+    REQUIRE( data.str_hello != "hell" );
+    REQUIRE( data.str_hello != "hello1" );
+    REQUIRE( data.str_hello.size() != 6 );
+}
+
+TEST_CASE(  "./failing/conditions/inequality", 
+            "Inequality checks that should fails" )
+{
+    TestData data;
+    
+    CHECK( data.int_seven != 7 );
+    CHECK( data.float_nine_point_one != Approx( 9.1f ) );
+    CHECK( data.double_pi != Approx( 3.1415926535 ) );
+    CHECK( data.str_hello != "hello" );
+    CHECK( data.str_hello.size() != 5 );
+}
+
+// Ordering comparison tests
+TEST_CASE(  "./succeeding/conditions/ordered", 
+            "Ordering comparison checks that should succeed" )
+{
+    TestData data;
+    
+    REQUIRE( data.int_seven < 8 );
+    REQUIRE( data.int_seven > 6 );
+    REQUIRE( data.int_seven > 0 );
+    REQUIRE( data.int_seven > -1 );
+
+    REQUIRE( data.int_seven >= 7 );
+    REQUIRE( data.int_seven >= 6 );
+    REQUIRE( data.int_seven <= 7 );
+    REQUIRE( data.int_seven <= 8 );
+    
+    REQUIRE( data.float_nine_point_one > 9 );
+    REQUIRE( data.float_nine_point_one < 10 );
+    REQUIRE( data.float_nine_point_one < 9.2 );
+    
+    REQUIRE( data.str_hello <= "hello" );
+    REQUIRE( data.str_hello >= "hello" );
+    
+    REQUIRE( data.str_hello < "hellp" );
+    REQUIRE( data.str_hello < "zebra" );
+    REQUIRE( data.str_hello > "hellm" );
+    REQUIRE( data.str_hello > "a" );
+}
+
+TEST_CASE(  "./failing/conditions/ordered", 
+            "Ordering comparison checks that should fail" )
+{
+    TestData data;
+    
+    CHECK( data.int_seven > 7 );
+    CHECK( data.int_seven < 7 );
+    CHECK( data.int_seven > 8 );
+    CHECK( data.int_seven < 6 );
+    CHECK( data.int_seven < 0 );
+    CHECK( data.int_seven < -1 );
+
+    CHECK( data.int_seven >= 8 );
+    CHECK( data.int_seven <= 6 );
+    
+    CHECK( data.float_nine_point_one < 9 );
+    CHECK( data.float_nine_point_one > 10 );
+    CHECK( data.float_nine_point_one > 9.2 );
+    
+    CHECK( data.str_hello > "hello" );
+    CHECK( data.str_hello < "hello" );
+    CHECK( data.str_hello > "hellp" );
+    CHECK( data.str_hello > "z" );
+    CHECK( data.str_hello < "hellm" );
+    CHECK( data.str_hello < "a" );
+
+    CHECK( data.str_hello >= "z" );
+    CHECK( data.str_hello <= "a" );
+}
+
+// Comparisons with int literals
+TEST_CASE(  "./succeeding/conditions/int literals", 
+            "Comparisons with int literals don't warn when mixing signed/ unsigned" )
+{
+    int i = 1;
+    unsigned int ui = 2;
+    long l = 3;
+    unsigned long ul = 4;
+    char c = 5;
+    unsigned char uc = 6;
+    
+    REQUIRE( i == 1 );
+    REQUIRE( ui == 2 );
+    REQUIRE( l == 3 );
+    REQUIRE( ul == 4 );
+    REQUIRE( c == 5 );
+    REQUIRE( uc == 6 );
+
+    REQUIRE( 1 == i );
+    REQUIRE( 2 == ui );
+    REQUIRE( 3 == l );
+    REQUIRE( 4 == ul );
+    REQUIRE( 5 == c );
+    REQUIRE( 6 == uc );
+
+    REQUIRE( (std::numeric_limits<unsigned long>::max)() > ul );
+}
+
+// These are not built normally to avoid warnings about signed/ unsigned
+#ifdef ALLOW_TESTS_THAT_WARN
+TEST_CASE(  "succeeding/conditions/negative ints", 
+            "Comparisons between unsigned ints and negative signed ints match c++ standard behaviour" )
+{
+    CHECK( ( -1 > 2u ) );
+    CHECK( -1 > 2u );
+
+    CHECK( ( 2u < -1 ) );
+    CHECK( 2u < -1 );
+
+    const int minInt = (std::numeric_limits<int>::min)();
+    CHECK( ( minInt > 2u ) );
+    CHECK( minInt > 2u );
+}
+#endif
+
+TEST_CASE(  "./succeeding/conditions/ptr", 
+            "Pointers can be compared to null" )
+{
+    TestData* p = NULL;
+    TestData* pNULL = NULL;
+    
+    REQUIRE( p == NULL );
+    REQUIRE( p == pNULL );
+    
+    TestData data;
+    p = &data;
+    
+    REQUIRE( p != NULL );
+
+    const TestData* cp = p;
+    REQUIRE( cp != NULL );
+
+    const TestData* const cpc = p;
+    REQUIRE( cpc != NULL );
+
+//    REQUIRE( NULL != p ); // gives warning, but should compile and run ok
+}
+
+// Not (!) tests
+// The problem with the ! operator is that it has right-to-left associativity.
+// This means we can't isolate it when we decompose. The simple REQUIRE( !false ) form, therefore,
+// cannot have the operand value extracted. The test will work correctly, and the situation
+// is detected and a warning issued.
+// An alternative form of the macros (CHECK_FALSE and REQUIRE_FALSE) can be used instead to capture
+// the operand value.
+TEST_CASE(  "./succeeding/conditions/not", 
+            "'Not' checks that should succeed" )
+{
+    bool falseValue = false;
+    
+    REQUIRE( !false );
+    REQUIRE_FALSE( false );
+
+    REQUIRE( !falseValue );
+    REQUIRE_FALSE( falseValue );
+
+    REQUIRE( !(1 == 2) );
+    REQUIRE_FALSE( 1 == 2 );
+}
+
+TEST_CASE(  "./failing/conditions/not", 
+            "'Not' checks that should fail" )
+{
+    bool trueValue = true;
+    
+    CHECK( !true );
+    CHECK_FALSE( true );
+    
+    CHECK( !trueValue );
+    CHECK_FALSE( trueValue );
+    
+    CHECK( !(1 == 1) );
+    CHECK_FALSE( 1 == 1 );
+}
+

projects/SelfTest/ExceptionTests.cpp

@@ -0,0 +1,122 @@
+/*
+ *  ExceptionTests.cpp
+ *  Catch - Test
+ *
+ *  Created by Phil on 09/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"
+
+#include <string>
+#include <stdexcept>
+
+namespace
+{
+    ATTRIBUTE_NORETURN
+    int thisThrows();
+    
+    int thisThrows()
+    {
+        throw std::domain_error( "expected exception" );
+        /*NOTREACHED*/    
+    }
+
+    int thisDoesntThrow()
+    {
+        return 0;
+    }
+}
+
+TEST_CASE( "./succeeding/exceptions/explicit", "When checked exceptions are thrown they can be expected or unexpected" )
+{
+    REQUIRE_THROWS_AS( thisThrows(), std::domain_error );
+    REQUIRE_NOTHROW( thisDoesntThrow() );
+    REQUIRE_THROWS( thisThrows() );
+}
+
+TEST_CASE( "./failing/exceptions/explicit", "When checked exceptions are thrown they can be expected or unexpected" )
+{
+    CHECK_THROWS_AS( thisThrows(), std::string );
+    CHECK_THROWS_AS( thisDoesntThrow(), std::domain_error );
+    CHECK_NOTHROW( thisThrows() );
+}
+
+TEST_CASE_NORETURN( "./failing/exceptions/implicit", "When unchecked exceptions are thrown they are always failures" )
+{
+    throw std::domain_error( "unexpected exception" );
+    /*NOTREACHED*/    
+}
+
+TEST_CASE( "./succeeding/exceptions/implicit", "When unchecked exceptions are thrown, but caught, they do not affect the test" )
+{
+    try
+    {
+        throw std::domain_error( "unexpected exception" );
+    }
+    catch(...)
+    {
+    }
+}
+
+class CustomException
+{
+public:
+    CustomException( const std::string& msg )
+    : m_msg( msg )
+    {}
+    
+    std::string getMessage() const
+    {
+        return m_msg;
+    }
+    
+private:
+    std::string m_msg;
+};
+
+CATCH_TRANSLATE_EXCEPTION( CustomException& ex )
+{
+    return ex.getMessage();
+}
+
+CATCH_TRANSLATE_EXCEPTION( double& ex )
+{
+    return Catch::toString( ex );
+}
+
+TEST_CASE_NORETURN( "./failing/exceptions/custom", "Unexpected custom exceptions can be translated" )
+{
+    throw CustomException( "custom exception" );
+}
+
+TEST_CASE( "./failing/exceptions/custom/nothrow", "Custom exceptions can be translated when testing for nothrow" )
+{
+    REQUIRE_NOTHROW( throw CustomException( "unexpected custom exception" ) );
+}
+
+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 );
+}
+
+
+TEST_CASE_NORETURN( "./failing/exceptions/custom/double", "Unexpected custom exceptions can be translated"  )
+{
+    throw double( 3.14 );
+}
+
+TEST_CASE( "./failing/exceptions/in-section", "Exceptions thrown from sections report file/ line or section" )
+{
+    SECTION( "the section", "" )
+    {
+        SECTION( "the section2", "" )
+        {
+            throw std::domain_error( "Exception from section" );
+        }
+    }
+}

projects/SelfTest/GeneratorTests.cpp

@@ -0,0 +1,29 @@
+/*
+ *  GeneratorTests.cpp
+ *  Catch - Test
+ *
+ *  Created by Phil on 28/01/2011.
+ *  Copyright 2011 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"
+
+size_t multiply( size_t a, size_t b )
+{
+    return a*b;
+}
+
+TEST_CASE( "./succeeding/generators/1", "Generators over two ranges" )
+{
+    using namespace Catch::Generators;
+    
+    size_t i = GENERATE( between( 1, 5 ).then( values( 15, 20, 21 ).then( 36 ) ) );
+    size_t j = GENERATE( between( 100, 107 ) );
+    
+    REQUIRE( multiply( i, 2 ) == i*2 );
+    REQUIRE( multiply( j, 2 ) == j*2 );
+}

projects/SelfTest/MessageTests.cpp

@@ -0,0 +1,51 @@
+/*
+ *  MessageTests.cpp
+ *  Catch - Test
+ *
+ *  Created by Phil on 09/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"
+
+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( "./failing/message/info/1", "INFO gets logged on failure" )
+{
+    INFO( "this message should be logged" );
+    INFO( "so should this" );
+    int a = 2;
+    REQUIRE( a == 1 );
+}
+
+TEST_CASE( "./mixed/message/info/2", "INFO gets logged on failure" )
+{
+    INFO( "this message should be logged" );
+    int a = 2;
+    CHECK( a == 2 );
+
+    INFO( "this message should be logged, too" );
+    
+    CHECK( a == 1 );
+
+    INFO( "and this, but later" );
+
+    CHECK( a == 0 );
+
+    INFO( "but not this" );
+
+    CHECK( a == 2 );
+}
+
+TEST_CASE( "./failing/message/fail", "FAIL aborts the test" )
+{
+    FAIL( "This is a " << "failure" );    // This should output the message and abort
+}

projects/SelfTest/MiscTests.cpp

@@ -0,0 +1,123 @@
+/*
+ *  MiscTests.cpp
+ *  Catch - Test
+ *
+ *  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"
+#include <iostream>
+
+TEST_CASE( "./succeeding/Misc/Sections", "random SECTION tests" )
+{
+    int a = 1;
+    int b = 2;
+    
+    SECTION( "s1", "doesn't equal" )
+    {
+        REQUIRE( a != b );
+        REQUIRE( b != a );
+    }
+
+    SECTION( "s2", "not equal" )
+    {
+        REQUIRE( a != b);
+    }
+}
+
+TEST_CASE( "./succeeding/Misc/Sections/nested", "nested SECTION tests" )
+{
+    int a = 1;
+    int b = 2;
+    
+    SECTION( "s1", "doesn't equal" )
+    {
+        REQUIRE( a != b );
+        REQUIRE( b != a );
+
+        SECTION( "s2", "not equal" )
+        {
+            REQUIRE( a != b);
+        }
+    }
+}
+
+TEST_CASE( "./mixed/Misc/Sections/nested2", "nested SECTION tests" )
+{
+    int a = 1;
+    int b = 2;
+    
+    SECTION( "s1", "doesn't equal" )
+    {
+        SECTION( "s2", "equal" )
+        {
+            REQUIRE( a == b );
+        }
+
+        SECTION( "s3", "not equal" )
+        {
+            REQUIRE( a != b );
+        }
+        SECTION( "s4", "less than" )
+        {
+            REQUIRE( a < b );
+        }
+    }
+}
+
+TEST_CASE( "./mixed/Misc/Sections/loops", "looped SECTION tests" )
+{
+    int a = 1;
+    
+    for( int b = 0; b < 10; ++b )
+    {
+        std::ostringstream oss;
+        oss << "b is currently: " << b;
+        SECTION( "s1", oss.str() )
+        {
+            CHECK( b > a );            
+        }
+    }
+}
+
+TEST_CASE( "./mixed/Misc/loops", "looped tests" )
+{
+    static const int fib[]  = { 1, 1, 2, 3, 5, 8, 13, 21 };
+    
+    for( size_t i=0; i < sizeof(fib)/sizeof(int); ++i )
+    {
+        INFO( "Testing if fib[" << i << "] (" << fib[i] << ") is even" );
+        CHECK( ( fib[i] % 2 ) == 0 );                
+    }
+}
+
+TEST_CASE( "./succeeding/Misc/stdout,stderr", "Sends stuff to stdout and stderr" )
+{
+    std::cout << "Some information";
+    
+    std::cerr << "An error";
+}
+
+const char* makeString( bool makeNull ) 
+{
+    return makeNull ? NULL : "valid string";
+}
+
+TEST_CASE( "./succeeding/Misc/null strings", "" )
+{
+    REQUIRE( makeString( false ) != static_cast<char*>(NULL));
+    REQUIRE( makeString( true ) == static_cast<char*>(NULL));
+}
+
+TEST_CASE( "./failing/info", "sends information to INFO" )
+{
+    INFO( "hi" );
+    int i = 7;
+    CAPTURE( i );
+    REQUIRE( false );
+}

projects/SelfTest/TestMain.cpp

@@ -0,0 +1,75 @@
+/*
+ *  main.cpp
+ *  Catch - Test
+ *
+ *  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)
+ *
+ */
+
+//#include "../catch_with_main.hpp"
+#include "internal/catch_self_test.hpp"
+
+#include "catch_runner.hpp"
+int main (int argc, char * const argv[])
+{
+    return Catch::Main( argc, argv );
+}
+
+TEST_CASE( "selftest/main", "Runs all Catch self tests and checks their results" )
+{
+    using namespace Catch;
+    
+    ///////////////////////////////////////////////////////////////////////////
+    SECTION(    "selftest/expected result",
+                "Tests do what they claim" )
+    {
+        SECTION(    "selftest/expected result/failing tests", 
+                    "Tests in the 'failing' branch fail" )
+        {
+            MetaTestRunner::runMatching( "./failing/*",  MetaTestRunner::Expected::ToFail );
+        }
+        
+        SECTION(    "selftest/expected result/succeeding tests", 
+                    "Tests in the 'succeeding' branch succeed" )
+        {
+            MetaTestRunner::runMatching( "./succeeding/*",  MetaTestRunner::Expected::ToSucceed );
+        }
+    }
+    
+    ///////////////////////////////////////////////////////////////////////////
+    SECTION(    "selftest/test counts", 
+                "Number of test cases that run is fixed" )
+    {
+        EmbeddedRunner runner;
+        
+        SECTION(    "selftest/test counts/succeeding tests", 
+                    "Number of 'succeeding' tests is fixed" )
+        {
+            runner.runMatching( "./succeeding/*" );
+            CHECK( runner.getSuccessCount() == 223 );
+            CHECK( runner.getFailureCount() == 0 );
+        }
+
+        SECTION(    "selftest/test counts/failing tests", 
+                    "Number of 'failing' tests is fixed" )
+        {
+            runner.runMatching( "./failing/*" );        
+            CHECK( runner.getSuccessCount() == 0 );
+            CHECK( runner.getFailureCount() == 60 );
+        }
+    }
+}
+
+TEST_CASE( "meta/Misc/Sections", "looped tests" )
+{
+    Catch::EmbeddedRunner runner;
+    
+    runner.runMatching( "./mixed/Misc/Sections/nested2" );
+    CHECK( runner.getSuccessCount() == 2 );
+    CHECK( runner.getFailureCount() == 1 );
+    
+}

projects/SelfTest/TrickyTests.cpp

@@ -0,0 +1,237 @@
+/*
+ *  TrickyTests.cpp
+ *  Catch - Test
+ *
+ *  Created by Phil on 09/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"
+
+namespace Catch
+{
+    template<>
+    std::string toString<std::pair<int, int> >( const std::pair<int, int>& value )
+    {
+        std::ostringstream oss;
+        oss << "std::pair( " << value.first << ", " << value.second << " )";
+        return oss.str();
+        
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+TEST_CASE
+(
+    "./succeeding/Tricky/std::pair", 
+    "Parsing a std::pair"
+)
+{
+    std::pair<int, int> aNicePair( 1, 2 );
+
+    // !TBD: would be nice if this could compile without the extra parentheses
+    REQUIRE( (std::pair<int, int>( 1, 2 )) == aNicePair );
+    
+}
+
+///////////////////////////////////////////////////////////////////////////////
+TEST_CASE
+(
+    "./inprogress/failing/Tricky/trailing expression", 
+    "Where the is more to the expression after the RHS"
+)
+{
+    /*
+    int a = 1;
+    int b = 2;
+
+    // This only captures part of the expression, but issues a warning about the rest
+    REQUIRE( a == 2 || b == 2 );
+     */
+    WARN( "Uncomment the code in this test to check that it gives a sensible compiler error" );
+}
+///////////////////////////////////////////////////////////////////////////////
+TEST_CASE
+(
+    "./inprogress/failing/Tricky/compound lhs", 
+    "Where the LHS is not a simple value"
+)
+{
+    /*
+    int a = 1;
+    int b = 2;
+    
+    // This only captures part of the expression, but issues a warning about the rest
+    REQUIRE( a+1 == b-1 );
+    */
+    WARN( "Uncomment the code in this test to check that it gives a sensible compiler error" );
+}
+
+struct Opaque
+{
+    int val;
+    bool operator ==( const Opaque& o ) const
+    {
+        return val == o.val;
+    }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+TEST_CASE
+(
+    "./failing/Tricky/non streamable type", 
+    "A failing expression with a non streamable type is still captured" 
+)
+{
+    
+    Opaque o1, o2;
+    o1.val = 7;
+    o2.val = 8;
+  
+    CHECK( &o1 == &o2 );
+    CHECK( o1 == o2 );
+}
+
+///////////////////////////////////////////////////////////////////////////////
+TEST_CASE
+(   
+    "./failing/string literals", 
+    "string literals of different sizes can be compared" 
+)
+{
+    REQUIRE( std::string( "first" ) == "second" );
+    
+}
+
+///////////////////////////////////////////////////////////////////////////////
+TEST_CASE
+(   
+    "./succeeding/side-effects", 
+    "An expression with side-effects should only be evaluated once" 
+)
+{
+    int i = 7;
+    
+    REQUIRE( i++ == 7 );
+    REQUIRE( i++ == 8 );
+    
+}
+
+namespace A {
+    struct X
+    {
+        X() : a(4), b(2), c(7) {}
+        X(int v) : a(v), b(2), c(7) {}
+        int a;
+        int b;
+        int c;
+    };
+}
+
+namespace B {
+    struct Y
+    {
+        Y() : a(4), b(2), c(7) {}
+        Y(int v) : a(v), b(2), c(7) {}
+        int a;
+        int b;
+        int c;
+    };
+}
+bool operator==(const A::X& lhs, const B::Y& rhs)
+{
+    return (lhs.a == rhs.a);
+}
+
+bool operator==(const B::Y& lhs, const A::X& rhs)
+{
+    return (lhs.a == rhs.a);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+TEST_CASE
+(
+    "./succeeding/koenig",
+    "Operators at different namespace levels not hijacked by Koenig lookup"
+)
+{
+    A::X x;
+    B::Y y;
+    REQUIRE( x == y );
+}
+
+
+namespace ObjectWithConversions
+{    
+    struct Object 
+    {
+        operator unsigned int() {return 0xc0000000;}
+    };
+
+    ///////////////////////////////////////////////////////////////////////////////
+    TEST_CASE
+    (
+        "./succeeding/koenig",
+        "Operators at different namespace levels not hijacked by Koenig lookup"
+    )
+    {        
+        Object o;        
+        REQUIRE(0xc0000000 == o );
+    }
+}
+
+namespace ObjectWithNonConstEqualityOperator 
+{
+    struct Test
+    {
+        Test( unsigned int v )
+        : m_value(v) 
+        {}
+        
+        bool operator==( const Test&rhs )
+        { 
+            return (m_value == rhs.m_value);
+        }
+        bool operator==( const Test&rhs ) const
+        { 
+            return (m_value != rhs.m_value);
+        }
+        unsigned int m_value;
+    };
+    
+    TEST_CASE("./succeeding/non-const==", "Demonstrate that a non-const == is not used")
+    {
+        Test t( 1 );
+        REQUIRE( t == 1 );
+    }
+}
+
+namespace EnumBitFieldTests
+{
+    enum Bits {bit0 = 0x0001, bit1 = 0x0002, bit2 = 0x0004, bit3 = 0x0008, bit1and2 = 0x0006,
+        bit30 = 0x40000000, bit31 = 0x80000000,
+        bit30and31 = 0xc0000000};
+
+    TEST_CASE("./succeeding/enum/bits", "Test enum bit values")
+    {
+        REQUIRE( 0xc0000000 == bit30and31 );
+    }
+}
+
+struct Obj
+{
+    Obj():prop(&p){}
+    
+    int p;
+    int* prop;
+};
+
+TEST_CASE("./succeeding/boolean member", "")
+{
+    Obj obj;
+    REQUIRE( obj.prop != NULL );
+}