#926 Update Conan version by release

- Update release scripts to increment Conan version

Signed-off-by: Uilian Ries <uilianries@gmail.com>
This commit is contained in:
Uilian Ries 2017-06-23 11:06:49 -03:00
parent 6234e3d54d
commit 3491804598
12 changed files with 49 additions and 556 deletions

View File

@ -12,8 +12,5 @@ class CatchConan(ConanFile):
url = "https://github.com/philsquared/Catch" url = "https://github.com/philsquared/Catch"
license = "BSL-1.0" license = "BSL-1.0"
def build(self):
pass
def package(self): def package(self):
self.copy(pattern="catch.hpp", src="single_include", dst="include") self.copy(pattern="catch.hpp", src="single_include", dst="include")

View File

@ -7,5 +7,6 @@ v = Version()
v.incrementBuildNumber() v.incrementBuildNumber()
v.updateVersionFile() v.updateVersionFile()
v.updateReadmeFile() v.updateReadmeFile()
v.updateConanFile()
print( "Updated Version.hpp and README to v{0}".format( v.getVersionString() ) ) print( "Updated Version.hpp, README and Conan to v{0}".format( v.getVersionString() ) )

View File

@ -7,5 +7,6 @@ v = Version()
v.incrementMajorVersion() v.incrementMajorVersion()
v.updateVersionFile() v.updateVersionFile()
v.updateReadmeFile() v.updateReadmeFile()
v.updateConanFile()
print( "Updated Version.hpp and README to v{0}".format( v.getVersionString() ) ) print( "Updated Version.hpp, README and Conan to v{0}".format( v.getVersionString() ) )

View File

@ -7,5 +7,6 @@ v = Version()
v.incrementMinorVersion() v.incrementMinorVersion()
v.updateVersionFile() v.updateVersionFile()
v.updateReadmeFile() v.updateReadmeFile()
v.updateConanFile()
print( "Updated Version.hpp and README to v{0}".format( v.getVersionString() ) ) print( "Updated Version.hpp, README and Conan to v{0}".format( v.getVersionString() ) )

View File

@ -7,5 +7,6 @@ v = Version()
v.incrementPatchNumber() v.incrementPatchNumber()
v.updateVersionFile() v.updateVersionFile()
v.updateReadmeFile() v.updateReadmeFile()
v.updateConanFile()
print( "Updated Version.hpp and README to v{0}".format( v.getVersionString() ) ) print( "Updated Version.hpp, README and Conan to v{0}".format( v.getVersionString() ) )

View File

@ -11,6 +11,7 @@ versionParser = re.compile( r'(\s*static\sVersion\sversion)\s*\(\s*(.*)\s*,\s*(.
rootPath = os.path.join( catchPath, 'include/' ) rootPath = os.path.join( catchPath, 'include/' )
versionPath = os.path.join( rootPath, "internal/catch_version.hpp" ) versionPath = os.path.join( rootPath, "internal/catch_version.hpp" )
readmePath = os.path.join( catchPath, "README.md" ) readmePath = os.path.join( catchPath, "README.md" )
conanPath = os.path.join(catchPath, 'conanfile.py')
class Version: class Version:
def __init__(self): def __init__(self):
@ -86,3 +87,17 @@ class Version:
line = downloadParser.sub( r'<a href="https://github.com/philsquared/Catch/releases/download/v{0}/catch.hpp">'.format(self.getVersionString()) , line) line = downloadParser.sub( r'<a href="https://github.com/philsquared/Catch/releases/download/v{0}/catch.hpp">'.format(self.getVersionString()) , line)
f.write( line + "\n" ) 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" )

View File

@ -1,19 +1,7 @@
cmake_minimum_required(VERSION 3.0) cmake_minimum_required(VERSION 3.0)
project(CatchTest CXX) project(CatchTest CXX)
# Conan setup ##################################################################
include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake) include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
conan_basic_setup() conan_basic_setup()
include(CTest) add_executable(${CMAKE_PROJECT_NAME} MainTest.cpp)
# 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})

21
test_package/MainTest.cpp Normal file
View File

@ -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 );
}

View File

@ -1,24 +1,16 @@
#!/usr/bin/env python #!/usr/bin/env python
from os import getenv from os import getenv
from os import path
from conans import ConanFile from conans import ConanFile
from conans import CMake from conans import CMake
class CatchConanTest(ConanFile): 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" generators = "cmake"
settings = "os", "compiler", "arch", "build_type" settings = "os", "compiler", "arch", "build_type"
url = "https://github.com/philsquared/Catch" username = getenv("CONAN_USERNAME", "philsquared")
license = "BSL-1.0"
username = getenv("CONAN_USERNAME", author)
channel = getenv("CONAN_CHANNEL", "testing") 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): def build(self):
cmake = CMake(self) cmake = CMake(self)
@ -26,6 +18,4 @@ class CatchConanTest(ConanFile):
cmake.build() cmake.build()
def test(self): def test(self):
cmake = CMake(self) self.run(path.join("bin", "CatchTest"))
cmake.configure(build_dir="./")
cmake.test()

View File

@ -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<int> 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);
}
}
}
}

View File

@ -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"

View File

@ -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 <stdio.h>
#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<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
(
"Parsing a std::pair",
"[Tricky][std::pair]"
)
{
std::pair<int, int> aNicePair( 1, 2 );
REQUIRE( (std::pair<int, int>( 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 <bool B>
struct is_true
{
static const bool value = B;
};
TEST_CASE( "(unimplemented) static bools can be evaluated", "[Tricky]" )
{
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( "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 <memory>
TEST_CASE( "null_ptr", "[Tricky][c++11][.]" )
{
std::unique_ptr<int> 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" );
}