mirror of
https://github.com/catchorg/Catch2.git
synced 2024-12-29 06:03:30 +01:00
849f2848bd
Previously, each warning suppression was self-contained, with its own pair of `SUPPRESS_X_WARNING` and `UNSUPPRESS_X_WARNING` macros. This had the obvious advantage of being self-containing, but it also meant that if we needed to suppress more than one warning in a single place, then we would manipulate the compiler's warning state multiple times, even though logically we would only need one layer. The new way of suppressing warnings in macros is to push compiler's warning state with `CATCH_INTERNAL_START_WARNINGS_SUPPRESSION` macro, then disable whatever macros we need with the `CATCH_INTERNAL_SUPPRESS_X_WARNINGS` macro, and then return to the previous state using `CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION`.
488 lines
13 KiB
C++
488 lines
13 KiB
C++
/*
|
|
* 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"
|
|
|
|
#ifdef __clang__
|
|
# pragma clang diagnostic ignored "-Wc++98-compat"
|
|
# pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
|
|
#endif
|
|
|
|
|
|
#include <iostream>
|
|
#include <cerrno>
|
|
#include <limits>
|
|
#include <sstream>
|
|
#include <array>
|
|
|
|
namespace { namespace MiscTests {
|
|
|
|
#ifndef MISC_TEST_HELPERS_INCLUDED // Don't compile this more than once per TU
|
|
#define MISC_TEST_HELPERS_INCLUDED
|
|
|
|
inline const char* makeString( bool makeNull ) {
|
|
return makeNull ? nullptr : "valid string";
|
|
}
|
|
inline bool testCheckedIf( bool flag ) {
|
|
CHECKED_IF( flag )
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
inline bool testCheckedElse( bool flag ) {
|
|
CHECKED_ELSE( flag )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
inline unsigned int Factorial( unsigned int number ) {
|
|
return number > 1 ? Factorial(number-1)*number : 1;
|
|
}
|
|
|
|
static int f() {
|
|
return 1;
|
|
}
|
|
|
|
inline void manuallyRegisteredTestFunction() {
|
|
SUCCEED( "was called" );
|
|
}
|
|
|
|
struct AutoTestReg {
|
|
AutoTestReg() {
|
|
REGISTER_TEST_CASE( manuallyRegisteredTestFunction, "ManuallyRegistered" );
|
|
}
|
|
};
|
|
|
|
CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
|
|
CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
|
|
static AutoTestReg autoTestReg;
|
|
CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
|
|
|
|
template<typename T>
|
|
struct Foo {
|
|
size_t size() { return 0; }
|
|
};
|
|
|
|
template<typename T, size_t S>
|
|
struct Bar {
|
|
size_t size() { return S; }
|
|
};
|
|
#endif
|
|
|
|
TEST_CASE( "random SECTION tests", "[.][sections][failing]" ) {
|
|
int a = 1;
|
|
int b = 2;
|
|
|
|
SECTION( "doesn't equal" ) {
|
|
REQUIRE( a != b );
|
|
REQUIRE( b != a );
|
|
}
|
|
|
|
SECTION( "not equal" ) {
|
|
REQUIRE( a != b);
|
|
}
|
|
}
|
|
|
|
TEST_CASE( "nested SECTION tests", "[.][sections][failing]" ) {
|
|
int a = 1;
|
|
int b = 2;
|
|
|
|
SECTION( "doesn't equal" ) {
|
|
REQUIRE( a != b );
|
|
REQUIRE( b != a );
|
|
|
|
SECTION( "not equal" ) {
|
|
REQUIRE( a != b);
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST_CASE( "more nested SECTION tests", "[sections][failing][.]" ) {
|
|
int a = 1;
|
|
int b = 2;
|
|
|
|
SECTION( "doesn't equal" ) {
|
|
SECTION( "equal" ) {
|
|
REQUIRE( a == b );
|
|
}
|
|
|
|
SECTION( "not equal" ) {
|
|
REQUIRE( a != b );
|
|
}
|
|
SECTION( "less than" ) {
|
|
REQUIRE( a < b );
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST_CASE( "even more nested SECTION tests", "[sections]" ) {
|
|
SECTION( "c" ) {
|
|
SECTION( "d (leaf)" ) {
|
|
SUCCEED(); // avoid failing due to no tests
|
|
}
|
|
|
|
SECTION( "e (leaf)" ) {
|
|
SUCCEED(); // avoid failing due to no tests
|
|
}
|
|
}
|
|
|
|
SECTION( "f (leaf)" ) {
|
|
SUCCEED(); // avoid failing due to no tests
|
|
}
|
|
}
|
|
|
|
TEST_CASE( "looped SECTION tests", "[.][failing][sections]" ) {
|
|
int a = 1;
|
|
|
|
for( int b = 0; b < 10; ++b ) {
|
|
DYNAMIC_SECTION( "b is currently: " << b ) {
|
|
CHECK( b > a );
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST_CASE( "looped tests", "[.][failing]" ) {
|
|
static const int fib[] = { 1, 1, 2, 3, 5, 8, 13, 21 };
|
|
|
|
for( std::size_t i=0; i < sizeof(fib)/sizeof(int); ++i ) {
|
|
INFO( "Testing if fib[" << i << "] (" << fib[i] << ") is even" );
|
|
CHECK( ( fib[i] % 2 ) == 0 );
|
|
}
|
|
}
|
|
|
|
TEST_CASE( "Sends stuff to stdout and stderr", "[.]" ) {
|
|
std::cout << "A string sent directly to stdout" << std::endl;
|
|
std::cerr << "A string sent directly to stderr" << std::endl;
|
|
std::clog << "A string sent to stderr via clog" << std::endl;
|
|
}
|
|
|
|
TEST_CASE( "null strings" ) {
|
|
REQUIRE( makeString( false ) != static_cast<char*>(nullptr));
|
|
REQUIRE( makeString( true ) == static_cast<char*>(nullptr));
|
|
}
|
|
|
|
TEST_CASE( "checkedIf" ) {
|
|
REQUIRE( testCheckedIf( true ) );
|
|
}
|
|
|
|
TEST_CASE( "checkedIf, failing", "[failing][.]" ) {
|
|
REQUIRE( testCheckedIf( false ) );
|
|
}
|
|
|
|
TEST_CASE( "checkedElse" ) {
|
|
REQUIRE( testCheckedElse( true ) );
|
|
}
|
|
|
|
TEST_CASE( "checkedElse, failing", "[failing][.]" ) {
|
|
REQUIRE( testCheckedElse( false ) );
|
|
}
|
|
|
|
TEST_CASE( "xmlentitycheck" ) {
|
|
SECTION( "embedded xml: <test>it should be possible to embed xml characters, such as <, \" or &, or even whole <xml>documents</xml> within an attribute</test>" ) {
|
|
SUCCEED(); // We need this here to stop it failing due to no tests
|
|
}
|
|
SECTION( "encoded chars: these should all be encoded: &&&\"\"\"<<<&\"<<&\"" ) {
|
|
SUCCEED(); // We need this here to stop it failing due to no tests
|
|
}
|
|
}
|
|
|
|
TEST_CASE( "send a single char to INFO", "[failing][.]" ) {
|
|
INFO(3);
|
|
REQUIRE(false);
|
|
}
|
|
|
|
TEST_CASE( "atomic if", "[failing][0]") {
|
|
std::size_t x = 0;
|
|
|
|
if( x )
|
|
REQUIRE(x > 0);
|
|
else
|
|
REQUIRE(x == 0);
|
|
}
|
|
|
|
|
|
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 );
|
|
}
|
|
|
|
TEST_CASE( "An empty test with no assertions", "[empty]" ) {}
|
|
|
|
TEST_CASE( "Nice descriptive name", "[tag1][tag2][tag3][.]" ) {
|
|
WARN( "This one ran" );
|
|
}
|
|
TEST_CASE( "first tag", "[tag1]" ) {}
|
|
TEST_CASE( "second tag", "[tag2]" ) {}
|
|
|
|
//
|
|
//TEST_CASE( "spawn a new process", "[.]" )
|
|
//{
|
|
// // !TBD Work in progress
|
|
// char line[200];
|
|
// FILE* output = popen("./CatchSelfTest ./failing/matchers/StartsWith", "r");
|
|
// while ( fgets(line, 199, output) )
|
|
// std::cout << line;
|
|
//}
|
|
|
|
TEST_CASE( "vectors can be sized and resized", "[vector]" ) {
|
|
|
|
std::vector<int> v( 5 );
|
|
|
|
REQUIRE( v.size() == 5 );
|
|
REQUIRE( v.capacity() >= 5 );
|
|
|
|
SECTION( "resizing bigger changes size and capacity" ) {
|
|
v.resize( 10 );
|
|
|
|
REQUIRE( v.size() == 10 );
|
|
REQUIRE( v.capacity() >= 10 );
|
|
}
|
|
SECTION( "resizing smaller changes size but not capacity" ) {
|
|
v.resize( 0 );
|
|
|
|
REQUIRE( v.size() == 0 );
|
|
REQUIRE( v.capacity() >= 5 );
|
|
|
|
SECTION( "We can use the 'swap trick' to reset the capacity" ) {
|
|
std::vector<int> empty;
|
|
empty.swap( v );
|
|
|
|
REQUIRE( v.capacity() == 0 );
|
|
}
|
|
}
|
|
SECTION( "reserving bigger changes capacity but not size" ) {
|
|
v.reserve( 10 );
|
|
|
|
REQUIRE( v.size() == 5 );
|
|
REQUIRE( v.capacity() >= 10 );
|
|
}
|
|
SECTION( "reserving smaller does not change size or capacity" ) {
|
|
v.reserve( 0 );
|
|
|
|
REQUIRE( v.size() == 5 );
|
|
REQUIRE( v.capacity() >= 5 );
|
|
}
|
|
}
|
|
|
|
TEMPLATE_TEST_CASE( "TemplateTest: vectors can be sized and resized", "[vector][template]", int, float, std::string, (std::tuple<int,float>) ) {
|
|
|
|
std::vector<TestType> v( 5 );
|
|
|
|
REQUIRE( v.size() == 5 );
|
|
REQUIRE( v.capacity() >= 5 );
|
|
|
|
SECTION( "resizing bigger changes size and capacity" ) {
|
|
v.resize( 10 );
|
|
|
|
REQUIRE( v.size() == 10 );
|
|
REQUIRE( v.capacity() >= 10 );
|
|
}
|
|
SECTION( "resizing smaller changes size but not capacity" ) {
|
|
v.resize( 0 );
|
|
|
|
REQUIRE( v.size() == 0 );
|
|
REQUIRE( v.capacity() >= 5 );
|
|
|
|
SECTION( "We can use the 'swap trick' to reset the capacity" ) {
|
|
std::vector<TestType> empty;
|
|
empty.swap( v );
|
|
|
|
REQUIRE( v.capacity() == 0 );
|
|
}
|
|
}
|
|
SECTION( "reserving bigger changes capacity but not size" ) {
|
|
v.reserve( 10 );
|
|
|
|
REQUIRE( v.size() == 5 );
|
|
REQUIRE( v.capacity() >= 10 );
|
|
}
|
|
SECTION( "reserving smaller does not change size or capacity" ) {
|
|
v.reserve( 0 );
|
|
|
|
REQUIRE( v.size() == 5 );
|
|
REQUIRE( v.capacity() >= 5 );
|
|
}
|
|
}
|
|
|
|
TEMPLATE_TEST_CASE_SIG("TemplateTestSig: vectors can be sized and resized", "[vector][template][nttp]", ((typename TestType, int V), TestType, V), (int,5), (float,4), (std::string,15), ((std::tuple<int, float>), 6)) {
|
|
|
|
std::vector<TestType> v(V);
|
|
|
|
REQUIRE(v.size() == V);
|
|
REQUIRE(v.capacity() >= V);
|
|
|
|
SECTION("resizing bigger changes size and capacity") {
|
|
v.resize(2 * V);
|
|
|
|
REQUIRE(v.size() == 2 * V);
|
|
REQUIRE(v.capacity() >= 2 * V);
|
|
}
|
|
SECTION("resizing smaller changes size but not capacity") {
|
|
v.resize(0);
|
|
|
|
REQUIRE(v.size() == 0);
|
|
REQUIRE(v.capacity() >= V);
|
|
|
|
SECTION("We can use the 'swap trick' to reset the capacity") {
|
|
std::vector<TestType> empty;
|
|
empty.swap(v);
|
|
|
|
REQUIRE(v.capacity() == 0);
|
|
}
|
|
}
|
|
SECTION("reserving bigger changes capacity but not size") {
|
|
v.reserve(2 * V);
|
|
|
|
REQUIRE(v.size() == V);
|
|
REQUIRE(v.capacity() >= 2 * V);
|
|
}
|
|
SECTION("reserving smaller does not change size or capacity") {
|
|
v.reserve(0);
|
|
|
|
REQUIRE(v.size() == V);
|
|
REQUIRE(v.capacity() >= V);
|
|
}
|
|
}
|
|
|
|
TEMPLATE_PRODUCT_TEST_CASE("A Template product test case", "[template][product]", (std::vector, Foo), (int, float)) {
|
|
TestType x;
|
|
REQUIRE(x.size() == 0);
|
|
}
|
|
|
|
TEMPLATE_PRODUCT_TEST_CASE_SIG("A Template product test case with array signature", "[template][product][nttp]", ((typename T, size_t S), T, S), (std::array, Bar), ((int, 9), (float, 42))) {
|
|
TestType x;
|
|
REQUIRE(x.size() > 0);
|
|
}
|
|
|
|
TEMPLATE_PRODUCT_TEST_CASE("Product with differing arities", "[template][product]", std::tuple, (int, (int, double), (int, double, float))) {
|
|
REQUIRE(std::tuple_size<TestType>::value >= 1);
|
|
}
|
|
|
|
using MyTypes = std::tuple<int, char, float>;
|
|
TEMPLATE_LIST_TEST_CASE("Template test case with test types specified inside std::tuple", "[template][list]", MyTypes)
|
|
{
|
|
REQUIRE(sizeof(TestType) > 0);
|
|
}
|
|
|
|
struct NonDefaultConstructibleType {
|
|
NonDefaultConstructibleType() = delete;
|
|
};
|
|
|
|
using MyNonDefaultConstructibleTypes = std::tuple<NonDefaultConstructibleType, float>;
|
|
TEMPLATE_LIST_TEST_CASE("Template test case with test types specified inside non-default-constructible std::tuple", "[template][list]", MyNonDefaultConstructibleTypes)
|
|
{
|
|
REQUIRE(sizeof(TestType) > 0);
|
|
}
|
|
|
|
struct NonCopyableAndNonMovableType {
|
|
NonCopyableAndNonMovableType() = default;
|
|
|
|
NonCopyableAndNonMovableType(NonCopyableAndNonMovableType const &) = delete;
|
|
NonCopyableAndNonMovableType(NonCopyableAndNonMovableType &&) = delete;
|
|
auto operator=(NonCopyableAndNonMovableType const &) -> NonCopyableAndNonMovableType & = delete;
|
|
auto operator=(NonCopyableAndNonMovableType &&) -> NonCopyableAndNonMovableType & = delete;
|
|
};
|
|
|
|
using NonCopyableAndNonMovableTypes = std::tuple<NonCopyableAndNonMovableType, float>;
|
|
TEMPLATE_LIST_TEST_CASE("Template test case with test types specified inside non-copyable and non-movable std::tuple", "[template][list]", NonCopyableAndNonMovableTypes)
|
|
{
|
|
REQUIRE(sizeof(TestType) > 0);
|
|
}
|
|
|
|
// https://github.com/philsquared/Catch/issues/166
|
|
TEST_CASE("A couple of nested sections followed by a failure", "[failing][.]") {
|
|
SECTION("Outer")
|
|
SECTION("Inner")
|
|
SUCCEED("that's not flying - that's failing in style");
|
|
|
|
FAIL("to infinity and beyond");
|
|
}
|
|
|
|
TEST_CASE("not allowed", "[!throws]") {
|
|
// This test case should not be included if you run with -e on the command line
|
|
SUCCEED();
|
|
}
|
|
|
|
//TEST_CASE( "Is big endian" ) {
|
|
// CHECK( Catch::Detail::Endianness::which() == Catch::Detail::Endianness::Little );
|
|
//}
|
|
|
|
TEST_CASE( "Tabs and newlines show in output", "[.][whitespace][failing]" ) {
|
|
|
|
// Based on issue #242
|
|
std::string s1 = "if ($b == 10) {\n\t\t$a\t= 20;\n}";
|
|
std::string s2 = "if ($b == 10) {\n\t$a = 20;\n}\n";
|
|
CHECK( s1 == s2 );
|
|
}
|
|
|
|
|
|
#ifdef CATCH_CONFIG_WCHAR
|
|
TEST_CASE( "toString on const wchar_t const pointer returns the string contents", "[toString]" ) {
|
|
const wchar_t * const s = L"wide load";
|
|
std::string result = ::Catch::Detail::stringify( s );
|
|
CHECK( result == "\"wide load\"" );
|
|
}
|
|
|
|
TEST_CASE( "toString on const wchar_t pointer returns the string contents", "[toString]" ) {
|
|
const wchar_t * s = L"wide load";
|
|
std::string result = ::Catch::Detail::stringify( s );
|
|
CHECK( result == "\"wide load\"" );
|
|
}
|
|
|
|
TEST_CASE( "toString on wchar_t const pointer returns the string contents", "[toString]" ) {
|
|
auto const s = const_cast<wchar_t*>( L"wide load" );
|
|
std::string result = ::Catch::Detail::stringify( s );
|
|
CHECK( result == "\"wide load\"" );
|
|
}
|
|
|
|
TEST_CASE( "toString on wchar_t returns the string contents", "[toString]" ) {
|
|
auto s = const_cast<wchar_t*>( L"wide load" );
|
|
std::string result = ::Catch::Detail::stringify( s );
|
|
CHECK( result == "\"wide load\"" );
|
|
}
|
|
#endif
|
|
|
|
TEST_CASE( "long long" ) {
|
|
long long l = std::numeric_limits<long long>::max();
|
|
|
|
REQUIRE( l == std::numeric_limits<long long>::max() );
|
|
}
|
|
|
|
TEST_CASE( "This test 'should' fail but doesn't", "[.][failing][!shouldfail]" ) {
|
|
SUCCEED( "oops!" );
|
|
}
|
|
|
|
TEST_CASE( "# A test name that starts with a #" ) {
|
|
SUCCEED( "yay" );
|
|
}
|
|
|
|
TEST_CASE( "#835 -- errno should not be touched by Catch", "[.][failing][!shouldfail]" ) {
|
|
errno = 1;
|
|
CHECK(f() == 0);
|
|
REQUIRE(errno == 1); // Check that f() doesn't touch errno.
|
|
}
|
|
|
|
TEST_CASE( "#961 -- Dynamically created sections should all be reported", "[.]" ) {
|
|
for (char i = '0'; i < '5'; ++i) {
|
|
SECTION(std::string("Looped section ") + i) {
|
|
SUCCEED( "Everything is OK" );
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST_CASE( "#1175 - Hidden Test", "[.]" ) {
|
|
// Just for checking that hidden test is not listed by default
|
|
SUCCEED();
|
|
}
|
|
|
|
}} // namespace MiscTests
|