Merged from develop branchv1.3.0

- now v1.3.0

1 files changed, 122 insertions, 30 deletions

diff --git a/projects/SelfTest/MiscTests.cpp b/projects/SelfTest/MiscTests.cpp
index 86bd4f39..cf7f48cf 100644
--- a/projects/SelfTest/MiscTests.cpp
+++ b/projects/SelfTest/MiscTests.cpp
@@ -8,17 +8,20 @@
 
 #include "catch.hpp"
 
-#include <iostream>
-
 #ifdef __clang__
-#pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
+#   pragma clang diagnostic ignored "-Wc++98-compat"
+#   pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
 #endif
 
+#include "../include/internal/catch_xmlwriter.hpp"
+
+#include <iostream>
+
 TEST_CASE( "random SECTION tests", "[.][sections][failing]" )
 {
     int a = 1;
     int b = 2;
-    
+
     SECTION( "s1", "doesn't equal" )
     {
         REQUIRE( a != b );
@@ -35,7 +38,7 @@ TEST_CASE( "nested SECTION tests", "[.][sections][failing]" )
 {
     int a = 1;
     int b = 2;
-    
+
     SECTION( "s1", "doesn't equal" )
     {
         REQUIRE( a != b );
@@ -52,7 +55,7 @@ TEST_CASE( "more nested SECTION tests", "[sections][failing][.]" )
 {
     int a = 1;
     int b = 2;
-    
+
     SECTION( "s1", "doesn't equal" )
     {
         SECTION( "s2", "equal" )
@@ -77,29 +80,32 @@ TEST_CASE( "even more nested SECTION tests", "[sections]" )
     {
         SECTION( "d (leaf)", "" )
         {
+            SUCCEED(""); // avoid failing due to no tests
         }
-        
+
         SECTION( "e (leaf)", "" )
         {
+            SUCCEED(""); // avoid failing due to no tests
         }
     }
 
     SECTION( "f (leaf)", "" )
     {
+        SUCCEED(""); // avoid failing due to no tests
     }
 }
 
 TEST_CASE( "looped SECTION tests", "[.][failing][sections]" )
 {
     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 );            
+            CHECK( b > a );
         }
     }
 }
@@ -107,30 +113,30 @@ TEST_CASE( "looped SECTION tests", "[.][failing][sections]" )
 TEST_CASE( "looped tests", "[.][failing]" )
 {
     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 );                
+        CHECK( ( fib[i] % 2 ) == 0 );
     }
 }
 
 TEST_CASE( "Sends stuff to stdout and stderr", "[.]" )
 {
     std::cout << "A string sent directly to stdout" << std::endl;
-    
+
     std::cerr << "A string sent directly to stderr" << std::endl;
 }
 
 inline const char* makeString( bool makeNull )
 {
-    return makeNull ? NULL : "valid string";
+    return makeNull ? CATCH_NULL : "valid string";
 }
 
 TEST_CASE( "null strings", "" )
 {
-    REQUIRE( makeString( false ) != static_cast<char*>(NULL));
-    REQUIRE( makeString( true ) == static_cast<char*>(NULL));
+    REQUIRE( makeString( false ) != static_cast<char*>(CATCH_NULL));
+    REQUIRE( makeString( true ) == static_cast<char*>(CATCH_NULL));
 }
 
 
@@ -156,7 +162,7 @@ inline bool testCheckedElse( bool flag )
 {
     CHECKED_ELSE( flag )
         return false;
-    
+
     return true;
 }
 
