RubyGems - redsnow - Versions diffs - 0.3.2 → 0.3.3 - Mend

redsnow 0.3.2 → 0.3.3

Files changed (530) hide show

data/ext/snowcrash/test/vendor/Catch/projects/SelfTest/TrickyTests.cpp DELETED

@@ -1,382 +0,0 @@
-/*
- *  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)
- */
-#ifdef __clang__
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-#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 );
-    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, b = 2;
-//    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;
-    };
-}
-inline bool operator==(const A::X& lhs, const B::Y& rhs)
-{
-    return (lhs.a == rhs.a);
-}
-inline bool operator==(const B::Y& lhs, const A::X& rhs)
-{
-    return (lhs.a == rhs.a);
-}
-///////////////////////////////////////////////////////////////////////////////
-/* This, currently, does not compile with LLVM
-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 == 1u );
-    }
-}
-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 );
-}
-// Tests for a problem submitted by Ralph McArdell
-//
-// The static bool value should not need to be defined outside the
-// struct it is declared in - but when evaluating it in a deduced
-// context it appears to require the extra definition.
-// The issue was fixed by adding bool overloads to bypass the
-// templates that were deduce it.
-template <bool B>
-struct is_true
-{
-    static const bool value = B;
-};
-TEST_CASE( "./succeeding/unimplemented static bool", "static bools can be evaluated" )
-{
-    SECTION("compare to true","")
-    {
-        REQUIRE( is_true<true>::value == true );
-        REQUIRE( true == is_true<true>::value );
-    }
-    SECTION("compare to false","")
-    {
-        REQUIRE( is_true<false>::value == false );
-        REQUIRE( false == is_true<false>::value );
-    }
-    SECTION("negation", "")
-    {
-        REQUIRE( !is_true<false>::value );
-    }
-    SECTION("double negation","")
-    {
-        REQUIRE( !!is_true<true>::value );
-    }
-    SECTION("direct","")
-    {
-        REQUIRE( is_true<true>::value );
-        REQUIRE_FALSE( is_true<false>::value );
-    }
-}
-// Uncomment these tests to produce an error at test registration time
-/*
-TEST_CASE( "./sameName", "Tests with the same name are not allowed" )
-{
-}
-TEST_CASE( "./sameName", "Tests with the same name are not allowed" )
-{
-}
-*/
-struct Boolable
-{
-    explicit Boolable( bool value ) : m_value( value ) {}
-    operator Catch::SafeBool::type() const {
-        return Catch::SafeBool::makeSafe( m_value );
-    }
-    bool m_value;
-};
-TEST_CASE( "./succeeding/SafeBool", "Objects that evaluated in boolean contexts can be checked")
-{
-    Boolable True( true );
-    Boolable False( false );
-    CHECK( True );
-    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" );
-}
-inline void foo() {}
-typedef void (*fooptr_t)();
-TEST_CASE( "Comparing function pointers", "[function pointer]" )
-{
-    // This was giving a warning in VS2010
-    // #179
-    fooptr_t a = foo;
-    REQUIRE( a );
-    REQUIRE( a == &foo );
-}
-class ClassName {};
-TEST_CASE( "pointer to class", "" )
-{
-   ClassName *p = 0;
-   REQUIRE( p == 0 );
-}
-#ifdef CATCH_CONFIG_CPP11_NULLPTR
-#include <memory>
-TEST_CASE( "null_ptr", "" )
-{
-    std::unique_ptr<int> ptr;
-    REQUIRE(ptr.get() == nullptr);
-}
-#endif
-TEST_CASE( "X/level/0/a", "" ) { SUCCEED(""); }
-TEST_CASE( "X/level/0/b", "[fizz]" ) { SUCCEED(""); }
-TEST_CASE( "X/level/1/a", "" ) { SUCCEED(""); }
-TEST_CASE( "X/level/1/b", "" ) { SUCCEED("");}

data/ext/snowcrash/test/vendor/Catch/projects/SelfTest/VariadicMacrosTests.cpp DELETED

@@ -1,31 +0,0 @@
-/*
- *  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

data/ext/snowcrash/test/vendor/Catch/projects/SelfTest/catch_self_test.cpp DELETED

@@ -1,31 +0,0 @@
-/*
- *  Created by Phil on 14/02/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)
- */
-#define CATCH_CONFIG_MAIN
-#include "catch_self_test.hpp"
-namespace Catch{
-    NullStreamingReporter::~NullStreamingReporter() {}
-    Totals EmbeddedRunner::runMatching( const std::string& rawTestSpec, std::size_t groupIndex, std::size_t groupsCount, const std::string& ) {
-        std::ostringstream oss;
-        Ptr<Config> config = new Config();
-        config->setStreamBuf( oss.rdbuf() );
-        Totals totals;
-        // Scoped because RunContext doesn't report EndTesting until its destructor
-        {
-            RunContext runner( config.get(), m_reporter.get() );
-            totals = runner.runMatching( rawTestSpec, groupIndex, groupsCount );
-        }
-        return totals;
-    }
-}

data/ext/snowcrash/test/vendor/Catch/projects/SelfTest/catch_self_test.hpp DELETED

