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__
|
2012-08-13 08:46:10 +02:00
|
|
|
#pragma clang diagnostic ignored "-Wpadded"
|
2012-08-16 19:47:41 +02:00
|
|
|
#endif
|
2012-08-13 08:46:10 +02:00
|
|
|
|
2017-05-08 01:26:06 +02:00
|
|
|
#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
|
|
|
|
2017-05-02 23:51:03 +02: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
|
|
|
|
(
|
2013-11-19 08:21:03 +01:00
|
|
|
"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 );
|
|
|
|
|
2015-11-04 19:01:28 +01:00
|
|
|
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",
|
2013-11-19 08:21:03 +01:00
|
|
|
"[Tricky][failing][.]"
|
2011-03-10 15:09:32 +01:00
|
|
|
)
|
2010-11-10 20:18:46 +01:00
|
|
|
{
|
2013-06-29 13:07:33 +02:00
|
|
|
// int a = 1, b = 2;
|
|
|
|
// REQUIRE( a == 2 || b == 2 );
|
2011-03-11 20:46:18 +01:00
|
|
|
WARN( "Uncomment the code in this test to check that it gives a sensible compiler error" );
|
2011-03-10 20:18:14 +01:00
|
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
TEST_CASE
|
|
|
|
(
|
2014-12-22 21:17:26 +01:00
|
|
|
"Where the LHS is not a simple value",
|
2013-11-19 08:21:03 +01:00
|
|
|
"[Tricky][failing][.]"
|
2011-03-10 20:18:14 +01:00
|
|
|
)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
int a = 1;
|
|
|
|
int b = 2;
|
2015-11-04 19:01:28 +01:00
|
|
|
|
2011-03-10 20:18:14 +01:00
|
|
|
// This only captures part of the expression, but issues a warning about the rest
|
|
|
|
REQUIRE( a+1 == b-1 );
|
|
|
|
*/
|
2011-03-11 20:46:18 +01:00
|
|
|
WARN( "Uncomment the code in this test to check that it gives a sensible compiler error" );
|
2010-11-11 21:37:46 +01:00
|
|
|
}
|
2010-11-29 20:40:44 +01:00
|
|
|
|
2010-11-16 20:30:41 +01:00
|
|
|
struct Opaque
|
|
|
|
{
|
|
|
|
int val;
|
2011-03-10 15:09:32 +01:00
|
|
|
bool operator ==( const Opaque& o ) const
|
2010-11-16 20:30:41 +01:00
|
|
|
{
|
2010-11-16 20:48:05 +01:00
|
|
|
return val == o.val;
|
2010-11-16 20:30:41 +01:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2011-03-10 15:09:32 +01:00
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
TEST_CASE
|
|
|
|
(
|
2014-12-20 01:46:02 +01:00
|
|
|
"A failing expression with a non streamable type is still captured",
|
2013-11-19 08:21:03 +01:00
|
|
|
"[Tricky][failing][.]"
|
2011-03-10 15:09:32 +01:00
|
|
|
)
|
2010-11-16 20:30:41 +01:00
|
|
|
{
|
2015-11-04 19:01:28 +01:00
|
|
|
|
2010-11-16 20:30:41 +01:00
|
|
|
Opaque o1, o2;
|
|
|
|
o1.val = 7;
|
|
|
|
o2.val = 8;
|
2015-11-04 19:01:28 +01:00
|
|
|
|
2010-11-16 20:30:41 +01:00
|
|
|
CHECK( &o1 == &o2 );
|
|
|
|
CHECK( o1 == o2 );
|
2010-11-29 20:48:37 +01:00
|
|
|
}
|
2011-03-10 15:09:32 +01:00
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
TEST_CASE
|
2015-11-04 19:01:28 +01:00
|
|
|
(
|
2014-12-20 01:46:02 +01:00
|
|
|
"string literals of different sizes can be compared",
|
2013-11-19 08:21:03 +01:00
|
|
|
"[Tricky][failing][.]"
|
2011-03-10 15:09:32 +01:00
|
|
|
)
|
|
|
|
{
|
|
|
|
REQUIRE( std::string( "first" ) == "second" );
|
2015-11-04 19:01:28 +01:00
|
|
|
|
2011-03-10 15:09:32 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
TEST_CASE
|
2015-11-04 19:01:28 +01:00
|
|
|
(
|
2013-11-19 08:21:03 +01:00
|
|
|
"An expression with side-effects should only be evaluated once",
|
|
|
|
"[Tricky]"
|
2011-03-10 15:09:32 +01:00
|
|
|
)
|
|
|
|
{
|
|
|
|
int i = 7;
|
2015-11-04 19:01:28 +01:00
|
|
|
|
2011-03-10 15:09:32 +01:00
|
|
|
REQUIRE( i++ == 7 );
|
|
|
|
REQUIRE( i++ == 8 );
|
2015-11-04 19:01:28 +01:00
|
|
|
|
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;
|
|
|
|
};
|
|
|
|
}
|
2011-12-27 11:59:41 +01:00
|
|
|
|
|
|
|
inline bool operator==(const A::X& lhs, const B::Y& rhs)
|
2011-04-06 23:26:16 +02:00
|
|
|
{
|
|
|
|
return (lhs.a == rhs.a);
|
|
|
|
}
|
|
|
|
|
2011-12-27 11:59:41 +01:00
|
|
|
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-12-27 11:59:41 +01:00
|
|
|
|
2011-04-06 23:26:16 +02:00
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
2011-12-27 11:59:41 +01: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"
|
2013-11-19 08:21:03 +01:00
|
|
|
"[Tricky]"
|
2011-04-06 23:26:16 +02:00
|
|
|
)
|
|
|
|
{
|
|
|
|
A::X x;
|
|
|
|
B::Y y;
|
|
|
|
REQUIRE( x == y );
|
|
|
|
}
|
2011-12-27 11:59:41 +01:00
|
|
|
*/
|
2011-04-06 23:26:16 +02:00
|
|
|
|
|
|
|
namespace ObjectWithConversions
|
2015-11-04 19:01:28 +01:00
|
|
|
{
|
|
|
|
struct Object
|
2011-04-06 23:26:16 +02:00
|
|
|
{
|
|
|
|
operator unsigned int() {return 0xc0000000;}
|
|
|
|
};
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
TEST_CASE
|
|
|
|
(
|
2013-11-19 08:21:03 +01:00
|
|
|
"Operators at different namespace levels not hijacked by Koenig lookup",
|
2017-09-01 20:28:49 +02:00
|
|
|
"[Tricky][approvals]"
|
2011-04-06 23:26:16 +02:00
|
|
|
)
|
2015-11-04 19:01:28 +01:00
|
|
|
{
|
2013-04-16 23:55:31 +02:00
|
|
|
Object o;
|
2011-04-11 09:32:55 +02:00
|
|
|
REQUIRE(0xc0000000 == o );
|
2011-04-06 23:26:16 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
namespace EnumBitFieldTests
|
|
|
|
{
|
2017-09-01 20:28:49 +02:00
|
|
|
enum Bits : uint32_t {
|
|
|
|
bit0 = 0x0001,
|
|
|
|
bit1 = 0x0002,
|
|
|
|
bit2 = 0x0004,
|
|
|
|
bit3 = 0x0008,
|
|
|
|
bit1and2 = bit1 | bit2,
|
|
|
|
bit30 = 0x40000000,
|
|
|
|
bit31 = 0x80000000,
|
|
|
|
bit30and31 = bit30 | bit31
|
|
|
|
};
|
2011-04-06 23:26:16 +02:00
|
|
|
|
2013-11-19 08:21:03 +01:00
|
|
|
TEST_CASE( "Test enum bit values", "[Tricky]" )
|
2011-04-06 23:26:16 +02:00
|
|
|
{
|
|
|
|
REQUIRE( 0xc0000000 == bit30and31 );
|
|
|
|
}
|
|
|
|
}
|
2011-04-11 09:32:55 +02:00
|
|
|
|
|
|
|
struct Obj
|
|
|
|
{
|
|
|
|
Obj():prop(&p){}
|
2015-11-04 19:01:28 +01:00
|
|
|
|
2011-04-11 09:32:55 +02:00
|
|
|
int p;
|
|
|
|
int* prop;
|
|
|
|
};
|
|
|
|
|
2013-11-19 08:21:03 +01:00
|
|
|
TEST_CASE("boolean member", "[Tricky]")
|
2011-04-11 09:32:55 +02:00
|
|
|
{
|
|
|
|
Obj obj;
|
2017-04-25 12:41:30 +02:00
|
|
|
REQUIRE( obj.prop != nullptr );
|
2011-04-11 09:32:55 +02:00
|
|
|
}
|
2011-08-09 09:18:27 +02:00
|
|
|
|
|
|
|
// 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
|
2013-11-19 08:21:03 +01:00
|
|
|
// templates that were there to deduce it.
|
2011-08-09 09:18:27 +02:00
|
|
|
template <bool B>
|
|
|
|
struct is_true
|
|
|
|
{
|
|
|
|
static const bool value = B;
|
|
|
|
};
|
|
|
|
|
2013-11-19 08:21:03 +01:00
|
|
|
TEST_CASE( "(unimplemented) static bools can be evaluated", "[Tricky]" )
|
2011-08-09 09:18:27 +02:00
|
|
|
{
|
|
|
|
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 );
|
|
|
|
}
|
|
|
|
}
|
2012-02-09 09:34:01 +01:00
|
|
|
|
|
|
|
// Uncomment these tests to produce an error at test registration time
|
|
|
|
/*
|
2013-11-19 08:21:03 +01:00
|
|
|
TEST_CASE( "Tests with the same name are not allowed", "[Tricky]" )
|
2012-02-09 09:34:01 +01:00
|
|
|
{
|
2015-11-04 19:01:28 +01:00
|
|
|
|
2012-02-09 09:34:01 +01:00
|
|
|
}
|
2013-11-19 08:21:03 +01:00
|
|
|
TEST_CASE( "Tests with the same name are not allowed", "[Tricky]" )
|
2012-02-09 09:34:01 +01:00
|
|
|
{
|
2015-11-04 19:01:28 +01:00
|
|
|
|
2012-02-09 09:34:01 +01:00
|
|
|
}
|
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;
|
|
|
|
};
|
|
|
|
|
2013-11-19 08:21:03 +01:00
|
|
|
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 );
|
|
|
|
}
|
2013-03-06 20:40:16 +01:00
|
|
|
|
2013-11-19 08:21:03 +01:00
|
|
|
TEST_CASE( "Assertions then sections", "[Tricky]" )
|
2013-03-06 20:40:16 +01:00
|
|
|
{
|
|
|
|
// This was causing a failure due to the way the console reporter was handling
|
|
|
|
// the current section
|
2015-11-04 19:01:28 +01:00
|
|
|
|
2014-05-28 19:53:01 +02:00
|
|
|
REQUIRE( Catch::alwaysTrue() );
|
2015-11-04 19:01:28 +01:00
|
|
|
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "A section" )
|
2013-03-06 20:40:16 +01:00
|
|
|
{
|
2014-05-28 19:53:01 +02:00
|
|
|
REQUIRE( Catch::alwaysTrue() );
|
2015-11-04 19:01:28 +01:00
|
|
|
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "Another section" )
|
2013-03-06 20:40:16 +01:00
|
|
|
{
|
2014-05-28 19:53:01 +02:00
|
|
|
REQUIRE( Catch::alwaysTrue() );
|
2013-03-06 20:40:16 +01:00
|
|
|
}
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "Another other section" )
|
2013-03-06 20:40:16 +01:00
|
|
|
{
|
2014-05-28 19:53:01 +02:00
|
|
|
REQUIRE( Catch::alwaysTrue() );
|
2013-03-06 20:40:16 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-04-12 11:43:06 +02:00
|
|
|
|
2013-04-16 23:55:31 +02:00
|
|
|
struct Awkward
|
2013-04-12 11:43:06 +02:00
|
|
|
{
|
|
|
|
operator int() const { return 7; }
|
|
|
|
};
|
|
|
|
|
2013-11-19 08:21:03 +01:00
|
|
|
TEST_CASE( "non streamable - with conv. op", "[Tricky]" )
|
2013-04-21 00:12:17 +02:00
|
|
|
{
|
|
|
|
Awkward awkward;
|
2017-05-02 23:51:03 +02:00
|
|
|
std::string s = ::Catch::Detail::stringify( awkward );
|
2013-04-21 00:12:17 +02:00
|
|
|
REQUIRE( s == "7" );
|
|
|
|
}
|
2013-04-22 19:55:12 +02:00
|
|
|
|
2013-07-01 19:45:19 +02:00
|
|
|
inline void foo() {}
|
|
|
|
|
|
|
|
typedef void (*fooptr_t)();
|
|
|
|
|
2013-11-19 08:21:03 +01:00
|
|
|
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 );
|
|
|
|
}
|
|
|
|
|
2014-01-07 18:25:27 +01:00
|
|
|
struct S
|
|
|
|
{
|
|
|
|
void f() {}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2017-09-01 20:28:49 +02:00
|
|
|
TEST_CASE( "Comparing member function pointers", "[Tricky][member function pointer][approvals]" )
|
2014-01-07 18:25:27 +01:00
|
|
|
{
|
|
|
|
typedef void (S::*MF)();
|
|
|
|
MF m = &S::f;
|
|
|
|
|
|
|
|
CHECK( m == &S::f );
|
|
|
|
}
|
|
|
|
|
2013-07-01 19:45:19 +02:00
|
|
|
class ClassName {};
|
|
|
|
|
2013-11-19 08:21:03 +01:00
|
|
|
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
|
|
|
}
|
|
|
|
|
2013-04-22 19:55:12 +02:00
|
|
|
#include <memory>
|
|
|
|
|
2017-07-13 09:52:51 +02:00
|
|
|
TEST_CASE( "null_ptr", "[Tricky]" )
|
2013-04-22 19:55:12 +02:00
|
|
|
{
|
|
|
|
std::unique_ptr<int> ptr;
|
|
|
|
REQUIRE(ptr.get() == nullptr);
|
|
|
|
}
|
|
|
|
|
2013-11-19 08:21:03 +01:00
|
|
|
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(""); }
|
2017-02-13 16:56:25 +01:00
|
|
|
|
2017-07-13 10:20:37 +02:00
|
|
|
TEST_CASE( "has printf" ) {
|
2017-02-13 16:56:25 +01:00
|
|
|
|
2017-08-11 11:38:29 +02:00
|
|
|
// This can cause problems as, currently, stdout itself is not redirected - only the cout (and cerr) buffer
|
|
|
|
printf( "loose text artifact\n" );
|
2017-02-13 16:56:25 +01:00
|
|
|
}
|
2017-04-26 17:12:48 +02:00
|
|
|
|
|
|
|
TEST_CASE( "assertions with commas are allowed" ) {
|
2017-05-03 19:10:27 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
struct constructor_throws {
|
|
|
|
constructor_throws() {
|
|
|
|
throw 1;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
2017-04-26 17:12:48 +02:00
|
|
|
|
2017-05-03 19:10:27 +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
|
|
|
}
|
2017-08-10 18:10:13 +02:00
|
|
|
|
|
|
|
TEST_CASE( "null deref", "[.][failing][!nonportable]" ) {
|
|
|
|
CHECK( false );
|
|
|
|
int *x = NULL;
|
|
|
|
*x = 1;
|
|
|
|
}
|
2017-08-17 17:48:46 +02:00
|
|
|
|
2017-08-17 17:55:35 +02:00
|
|
|
TEST_CASE( "non-copyable objects", "[.][failing]" ) {
|
2017-08-17 17:48:46 +02:00
|
|
|
// Thanks to Agustin Bergé (@k-ballo on the cpplang Slack) for raising this
|
|
|
|
std::type_info const& ti = typeid(int);
|
|
|
|
CHECK( ti == typeid(int) );
|
|
|
|
}
|
2017-09-06 14:42:44 +02:00
|
|
|
|
|
|
|
// #925
|
|
|
|
using signal_t = void (*) (void*);
|
|
|
|
|
|
|
|
struct TestClass {
|
|
|
|
signal_t testMethod_uponComplete_arg = nullptr;
|
|
|
|
};
|
|
|
|
|
|
|
|
namespace utility {
|
|
|
|
inline static void synchronizing_callback( void * ) { }
|
|
|
|
}
|
|
|
|
|
2017-09-07 16:04:30 +02:00
|
|
|
TEST_CASE("#925: comparing function pointer to function address failed to compile", "[!nonportable]" ) {
|
|
|
|
|
2017-09-06 14:42:44 +02:00
|
|
|
TestClass test;
|
|
|
|
REQUIRE(utility::synchronizing_callback != test.testMethod_uponComplete_arg);
|
|
|
|
}
|