From 6234e3d54d05982d4e01f2c77099a94a46921aa4 Mon Sep 17 00:00:00 2001 From: Uilian Ries Date: Fri, 23 Jun 2017 10:34:56 -0300 Subject: [PATCH 1/2] #926 Conan recipe for Catch single header - Insert catch.hpp (single header) to package - Copy BDDTests and TrickyTest to validate Catch package Signed-off-by: Uilian Ries --- conanfile.py | 19 ++ test_package/CMakeLists.txt | 19 ++ test_package/conanfile.py | 31 +++ test_package/src/BDDTests.cpp | 103 ++++++++ test_package/src/MainTests.cpp | 10 + test_package/src/TrickyTests.cpp | 409 +++++++++++++++++++++++++++++++ 6 files changed, 591 insertions(+) create mode 100644 conanfile.py create mode 100644 test_package/CMakeLists.txt create mode 100644 test_package/conanfile.py create mode 100644 test_package/src/BDDTests.cpp create mode 100644 test_package/src/MainTests.cpp create mode 100644 test_package/src/TrickyTests.cpp diff --git a/conanfile.py b/conanfile.py new file mode 100644 index 00000000..e891046f --- /dev/null +++ b/conanfile.py @@ -0,0 +1,19 @@ +#!/usr/bin/env python +from conans import ConanFile + + +class CatchConan(ConanFile): + name = "Catch" + version = "1.9.5" + description = "A modern, C++-native, header-only, framework for unit-tests, TDD and BDD" + author = "philsquared" + generators = "cmake" + exports_sources = "single_include/*" + url = "https://github.com/philsquared/Catch" + license = "BSL-1.0" + + def build(self): + pass + + def package(self): + self.copy(pattern="catch.hpp", src="single_include", dst="include") diff --git a/test_package/CMakeLists.txt b/test_package/CMakeLists.txt new file mode 100644 index 00000000..afc9f338 --- /dev/null +++ b/test_package/CMakeLists.txt @@ -0,0 +1,19 @@ +cmake_minimum_required(VERSION 3.0) +project(CatchTest CXX) + +# Conan setup ################################################################## +include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake) +conan_basic_setup() + +include(CTest) + +# Build Test ################################################################### +file(GLOB SOURCE_FILES ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp) + +add_executable(${CMAKE_PROJECT_NAME} ${SOURCE_FILES}) + +# Execute Test ################################################################# +enable_testing() +add_test(NAME test-single-header + WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/bin + COMMAND ${CMAKE_PROJECT_NAME}) diff --git a/test_package/conanfile.py b/test_package/conanfile.py new file mode 100644 index 00000000..f103439e --- /dev/null +++ b/test_package/conanfile.py @@ -0,0 +1,31 @@ +#!/usr/bin/env python +from os import getenv +from conans import ConanFile +from conans import CMake + + +class CatchConanTest(ConanFile): + """Build test using target package and execute all tests + """ + target = "Catch" + name = "%s-test" % target + version = "1.9.5" + description = "A modern, C++-native, header-only, framework for unit-tests, TDD and BDD" + author = "philsquared" + generators = "cmake" + settings = "os", "compiler", "arch", "build_type" + url = "https://github.com/philsquared/Catch" + license = "BSL-1.0" + username = getenv("CONAN_USERNAME", author) + channel = getenv("CONAN_CHANNEL", "testing") + requires = "%s/%s@%s/%s" % (target, version, username, channel) + + def build(self): + cmake = CMake(self) + cmake.configure(build_dir="./") + cmake.build() + + def test(self): + cmake = CMake(self) + cmake.configure(build_dir="./") + cmake.test() diff --git a/test_package/src/BDDTests.cpp b/test_package/src/BDDTests.cpp new file mode 100644 index 00000000..ed89bfbc --- /dev/null +++ b/test_package/src/BDDTests.cpp @@ -0,0 +1,103 @@ +/* + * 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 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!"); +} + +namespace { + +// a trivial fixture example to support SCENARIO_METHOD tests +struct Fixture +{ + Fixture() + : d_counter(0) + { + } + + int counter() + { + return d_counter++; + } + + int d_counter; +}; + +} + +SCENARIO_METHOD(Fixture, + "BDD tests requiring Fixtures to provide commonly-accessed data or methods", + "[bdd][fixtures]") { + const int before(counter()); + GIVEN("No operations precede me") { + REQUIRE(before == 0); + WHEN("We get the count") { + const int after(counter()); + THEN("Subsequently values are higher") { + REQUIRE(after > before); + } + } + } +} diff --git a/test_package/src/MainTests.cpp b/test_package/src/MainTests.cpp new file mode 100644 index 00000000..e5f8d3e9 --- /dev/null +++ b/test_package/src/MainTests.cpp @@ -0,0 +1,10 @@ +/* + * 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) + */ + +#define CATCH_CONFIG_MAIN +#include "catch.hpp" diff --git a/test_package/src/TrickyTests.cpp b/test_package/src/TrickyTests.cpp new file mode 100644 index 00000000..26625b03 --- /dev/null +++ b/test_package/src/TrickyTests.cpp @@ -0,0 +1,409 @@ +/* + * 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 + +#include "catch.hpp" + +#ifdef __clang__ +#pragma clang diagnostic ignored "-Wc++98-compat" +#pragma clang diagnostic ignored "-Wc++98-compat-pedantic" +#endif + +namespace Catch +{ + template<> + std::string toString >( const std::pair& value ) + { + std::ostringstream oss; + oss << "std::pair( " << value.first << ", " << value.second << " )"; + return oss.str(); + + } +} + +/////////////////////////////////////////////////////////////////////////////// +TEST_CASE +( + "Parsing a std::pair", + "[Tricky][std::pair]" +) +{ + std::pair aNicePair( 1, 2 ); + + REQUIRE( (std::pair( 1, 2 )) == aNicePair ); +} + +/////////////////////////////////////////////////////////////////////////////// +TEST_CASE +( + "Where there is more to the expression after the RHS", + "[Tricky][failing][.]" +) +{ +// 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 +( + "Where the LHS is not a simple value", + "[Tricky][failing][.]" +) +{ + /* + 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 +( + "A failing expression with a non streamable type is still captured", + "[Tricky][failing][.]" +) +{ + + Opaque o1, o2; + o1.val = 7; + o2.val = 8; + + CHECK( &o1 == &o2 ); + CHECK( o1 == o2 ); +} + +/////////////////////////////////////////////////////////////////////////////// +TEST_CASE +( + "string literals of different sizes can be compared", + "[Tricky][failing][.]" +) +{ + REQUIRE( std::string( "first" ) == "second" ); + +} + +/////////////////////////////////////////////////////////////////////////////// +TEST_CASE +( + "An expression with side-effects should only be evaluated once", + "[Tricky]" +) +{ + 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 +( + "Operators at different namespace levels not hijacked by Koenig lookup" + "[Tricky]" +) +{ + A::X x; + B::Y y; + REQUIRE( x == y ); +} +*/ + +namespace ObjectWithConversions +{ + struct Object + { + operator unsigned int() {return 0xc0000000;} + }; + + /////////////////////////////////////////////////////////////////////////////// + TEST_CASE + ( + "Operators at different namespace levels not hijacked by Koenig lookup", + "[Tricky]" + ) + { + 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("Demonstrate that a non-const == is not used", "[Tricky]" ) + { + 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( "Test enum bit values", "[Tricky]" ) + { + REQUIRE( 0xc0000000 == bit30and31 ); + } +} + +struct Obj +{ + Obj():prop(&p){} + + int p; + int* prop; +}; + +TEST_CASE("boolean member", "[Tricky]") +{ + Obj obj; + REQUIRE( obj.prop != CATCH_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 there to deduce it. +template +struct is_true +{ + static const bool value = B; +}; + +TEST_CASE( "(unimplemented) static bools can be evaluated", "[Tricky]" ) +{ + SECTION("compare to true","") + { + REQUIRE( is_true::value == true ); + REQUIRE( true == is_true::value ); + } + SECTION("compare to false","") + { + REQUIRE( is_true::value == false ); + REQUIRE( false == is_true::value ); + } + + SECTION("negation", "") + { + REQUIRE( !is_true::value ); + } + + SECTION("double negation","") + { + REQUIRE( !!is_true::value ); + } + + SECTION("direct","") + { + REQUIRE( is_true::value ); + REQUIRE_FALSE( is_true::value ); + } +} + +// Uncomment these tests to produce an error at test registration time +/* +TEST_CASE( "Tests with the same name are not allowed", "[Tricky]" ) +{ + +} +TEST_CASE( "Tests with the same name are not allowed", "[Tricky]" ) +{ + +} +*/ + +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( "Objects that evaluated in boolean contexts can be checked", "[Tricky][SafeBool]" ) +{ + Boolable True( true ); + Boolable False( false ); + + CHECK( True ); + CHECK( !False ); + CHECK_FALSE( False ); +} + +TEST_CASE( "Assertions then sections", "[Tricky]" ) +{ + // This was causing a failure due to the way the console reporter was handling + // the current section + + REQUIRE( Catch::alwaysTrue() ); + + SECTION( "A section", "" ) + { + REQUIRE( Catch::alwaysTrue() ); + + SECTION( "Another section", "" ) + { + REQUIRE( Catch::alwaysTrue() ); + } + SECTION( "Another other section", "" ) + { + REQUIRE( Catch::alwaysTrue() ); + } + } +} + +struct Awkward +{ + operator int() const { return 7; } +}; + +TEST_CASE( "non streamable - with conv. op", "[Tricky]" ) +{ + Awkward awkward; + std::string s = Catch::toString( awkward ); + REQUIRE( s == "7" ); +} + +inline void foo() {} + +typedef void (*fooptr_t)(); + +TEST_CASE( "Comparing function pointers", "[Tricky][function pointer]" ) +{ + // This was giving a warning in VS2010 + // #179 + fooptr_t a = foo; + + REQUIRE( a ); + REQUIRE( a == &foo ); +} + +struct S +{ + void f() {} +}; + + +TEST_CASE( "Comparing member function pointers", "[Tricky][member function pointer]" ) +{ + typedef void (S::*MF)(); + MF m = &S::f; + + CHECK( m == &S::f ); +} + +class ClassName {}; + +TEST_CASE( "pointer to class", "[Tricky]" ) +{ + ClassName *p = 0; + REQUIRE( p == 0 ); +} + +#ifdef CATCH_CONFIG_CPP11_NULLPTR + +#include + +TEST_CASE( "null_ptr", "[Tricky][c++11][.]" ) +{ + std::unique_ptr ptr; + REQUIRE(ptr.get() == nullptr); +} + +#endif + +TEST_CASE( "X/level/0/a", "[Tricky]" ) { SUCCEED(""); } +TEST_CASE( "X/level/0/b", "[Tricky][fizz]" ){ SUCCEED(""); } +TEST_CASE( "X/level/1/a", "[Tricky]" ) { SUCCEED(""); } +TEST_CASE( "X/level/1/b", "[Tricky]" ) { SUCCEED(""); } + +TEST_CASE( "has printf", "" ) { + + // This can cause problems as, currently, stdout itself is not redirect - only the cout (and cerr) buffer + printf( "spanner" ); +} From 34918045981bfb1cfe95741512ba3a3a61e40cd3 Mon Sep 17 00:00:00 2001 From: Uilian Ries Date: Fri, 23 Jun 2017 11:06:49 -0300 Subject: [PATCH 2/2] #926 Update Conan version by release - Update release scripts to increment Conan version Signed-off-by: Uilian Ries --- conanfile.py | 3 - scripts/developBuild.py | 3 +- scripts/majorRelease.py | 3 +- scripts/minorRelease.py | 3 +- scripts/patchRelease.py | 3 +- scripts/releaseCommon.py | 15 ++ test_package/CMakeLists.txt | 14 +- test_package/MainTest.cpp | 21 ++ test_package/conanfile.py | 18 +- test_package/src/BDDTests.cpp | 103 -------- test_package/src/MainTests.cpp | 10 - test_package/src/TrickyTests.cpp | 409 ------------------------------- 12 files changed, 49 insertions(+), 556 deletions(-) create mode 100644 test_package/MainTest.cpp delete mode 100644 test_package/src/BDDTests.cpp delete mode 100644 test_package/src/MainTests.cpp delete mode 100644 test_package/src/TrickyTests.cpp diff --git a/conanfile.py b/conanfile.py index e891046f..564b6514 100644 --- a/conanfile.py +++ b/conanfile.py @@ -12,8 +12,5 @@ class CatchConan(ConanFile): url = "https://github.com/philsquared/Catch" license = "BSL-1.0" - def build(self): - pass - def package(self): self.copy(pattern="catch.hpp", src="single_include", dst="include") diff --git a/scripts/developBuild.py b/scripts/developBuild.py index c16c8a6d..3d3f6f0a 100755 --- a/scripts/developBuild.py +++ b/scripts/developBuild.py @@ -7,5 +7,6 @@ v = Version() v.incrementBuildNumber() v.updateVersionFile() v.updateReadmeFile() +v.updateConanFile() -print( "Updated Version.hpp and README to v{0}".format( v.getVersionString() ) ) \ No newline at end of file +print( "Updated Version.hpp, README and Conan to v{0}".format( v.getVersionString() ) ) diff --git a/scripts/majorRelease.py b/scripts/majorRelease.py index f367506a..2341ecb5 100755 --- a/scripts/majorRelease.py +++ b/scripts/majorRelease.py @@ -7,5 +7,6 @@ v = Version() v.incrementMajorVersion() v.updateVersionFile() v.updateReadmeFile() +v.updateConanFile() -print( "Updated Version.hpp and README to v{0}".format( v.getVersionString() ) ) \ No newline at end of file +print( "Updated Version.hpp, README and Conan to v{0}".format( v.getVersionString() ) ) diff --git a/scripts/minorRelease.py b/scripts/minorRelease.py index ac36df96..585b7019 100755 --- a/scripts/minorRelease.py +++ b/scripts/minorRelease.py @@ -7,5 +7,6 @@ v = Version() v.incrementMinorVersion() v.updateVersionFile() v.updateReadmeFile() +v.updateConanFile() -print( "Updated Version.hpp and README to v{0}".format( v.getVersionString() ) ) \ No newline at end of file +print( "Updated Version.hpp, README and Conan to v{0}".format( v.getVersionString() ) ) diff --git a/scripts/patchRelease.py b/scripts/patchRelease.py index 878662f8..312b4d5a 100755 --- a/scripts/patchRelease.py +++ b/scripts/patchRelease.py @@ -7,5 +7,6 @@ v = Version() v.incrementPatchNumber() v.updateVersionFile() v.updateReadmeFile() +v.updateConanFile() -print( "Updated Version.hpp and README to v{0}".format( v.getVersionString() ) ) \ No newline at end of file +print( "Updated Version.hpp, README and Conan to v{0}".format( v.getVersionString() ) ) diff --git a/scripts/releaseCommon.py b/scripts/releaseCommon.py index c49f7461..16b5f199 100644 --- a/scripts/releaseCommon.py +++ b/scripts/releaseCommon.py @@ -11,6 +11,7 @@ versionParser = re.compile( r'(\s*static\sVersion\sversion)\s*\(\s*(.*)\s*,\s*(. rootPath = os.path.join( catchPath, 'include/' ) versionPath = os.path.join( rootPath, "internal/catch_version.hpp" ) readmePath = os.path.join( catchPath, "README.md" ) +conanPath = os.path.join(catchPath, 'conanfile.py') class Version: def __init__(self): @@ -86,3 +87,17 @@ class Version: line = downloadParser.sub( r''.format(self.getVersionString()) , line) f.write( line + "\n" ) + def updateConanFile(self): + conanParser = re.compile( r' version = "\d+\.\d+\.\d+.*"') + f = open( conanPath, 'r' ) + lines = [] + for line in f: + m = conanParser.match( line ) + if m: + lines.append( ' version = "{0}"'.format(format(self.getVersionString())) ) + else: + lines.append( line.rstrip() ) + f.close() + f = open( conanPath, 'w' ) + for line in lines: + f.write( line + "\n" ) diff --git a/test_package/CMakeLists.txt b/test_package/CMakeLists.txt index afc9f338..339facbf 100644 --- a/test_package/CMakeLists.txt +++ b/test_package/CMakeLists.txt @@ -1,19 +1,7 @@ cmake_minimum_required(VERSION 3.0) project(CatchTest CXX) -# Conan setup ################################################################## include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake) conan_basic_setup() -include(CTest) - -# Build Test ################################################################### -file(GLOB SOURCE_FILES ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp) - -add_executable(${CMAKE_PROJECT_NAME} ${SOURCE_FILES}) - -# Execute Test ################################################################# -enable_testing() -add_test(NAME test-single-header - WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/bin - COMMAND ${CMAKE_PROJECT_NAME}) +add_executable(${CMAKE_PROJECT_NAME} MainTest.cpp) diff --git a/test_package/MainTest.cpp b/test_package/MainTest.cpp new file mode 100644 index 00000000..b8ed744e --- /dev/null +++ b/test_package/MainTest.cpp @@ -0,0 +1,21 @@ +/* + * 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) + */ +#define CATCH_CONFIG_MAIN +#include "catch.hpp" + +unsigned int Factorial( unsigned int 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 ); +} diff --git a/test_package/conanfile.py b/test_package/conanfile.py index f103439e..9444b737 100644 --- a/test_package/conanfile.py +++ b/test_package/conanfile.py @@ -1,24 +1,16 @@ #!/usr/bin/env python from os import getenv +from os import path from conans import ConanFile from conans import CMake class CatchConanTest(ConanFile): - """Build test using target package and execute all tests - """ - target = "Catch" - name = "%s-test" % target - version = "1.9.5" - description = "A modern, C++-native, header-only, framework for unit-tests, TDD and BDD" - author = "philsquared" generators = "cmake" settings = "os", "compiler", "arch", "build_type" - url = "https://github.com/philsquared/Catch" - license = "BSL-1.0" - username = getenv("CONAN_USERNAME", author) + username = getenv("CONAN_USERNAME", "philsquared") channel = getenv("CONAN_CHANNEL", "testing") - requires = "%s/%s@%s/%s" % (target, version, username, channel) + requires = "Catch/1.9.5@%s/%s" % (username, channel) def build(self): cmake = CMake(self) @@ -26,6 +18,4 @@ class CatchConanTest(ConanFile): cmake.build() def test(self): - cmake = CMake(self) - cmake.configure(build_dir="./") - cmake.test() + self.run(path.join("bin", "CatchTest")) diff --git a/test_package/src/BDDTests.cpp b/test_package/src/BDDTests.cpp deleted file mode 100644 index ed89bfbc..00000000 --- a/test_package/src/BDDTests.cpp +++ /dev/null @@ -1,103 +0,0 @@ -/* - * 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 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!"); -} - -namespace { - -// a trivial fixture example to support SCENARIO_METHOD tests -struct Fixture -{ - Fixture() - : d_counter(0) - { - } - - int counter() - { - return d_counter++; - } - - int d_counter; -}; - -} - -SCENARIO_METHOD(Fixture, - "BDD tests requiring Fixtures to provide commonly-accessed data or methods", - "[bdd][fixtures]") { - const int before(counter()); - GIVEN("No operations precede me") { - REQUIRE(before == 0); - WHEN("We get the count") { - const int after(counter()); - THEN("Subsequently values are higher") { - REQUIRE(after > before); - } - } - } -} diff --git a/test_package/src/MainTests.cpp b/test_package/src/MainTests.cpp deleted file mode 100644 index e5f8d3e9..00000000 --- a/test_package/src/MainTests.cpp +++ /dev/null @@ -1,10 +0,0 @@ -/* - * 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) - */ - -#define CATCH_CONFIG_MAIN -#include "catch.hpp" diff --git a/test_package/src/TrickyTests.cpp b/test_package/src/TrickyTests.cpp deleted file mode 100644 index 26625b03..00000000 --- a/test_package/src/TrickyTests.cpp +++ /dev/null @@ -1,409 +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 - -#include "catch.hpp" - -#ifdef __clang__ -#pragma clang diagnostic ignored "-Wc++98-compat" -#pragma clang diagnostic ignored "-Wc++98-compat-pedantic" -#endif - -namespace Catch -{ - template<> - std::string toString >( const std::pair& value ) - { - std::ostringstream oss; - oss << "std::pair( " << value.first << ", " << value.second << " )"; - return oss.str(); - - } -} - -/////////////////////////////////////////////////////////////////////////////// -TEST_CASE -( - "Parsing a std::pair", - "[Tricky][std::pair]" -) -{ - std::pair aNicePair( 1, 2 ); - - REQUIRE( (std::pair( 1, 2 )) == aNicePair ); -} - -/////////////////////////////////////////////////////////////////////////////// -TEST_CASE -( - "Where there is more to the expression after the RHS", - "[Tricky][failing][.]" -) -{ -// 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 -( - "Where the LHS is not a simple value", - "[Tricky][failing][.]" -) -{ - /* - 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 -( - "A failing expression with a non streamable type is still captured", - "[Tricky][failing][.]" -) -{ - - Opaque o1, o2; - o1.val = 7; - o2.val = 8; - - CHECK( &o1 == &o2 ); - CHECK( o1 == o2 ); -} - -/////////////////////////////////////////////////////////////////////////////// -TEST_CASE -( - "string literals of different sizes can be compared", - "[Tricky][failing][.]" -) -{ - REQUIRE( std::string( "first" ) == "second" ); - -} - -/////////////////////////////////////////////////////////////////////////////// -TEST_CASE -( - "An expression with side-effects should only be evaluated once", - "[Tricky]" -) -{ - 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 -( - "Operators at different namespace levels not hijacked by Koenig lookup" - "[Tricky]" -) -{ - A::X x; - B::Y y; - REQUIRE( x == y ); -} -*/ - -namespace ObjectWithConversions -{ - struct Object - { - operator unsigned int() {return 0xc0000000;} - }; - - /////////////////////////////////////////////////////////////////////////////// - TEST_CASE - ( - "Operators at different namespace levels not hijacked by Koenig lookup", - "[Tricky]" - ) - { - 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("Demonstrate that a non-const == is not used", "[Tricky]" ) - { - 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( "Test enum bit values", "[Tricky]" ) - { - REQUIRE( 0xc0000000 == bit30and31 ); - } -} - -struct Obj -{ - Obj():prop(&p){} - - int p; - int* prop; -}; - -TEST_CASE("boolean member", "[Tricky]") -{ - Obj obj; - REQUIRE( obj.prop != CATCH_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 there to deduce it. -template -struct is_true -{ - static const bool value = B; -}; - -TEST_CASE( "(unimplemented) static bools can be evaluated", "[Tricky]" ) -{ - SECTION("compare to true","") - { - REQUIRE( is_true::value == true ); - REQUIRE( true == is_true::value ); - } - SECTION("compare to false","") - { - REQUIRE( is_true::value == false ); - REQUIRE( false == is_true::value ); - } - - SECTION("negation", "") - { - REQUIRE( !is_true::value ); - } - - SECTION("double negation","") - { - REQUIRE( !!is_true::value ); - } - - SECTION("direct","") - { - REQUIRE( is_true::value ); - REQUIRE_FALSE( is_true::value ); - } -} - -// Uncomment these tests to produce an error at test registration time -/* -TEST_CASE( "Tests with the same name are not allowed", "[Tricky]" ) -{ - -} -TEST_CASE( "Tests with the same name are not allowed", "[Tricky]" ) -{ - -} -*/ - -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( "Objects that evaluated in boolean contexts can be checked", "[Tricky][SafeBool]" ) -{ - Boolable True( true ); - Boolable False( false ); - - CHECK( True ); - CHECK( !False ); - CHECK_FALSE( False ); -} - -TEST_CASE( "Assertions then sections", "[Tricky]" ) -{ - // This was causing a failure due to the way the console reporter was handling - // the current section - - REQUIRE( Catch::alwaysTrue() ); - - SECTION( "A section", "" ) - { - REQUIRE( Catch::alwaysTrue() ); - - SECTION( "Another section", "" ) - { - REQUIRE( Catch::alwaysTrue() ); - } - SECTION( "Another other section", "" ) - { - REQUIRE( Catch::alwaysTrue() ); - } - } -} - -struct Awkward -{ - operator int() const { return 7; } -}; - -TEST_CASE( "non streamable - with conv. op", "[Tricky]" ) -{ - Awkward awkward; - std::string s = Catch::toString( awkward ); - REQUIRE( s == "7" ); -} - -inline void foo() {} - -typedef void (*fooptr_t)(); - -TEST_CASE( "Comparing function pointers", "[Tricky][function pointer]" ) -{ - // This was giving a warning in VS2010 - // #179 - fooptr_t a = foo; - - REQUIRE( a ); - REQUIRE( a == &foo ); -} - -struct S -{ - void f() {} -}; - - -TEST_CASE( "Comparing member function pointers", "[Tricky][member function pointer]" ) -{ - typedef void (S::*MF)(); - MF m = &S::f; - - CHECK( m == &S::f ); -} - -class ClassName {}; - -TEST_CASE( "pointer to class", "[Tricky]" ) -{ - ClassName *p = 0; - REQUIRE( p == 0 ); -} - -#ifdef CATCH_CONFIG_CPP11_NULLPTR - -#include - -TEST_CASE( "null_ptr", "[Tricky][c++11][.]" ) -{ - std::unique_ptr ptr; - REQUIRE(ptr.get() == nullptr); -} - -#endif - -TEST_CASE( "X/level/0/a", "[Tricky]" ) { SUCCEED(""); } -TEST_CASE( "X/level/0/b", "[Tricky][fizz]" ){ SUCCEED(""); } -TEST_CASE( "X/level/1/a", "[Tricky]" ) { SUCCEED(""); } -TEST_CASE( "X/level/1/b", "[Tricky]" ) { SUCCEED(""); } - -TEST_CASE( "has printf", "" ) { - - // This can cause problems as, currently, stdout itself is not redirect - only the cout (and cerr) buffer - printf( "spanner" ); -}