catch2/projects/SelfTest/TrickyTests.cpp

438 lines
9.4 KiB
C++
Raw Normal View History

2010-11-10 00:24:00 +01:00
/*
* 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)
*/
2012-08-16 19:47:41 +02:00
#ifdef __clang__
#pragma clang diagnostic ignored "-Wpadded"
2012-08-16 19:47:41 +02:00
#endif
#ifdef _MSC_VER
#pragma warning (disable : 4702) // Disable unreachable code warning for the last test
// that is triggered when compiling as Win32|Release
#endif
2017-02-13 18:43:43 +01:00
#include <stdio.h>
2011-04-26 09:32:40 +02:00
#include "catch.hpp"
2010-11-10 00:24:00 +01:00
namespace Catch {
std::string toString( const std::pair<int, int>& value ) {
2010-11-10 00:24:00 +01:00
std::ostringstream oss;
oss << "std::pair( " << value.first << ", " << value.second << " )";
return oss.str();
}
}
2011-03-10 15:09:32 +01:00
///////////////////////////////////////////////////////////////////////////////
TEST_CASE
(
"Parsing a std::pair",
"[Tricky][std::pair]"
2011-03-10 15:09:32 +01:00
)
2010-11-10 00:24:00 +01:00
{
std::pair<int, int> aNicePair( 1, 2 );
REQUIRE( (std::pair<int, int>( 1, 2 )) == aNicePair );
2010-11-10 20:18:46 +01:00
}
2011-03-10 15:09:32 +01:00
///////////////////////////////////////////////////////////////////////////////
TEST_CASE
(
2014-12-22 21:17:26 +01:00
"Where there is more to the expression after the RHS",
"[Tricky][failing][.]"
2011-03-10 15:09:32 +01:00
)
2010-11-10 20:18:46 +01:00
{
// 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
(
2014-12-22 21:17:26 +01:00
"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" );
2010-11-11 21:37:46 +01:00
}
struct Opaque
{
int val;
2011-03-10 15:09:32 +01:00
bool operator ==( const Opaque& o ) const
{
2010-11-16 20:48:05 +01:00
return val == o.val;
}
};
2011-03-10 15:09:32 +01:00
///////////////////////////////////////////////////////////////////////////////
TEST_CASE
(
"A failing expression with a non streamable type is still captured",
"[Tricky][failing][.]"
2011-03-10 15:09:32 +01:00
)
{
Opaque o1, o2;
o1.val = 7;
o2.val = 8;
CHECK( &o1 == &o2 );
CHECK( o1 == o2 );
2010-11-29 20:48:37 +01:00
}
2011-03-10 15:09:32 +01:00
///////////////////////////////////////////////////////////////////////////////
TEST_CASE
(
"string literals of different sizes can be compared",
"[Tricky][failing][.]"
2011-03-10 15:09:32 +01:00
)
{
REQUIRE( std::string( "first" ) == "second" );
2011-03-10 15:09:32 +01:00
}
///////////////////////////////////////////////////////////////////////////////
TEST_CASE
(
"An expression with side-effects should only be evaluated once",
"[Tricky]"
2011-03-10 15:09:32 +01:00
)
{
int i = 7;
2011-03-10 15:09:32 +01:00
REQUIRE( i++ == 7 );
REQUIRE( i++ == 8 );
2011-03-10 15:09:32 +01:00
}
2011-04-06 23:26:16 +02:00
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)
2011-04-06 23:26:16 +02:00
{
return (lhs.a == rhs.a);
}
inline bool operator==(const B::Y& lhs, const A::X& rhs)
2011-04-06 23:26:16 +02:00
{
return (lhs.a == rhs.a);
}
2011-04-06 23:26:16 +02:00
///////////////////////////////////////////////////////////////////////////////
/* This, currently, does not compile with LLVM
2011-04-06 23:26:16 +02:00
TEST_CASE
(
"Operators at different namespace levels not hijacked by Koenig lookup"
"[Tricky]"
2011-04-06 23:26:16 +02:00
)
{
A::X x;
B::Y y;
REQUIRE( x == y );
}
*/
2011-04-06 23:26:16 +02:00
namespace ObjectWithConversions
{
struct Object
2011-04-06 23:26:16 +02:00
{
operator unsigned int() {return 0xc0000000;}
};
///////////////////////////////////////////////////////////////////////////////
TEST_CASE
(
"Operators at different namespace levels not hijacked by Koenig lookup",
"[Tricky]"
2011-04-06 23:26:16 +02:00
)
{
Object o;
REQUIRE(0xc0000000 == o );
2011-04-06 23:26:16 +02:00
}
}
namespace ObjectWithNonConstEqualityOperator
2011-04-06 23:26:16 +02:00
{
struct Test
{
Test( unsigned int v )
: m_value(v)
2011-04-06 23:26:16 +02:00
{}
2011-04-06 23:26:16 +02:00
bool operator==( const Test&rhs )
{
2011-04-06 23:26:16 +02:00
return (m_value == rhs.m_value);
}
bool operator==( const Test&rhs ) const
{
2011-04-06 23:26:16 +02:00
return (m_value != rhs.m_value);
}
unsigned int m_value;
};
TEST_CASE("Demonstrate that a non-const == is not used", "[Tricky]" )
2011-04-06 23:26:16 +02:00
{
Test t( 1 );
REQUIRE( t == 1u );
2011-04-06 23:26:16 +02:00
}
}
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]" )
2011-04-06 23:26:16 +02:00
{
REQUIRE( 0xc0000000 == bit30and31 );
}
}
struct Obj
{
Obj():prop(&p){}
int p;
int* prop;
};
TEST_CASE("boolean member", "[Tricky]")
{
Obj obj;
REQUIRE( obj.prop != nullptr );
}
// 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]" )
{
}
2012-05-24 09:23:55 +02:00
*/
2012-10-28 21:57:21 +01:00
struct Boolable
{
explicit Boolable( bool value ) : m_value( value ) {}
2017-04-25 16:46:48 +02:00
explicit operator bool() const {
return m_value;
2012-10-28 21:57:21 +01:00
}
bool m_value;
};
TEST_CASE( "Objects that evaluated in boolean contexts can be checked", "[Tricky][SafeBool]" )
2012-10-28 21:57:21 +01:00
{
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() );
}
}
}
2013-04-12 11:43:06 +02:00
struct Awkward
2013-04-12 11:43:06 +02:00
{
operator int() const { return 7; }
};
TEST_CASE( "non streamable - with conv. op", "[Tricky]" )
{
Awkward awkward;
std::string s = ::Catch::Detail::stringify( awkward );
REQUIRE( s == "7" );
}
2013-07-01 19:45:19 +02:00
inline void foo() {}
typedef void (*fooptr_t)();
TEST_CASE( "Comparing function pointers", "[Tricky][function pointer]" )
2013-07-01 19:45:19 +02:00
{
// 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 );
}
2013-07-01 19:45:19 +02:00
class ClassName {};
TEST_CASE( "pointer to class", "[Tricky]" )
2013-07-01 19:45:19 +02:00
{
ClassName *p = 0;
2013-07-01 20:00:55 +02:00
REQUIRE( p == 0 );
2013-07-01 19:45:19 +02:00
}
#include <memory>
2017-07-13 09:52:51 +02:00
TEST_CASE( "null_ptr", "[Tricky]" )
{
std::unique_ptr<int> ptr;
REQUIRE(ptr.get() == nullptr);
}
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 redirected - only the cout (and cerr) buffer
printf( "loose text artifact\n" );
}
2017-04-26 17:12:48 +02:00
TEST_CASE( "assertions with commas are allowed" ) {
}
namespace {
struct constructor_throws {
constructor_throws() {
throw 1;
}
};
}
2017-04-26 17:12:48 +02:00
TEST_CASE("Commas in various macros are allowed") {
REQUIRE_THROWS( std::vector<constructor_throws>{constructor_throws{}, constructor_throws{}} );
CHECK_THROWS( std::vector<constructor_throws>{constructor_throws{}, constructor_throws{}} );
REQUIRE_NOTHROW( std::vector<int>{1, 2, 3} == std::vector<int>{1, 2, 3} );
CHECK_NOTHROW( std::vector<int>{1, 2, 3} == std::vector<int>{1, 2, 3} );
REQUIRE(std::vector<int>{1, 2} == std::vector<int>{1, 2});
CHECK( std::vector<int>{1, 2} == std::vector<int>{1, 2} );
REQUIRE_FALSE(std::vector<int>{1, 2} == std::vector<int>{1, 2, 3});
CHECK_FALSE( std::vector<int>{1, 2} == std::vector<int>{1, 2, 3} );
CHECK_NOFAIL( std::vector<int>{1, 2} == std::vector<int>{1, 2} );
CHECKED_IF( std::vector<int>{1, 2} == std::vector<int>{1, 2} ) {
REQUIRE(true);
} CHECKED_ELSE( std::vector<int>{1, 2} == std::vector<int>{1, 2} ) {
CHECK(true);
}
2017-04-26 17:12:48 +02:00
}
TEST_CASE( "null deref", "[.][failing][!nonportable]" ) {
CHECK( false );
int *x = NULL;
*x = 1;
}