redsnow 0.3.1 → 0.3.2

data/ext/snowcrash/ext/markdown-parser/test/ext/Catch/projects/SelfTest/GeneratorTests.cpp

@@ -0,0 +1,42 @@
+/*
+ *  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)
+ */
+
+// This define means we have to prefix all the CATCH macros with CATCH_
+// We're using it here to test it out
+#define CATCH_CONFIG_PREFIX_ALL
+#include "catch.hpp"
+
+inline int multiply( int a, int b )
+{
+    return a*b;
+}
+
+CATCH_TEST_CASE( "Generators over two ranges", "[generators]" )
+{
+    using namespace Catch::Generators;
+    
+    int i = CATCH_GENERATE( between( 1, 5 ).then( values( 15, 20, 21 ).then( 36 ) ) );
+    int j = CATCH_GENERATE( between( 100, 107 ) );
+    
+    CATCH_REQUIRE( multiply( i, 2 ) == i*2 );
+    CATCH_REQUIRE( multiply( j, 2 ) == j*2 );
+}
+
+struct IntPair { int first, second; };
+
+CATCH_TEST_CASE( "Generator over a range of pairs", "[generators]" )
+{
+    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 );
+    
+}

data/ext/snowcrash/ext/markdown-parser/test/ext/Catch/projects/SelfTest/MessageTests.cpp