@@ -1,177 +0,0 @@
-/*
- *  Created by Phil on 14/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)
- */
-#ifndef TWOBLUECUBES_CATCH_SELF_TEST_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_SELF_TEST_HPP_INCLUDED
-#include "catch.hpp"
-// Use this external guard here as if we're using the single header version
-// this will already be defined
-#ifndef TWOBLUECUBES_CATCH_INTERFACES_REGISTRY_HUB_H_INCLUDED
-#include "catch_interfaces_registry_hub.h"
-#endif
-#include "set"
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-namespace Catch {
-    class NullStreamingReporter : public SharedImpl<IStreamingReporter> {
-    public:
-        virtual ~NullStreamingReporter();
-        static std::string getDescription() {
-            return "null reporter";
-        }
-    private: // IStreamingReporter
-        virtual ReporterPreferences getPreferences() const {
-            return ReporterPreferences();
-        }
-        virtual void noMatchingTestCases( std::string const& ) {}
-        virtual void testRunStarting( TestRunInfo const& ) {}
-        virtual void testGroupStarting( GroupInfo const& ) {}
-        virtual void testCaseStarting( TestCaseInfo const& ) {}
-        virtual void sectionStarting( SectionInfo const& ) {}
-        virtual void assertionStarting( AssertionInfo const& ) {}
-        virtual bool assertionEnded( AssertionStats const& ) { return false; }
-        virtual void sectionEnded( SectionStats const& ) {}
-        virtual void testCaseEnded( TestCaseStats const& ) {}
-        virtual void testGroupEnded( TestGroupStats const& ) {}
-        virtual void testRunEnded( TestRunStats const& ) {}
-    };
-    class EmbeddedRunner {
-    public:
-        EmbeddedRunner() : m_reporter( new NullStreamingReporter() ) {}
-        Totals runMatching( const std::string& rawTestSpec,
-                            std::size_t groupIndex,
-                            std::size_t groupsCount,
-                            const std::string& reporter = "console" );
-    private:
-        Ptr<IStreamingReporter> m_reporter;
-    };
-    class MetaTestRunner {
-    public:
-        struct Expected { enum Result {
-            ToSucceed,
-            ToFail
-        }; };
-        MetaTestRunner( Expected::Result expectedResult, std::size_t groupIndex, std::size_t groupsCount )
-        :   m_expectedResult( expectedResult ),
-            m_groupIndex( groupIndex ),
-            m_groupsCount( groupsCount )
-        {}
-        static void runMatching(    const std::string& testSpec,
-                                    Expected::Result expectedResult,
-                                    std::size_t groupIndex,
-                                    std::size_t groupsCount ) {
-            forEach(    getRegistryHub().getTestCaseRegistry().getMatchingTestCases( testSpec ),
-                        MetaTestRunner( expectedResult, groupIndex, groupsCount ) );
-        }
-        void operator()( const TestCase& testCase ) {
-            std::string name;
-            Totals totals;
-            {
-                EmbeddedRunner runner;
-                name = testCase.getTestCaseInfo().name;
-                totals = runner.runMatching( name, m_groupIndex, m_groupsCount );
-            }
-            switch( m_expectedResult ) {
-                case Expected::ToSucceed:
-                    if( totals.assertions.failed > 0 ) {
-                        FAIL( "Expected test case '"
-                             << name
-                             << "' to succeed but there was/ were "
-                             << totals.assertions.failed << " failure(s)" );
-                    }
-                    else {
-                        SUCCEED( "Tests passed, as expected" );
-                    }
-                    break;
-                case Expected::ToFail:
-                    if( totals.assertions.failed == 0 ) {
-                        FAIL( "Expected test case '"
-                             << name
-                             << "' to fail but there was/ were "
-                             << totals.assertions.passed << " success(es)" );
-                    }
-                    else {
-                        SUCCEED( "Tests failed, as expected" );
-                    }
-                    break;
-            }
-        }
-    private:
-        Expected::Result m_expectedResult;
-        std::size_t m_groupIndex;
-        std::size_t m_groupsCount;
-    };
-    struct LineInfoRegistry {
-        static LineInfoRegistry& get() {
-            static LineInfoRegistry s_instance;
-            return s_instance;
-        }
-        void registerLineInfo(  const std::string& name,
-                                const SourceLineInfo& info ) {
-            m_registry.insert( std::make_pair( name, info ) );
-        }
-        const SourceLineInfo* find( const std::string& name ) const {
-            std::map<std::string, SourceLineInfo>::const_iterator it = m_registry.find( name );
-            return it == m_registry.end() ? NULL : &(it->second);
-        }
-        const std::string infoForName( const std::string& name ) const {
-            std::map<std::string, SourceLineInfo>::const_iterator it = m_registry.find( name );
-            if( it == m_registry.end() )
-                return "";
-            std::ostringstream oss;
-            oss << it->second;
-            return oss.str();
-        }
-        std::map<std::string, SourceLineInfo> m_registry;
-    };
-    struct LineInfoRegistrar {
-        LineInfoRegistrar( const char* name, const SourceLineInfo& lineInfo ) {
-            LineInfoRegistry::get().registerLineInfo( name, lineInfo );
-        }
-    };
-}
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-#define CATCH_REGISTER_LINE_INFO( name ) ::Catch::LineInfoRegistrar INTERNAL_CATCH_UNIQUE_NAME( lineRegistrar )( name, ::Catch::SourceLineInfo( __FILE__, __LINE__ ) );
-#define CATCH_GET_LINE_INFO( name ) ::Catch::LineInfoRegistry::get().infoForName( name )
-#endif // TWOBLUECUBES_CATCH_SELF_TEST_HPP_INCLUDED