@@ -174,24 +180,24 @@ TEST_CASE( "xmlentitycheck", "" )
 {
     SECTION( "embedded xml", "<test>it should be possible to embed xml characters, such as <, \" or &, or even whole <xml>documents</xml> within an attribute</test>" )
     {
-        // No test
+        SUCCEED(""); // We need this here to stop it failing due to no tests
     }
     SECTION( "encoded chars", "these should all be encoded: &&&\"\"\"<<<&\"<<&\"" )
     {
-        // No test
+        SUCCEED(""); // We need this here to stop it failing due to no tests
     }
 }
 
 TEST_CASE( "send a single char to INFO", "[failing][.]" )
 {
     INFO(3);
-    REQUIRE(false);    
+    REQUIRE(false);
 }
 
 TEST_CASE( "atomic if", "[failing][0]")
 {
     size_t x = 0;
-    
+
     if( x )
         REQUIRE(x > 0);
     else
@@ -202,10 +208,16 @@ inline const char* testStringForMatching()
 {
     return "this string contains 'abc' as a substring";
 }
+inline const char* testStringForMatching2()
+{
+    return "some completely different text that contains one common word";
+}
+
+using namespace Catch::Matchers;
 
 TEST_CASE("String matchers", "[matchers]" )
 {
-    REQUIRE_THAT( testStringForMatching(), Contains( "string" ) );    
+    REQUIRE_THAT( testStringForMatching(), Contains( "string" ) );
     CHECK_THAT( testStringForMatching(), Contains( "abc" ) );
 
     CHECK_THAT( testStringForMatching(), StartsWith( "this" ) );
@@ -233,7 +245,7 @@ TEST_CASE("Equals string matcher", "[.][failing][matchers]")
 }
 TEST_CASE("Equals string matcher, with NULL", "[matchers]")
 {
-    REQUIRE_THAT("", Equals(NULL));
+    REQUIRE_THAT("", Equals(CATCH_NULL));
 }
 TEST_CASE("AllOf matcher", "[matchers]")
 {
@@ -250,6 +262,42 @@ TEST_CASE("Equals", "[matchers]")
     CHECK_THAT( testStringForMatching(), Equals( "this string contains 'abc' as a substring" ) );
 }
 
+TEST_CASE("Matchers can be (AllOf) composed with the && operator", "[matchers][operators][operator&&]")
+{
+    CHECK_THAT( testStringForMatching(),
+           Contains( "string" ) &&
+           Contains( "abc" ) &&
+           Contains( "substring" ) &&
+           Contains( "contains" ) );
+}
+
+TEST_CASE("Matchers can be (AnyOf) composed with the || operator", "[matchers][operators][operator||]")
+{
+    CHECK_THAT( testStringForMatching(), Contains( "string" ) || Contains( "different" ) || Contains( "random" ) );
+    CHECK_THAT( testStringForMatching2(), Contains( "string" ) || Contains( "different" ) || Contains( "random" ) );
+}
+
+TEST_CASE("Matchers can be composed with both && and ||", "[matchers][operators][operator||][operator&&]")
+{
+    CHECK_THAT( testStringForMatching(), ( Contains( "string" ) || Contains( "different" ) ) && Contains( "substring" ) );
+}
+
+TEST_CASE("Matchers can be composed with both && and || - failing", "[matchers][operators][operator||][operator&&][.failing]")
+{
+    CHECK_THAT( testStringForMatching(), ( Contains( "string" ) || Contains( "different" ) ) && Contains( "random" ) );
+}
+
+TEST_CASE("Matchers can be negated (Not) with the ! operator", "[matchers][operators][not]")
+{
+    CHECK_THAT( testStringForMatching(), !Contains( "different" ) );
+}
+
+TEST_CASE("Matchers can be negated (Not) with the ! operator - failing", "[matchers][operators][not][.failing]")
+{
+    CHECK_THAT( testStringForMatching(), !Contains( "substring" ) );
+}
+
+
 inline unsigned int Factorial( unsigned int number )
 {
 //  return number <= 1 ? number : Factorial(number-1)*number;
@@ -291,38 +339,38 @@ TEST_CASE( "second tag", "[tag2]" )
 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 );
     }
@@ -381,6 +429,50 @@ TEST_CASE( "toString on wchar_t returns the string contents", "[toString]" ) {
 	CHECK( result == "\"wide load\"" );
 }
 
+inline std::string encode( std::string const& str, Catch::XmlEncode::ForWhat forWhat = Catch::XmlEncode::ForTextNodes ) {
+    std::ostringstream oss;
+    oss << Catch::XmlEncode( str, forWhat );
+    return oss.str();
+}
+
+TEST_CASE( "XmlEncode" ) {
+    SECTION( "normal string" ) {
+        REQUIRE( encode( "normal string" ) == "normal string" );
+    }
+    SECTION( "empty string" ) {
+        REQUIRE( encode( "" ) == "" );
+    }
+    SECTION( "string with ampersand" ) {
+        REQUIRE( encode( "smith & jones" ) == "smith &amp; jones" );
+    }
+    SECTION( "string with less-than" ) {
+        REQUIRE( encode( "smith < jones" ) == "smith &lt; jones" );
+    }
+    SECTION( "string with greater-than" ) {
+        REQUIRE( encode( "smith > jones" ) == "smith > jones" );
+        REQUIRE( encode( "smith ]]> jones" ) == "smith ]]&gt; jones" );
+    }
+    SECTION( "string with quotes" ) {
+        std::string stringWithQuotes = "don't \"quote\" me on that";
+        REQUIRE( encode( stringWithQuotes ) == stringWithQuotes );
+        REQUIRE( encode( stringWithQuotes, Catch::XmlEncode::ForAttributes ) == "don't &quot;quote&quot; me on that" );
+    }
+    SECTION( "string with control char (1)" ) {
+        REQUIRE( encode( "[\x01]" ) == "[&#x1]" );
+    }
+    SECTION( "string with control char (x7F)" ) {
+        REQUIRE( encode( "[\x7F]" ) == "[&#x7F]" );
+    }
+}
+
+#ifdef CATCH_CONFIG_CPP11_LONG_LONG
+TEST_CASE( "long long" ) {
+    long long l = std::numeric_limits<long long>::max();
+
+    REQUIRE( l == std::numeric_limits<long long>::max() );
+}
+#endif
+
 //TEST_CASE( "Divide by Zero signal handler", "[.][sig]" ) {
 //    int i = 0;
 //    int x = 10/i; // This should cause the signal to fire