@@ -0,0 +1,121 @@
+/*
+ *  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( "INFO and WARN do not abort tests", "[messages]" )
+{
+    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( "SUCCEED counts as a test pass", "[messages]" )
+{
+    SUCCEED( "this is a " << "success" );
+}
+
+TEST_CASE( "INFO gets logged on failure", "[failing][messages][.]" )
+{
+    INFO( "this message should be logged" );
+    INFO( "so should this" );
+    int a = 2;
+    REQUIRE( a == 1 );
+}
+
+TEST_CASE( "INFO gets logged on failure, even if captured before successful assertions", "[failing][messages][.]" )
+{
+    INFO( "this message may be logged later" );
+    int a = 2;
+    CHECK( a == 2 );
+
+    INFO( "this message should be logged" );
+    
+    CHECK( a == 1 );
+
+    INFO( "and this, but later" );
+
+    CHECK( a == 0 );
+
+    INFO( "but not this" );
+
+    CHECK( a == 2 );
+}
+
+TEST_CASE( "FAIL aborts the test", "[failing][messages][.]" )
+{
+    FAIL( "This is a " << "failure" );    // This should output the message and abort
+}
+
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+TEST_CASE( "FAIL does not require an argument", "[failing][messages][.]" )
+{
+    FAIL();
+}
+TEST_CASE( "SUCCESS does not require an argument", "[messages][.]" )
+{
+   SUCCEED();
+}
+#endif
+
+TEST_CASE( "Output from all sections is reported", "[failing][messages][.]" )
+{
+    SECTION( "one", "" )
+    {
+        FAIL( "Message from section one" );
+    }
+
+    SECTION( "two", "" )
+    {
+        FAIL( "Message from section two" );
+    }
+}
+
+TEST_CASE( "Standard output from all sections is reported", "[messages]" )
+{
+    SECTION( "one", "" )
+    {
+        std::cout << "Message from section one" << std::endl;
+    }
+    
+    SECTION( "two", "" )
+    {
+        std::cout << "Message from section two" << std::endl;
+    }
+}
+
+TEST_CASE( "SCOPED_INFO is reset for each loop", "[messages][failing][.]" )
+{
+    for( int i=0; i<100; i++ )
+    {
+        SCOPED_INFO( "current counter " << i );
+        SCOPED_CAPTURE( i );
+        REQUIRE( i < 10 );
+    }
+}
+
+TEST_CASE( "The NO_FAIL macro reports a failure but does not fail the test", "[messages]" )
+{
+    CHECK_NOFAIL( 1 == 2 );
+}
+
+TEST_CASE( "just info", "[info][isolated info][messages]" )
+{
+    INFO( "this should never be seen" );
+}
+TEST_CASE( "just failure", "[fail][isolated info][.][messages]" )
+{
+    FAIL( "Previous info should not be seen" );
+}
+
+
+TEST_CASE( "sends information to INFO", "[.][failing]" )
+{
+    INFO( "hi" );
+    int i = 7;
+    CAPTURE( i );
+    REQUIRE( false );
+}

data/ext/snowcrash/ext/markdown-parser/test/ext/Catch/projects/SelfTest/MiscTests.cpp

@@ -0,0 +1,341 @@
+/*
+ *  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( "random SECTION tests", "[.][sections][failing]" )
+{
+    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( "nested SECTION tests", "[.][sections][failing]" )
+{
+    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( "more nested SECTION tests", "[sections][failing][.]" )
+{
+    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( "even more nested SECTION tests", "[sections]" )
+{
+    SECTION( "c", "" )
+    {
+        SECTION( "d (leaf)", "" )
+        {
+        }
+        
+        SECTION( "e (leaf)", "" )
+        {
+        }
+    }
+
+    SECTION( "f (leaf)", "" )
+    {
+    }
+}
+
+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 );            
+        }
+    }
+}
+
+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 );                
+    }
+}
+
+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";
+}
+
+TEST_CASE( "null strings", "" )
+{
+    REQUIRE( makeString( false ) != static_cast<char*>(NULL));
+    REQUIRE( makeString( true ) == static_cast<char*>(NULL));
+}
+
+
+inline bool testCheckedIf( bool flag )
+{
+    CHECKED_IF( flag )
+        return true;
+    else
+        return false;
+}
+
+TEST_CASE( "checkedIf", "" )
+{
+    REQUIRE( testCheckedIf( true ) );
+}
+
+TEST_CASE( "checkedIf, failing", "[failing][.]" )
+{
+    REQUIRE( testCheckedIf( false ) );
+}
+
+inline bool testCheckedElse( bool flag )
+{
+    CHECKED_ELSE( flag )
+        return false;
+    
+    return true;
+}
+
+TEST_CASE( "checkedElse", "" )
+{
+    REQUIRE( testCheckedElse( true ) );
+}
+
+TEST_CASE( "checkedElse, failing", "[failing][.]" )
+{
+    REQUIRE( testCheckedElse( false ) );
+}
+
+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
+    }
+    SECTION( "encoded chars", "these should all be encoded: &&&\"\"\"<<<&\"<<&\"" )
+    {
+        // No test
+    }
+}
+
+TEST_CASE( "send a single char to INFO", "[failing][.]" )
+{
+    INFO(3);
+    REQUIRE(false);    
+}
+
+TEST_CASE( "atomic if", "[failing][0]")
+{
+    size_t x = 0;
+    
+    if( x )
+        REQUIRE(x > 0);
+    else
+        REQUIRE(x == 0);
+}
+
+inline const char* testStringForMatching()
+{
+    return "this string contains 'abc' as a substring";
+}
+
+TEST_CASE("String matchers", "[matchers]" )
+{
+    REQUIRE_THAT( testStringForMatching(), Contains( "string" ) );    
+    CHECK_THAT( testStringForMatching(), Contains( "abc" ) );
+
+    CHECK_THAT( testStringForMatching(), StartsWith( "this" ) );
+    CHECK_THAT( testStringForMatching(), EndsWith( "substring" ) );
+}
+
+TEST_CASE("Contains string matcher", "[.][failing][matchers]")
+{
+    CHECK_THAT( testStringForMatching(), Contains( "not there" ) );
+}
+
+TEST_CASE("StartsWith string matcher", "[.][failing][matchers]")
+{
+    CHECK_THAT( testStringForMatching(), StartsWith( "string" ) );
+}
+
+TEST_CASE("EndsWith string matcher", "[.][failing][matchers]")
+{
+    CHECK_THAT( testStringForMatching(), EndsWith( "this" ) );
+}
+
+TEST_CASE("Equals string matcher", "[.][failing][matchers]")
+{
+    CHECK_THAT( testStringForMatching(), Equals( "something else" ) );
+}
+TEST_CASE("Equals string matcher, with NULL", "[matchers]")
+{
+    REQUIRE_THAT("", Equals(NULL));
+}
+TEST_CASE("AllOf matcher", "[matchers]")
+{
+    CHECK_THAT( testStringForMatching(), AllOf( Catch::Contains( "string" ), Catch::Contains( "abc" ) ) );
+}
+TEST_CASE("AnyOf matcher", "[matchers]")
+{
+    CHECK_THAT( testStringForMatching(), AnyOf( Catch::Contains( "string" ), Catch::Contains( "not there" ) ) );
+    CHECK_THAT( testStringForMatching(), AnyOf( Catch::Contains( "not there" ), Catch::Contains( "string" ) ) );
+}
+
+TEST_CASE("Equals", "[matchers]")
+{
+    CHECK_THAT( testStringForMatching(), Equals( "this string contains 'abc' as a substring" ) );
+}
+
+inline unsigned int Factorial( unsigned int number )
+{
+//  return number <= 1 ? number : Factorial(number-1)*number;
+  return number > 1 ? Factorial(number-1)*number : 1;
+}
+
+TEST_CASE( "Factorials are computed", "[factorial]" ) {
+  REQUIRE( Factorial(0) == 1 );
+  REQUIRE( Factorial(1) == 1 );
+  REQUIRE( Factorial(2) == 2 );
+  REQUIRE( Factorial(3) == 6 );
+  REQUIRE( Factorial(10) == 3628800 );
+}
+
+TEST_CASE( "An empty test with no assertions", "[empty]" )
+{
+}
+
+TEST_CASE( "Nice descriptive name", "[tag1][tag2][tag3][.]" )
+{
+    WARN( "This one ran" );
+}
+TEST_CASE( "first tag", "[tag1]" )
+{
+}
+TEST_CASE( "second tag", "[tag2]" )
+{
+}
+//
+//TEST_CASE( "spawn a new process", "[.]" )
+//{
+//    // !TBD Work in progress
+//    char line[200];
+//    FILE* output = popen("./CatchSelfTest ./failing/matchers/StartsWith", "r");
+//    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("A couple of nested sections followed by a failure", "[failing][.]")
+{
+    SECTION("Outer", "")
+        SECTION("Inner", "")
+            SUCCEED("that's not flying - that's failing in style");
+
+    FAIL("to infinity and beyond");
+}
+
+TEST_CASE("not allowed", "[!throws]")
+{
+    // This test case should not be included if you run with -e on the command line
+    SUCCEED();
+}