catch2/tests/SelfTest/UsageTests/Misc.tests.cpp

486 lines
13 KiB
C++
Raw Normal View History

/*
* 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
#include <catch2/catch_test_macros.hpp>
#include <catch2/catch_template_test_macros.hpp>
2014-05-19 19:57:14 +02:00
#ifdef __clang__
# pragma clang diagnostic ignored "-Wc++98-compat"
# pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
2014-05-19 19:57:14 +02:00
#endif
#include <iostream>
#include <cerrno>
#include <limits>
#include <sstream>
2019-04-17 20:23:24 +02:00
#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; }
};
2019-04-17 20:23:24 +02:00
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 );
}
2010-11-30 07:48:21 +01:00
SECTION( "not equal" ) {
2011-02-17 21:15:20 +01:00
REQUIRE( a != b);
}
}
2010-11-30 07:48:21 +01:00
TEST_CASE( "nested SECTION tests", "[.][sections][failing]" ) {
2010-12-15 20:36:39 +01:00
int a = 1;
int b = 2;
SECTION( "doesn't equal" ) {
2010-12-28 18:21:29 +01:00
REQUIRE( a != b );
2010-12-15 20:36:39 +01:00
REQUIRE( b != a );
SECTION( "not equal" ) {
2011-02-17 21:15:20 +01:00
REQUIRE( a != b);
}
}
}
TEST_CASE( "more nested SECTION tests", "[sections][failing][.]" ) {
2011-02-17 21:15:20 +01:00
int a = 1;
int b = 2;
SECTION( "doesn't equal" ) {
SECTION( "equal" ) {
2011-02-21 09:50:05 +01:00
REQUIRE( a == b );
2011-02-17 21:15:20 +01:00
}
SECTION( "not equal" ) {
2011-02-21 09:50:05 +01:00
REQUIRE( a != b );
}
SECTION( "less than" ) {
REQUIRE( a < b );
2010-12-15 20:36:39 +01:00
}
}
}
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]" ) {
2010-12-28 15:41:57 +01:00
int a = 1;
for( int b = 0; b < 10; ++b ) {
DYNAMIC_SECTION( "b is currently: " << b ) {
CHECK( b > a );
2010-12-28 15:41:57 +01:00
}
}
}
TEST_CASE( "looped tests", "[.][failing]" ) {
2010-12-28 15:41:57 +01:00
static const int fib[] = { 1, 1, 2, 3, 5, 8, 13, 21 };
for( std::size_t i=0; i < sizeof(fib)/sizeof(int); ++i ) {
2010-12-28 15:41:57 +01:00
INFO( "Testing if fib[" << i << "] (" << fib[i] << ") is even" );
CHECK( ( fib[i] % 2 ) == 0 );
2010-12-28 15:41:57 +01:00
}
}
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;
2017-12-05 18:48:15 +01:00
std::clog << "A string sent to stderr via clog" << std::endl;
2010-12-28 15:41:57 +01:00
}
2011-02-23 21:02:18 +01:00
TEST_CASE( "null strings" ) {
REQUIRE( makeString( false ) != static_cast<char*>(nullptr));
REQUIRE( makeString( true ) == static_cast<char*>(nullptr));
2011-02-23 21:02:18 +01:00
}
2011-03-09 20:45:05 +01:00
TEST_CASE( "checkedIf" ) {
2012-02-10 09:30:13 +01:00
REQUIRE( testCheckedIf( true ) );
}
TEST_CASE( "checkedIf, failing", "[failing][.]" ) {
2012-02-10 09:30:13 +01:00
REQUIRE( testCheckedIf( false ) );
}
TEST_CASE( "checkedElse" ) {
2012-02-10 09:30:13 +01:00
REQUIRE( testCheckedElse( true ) );
}
TEST_CASE( "checkedElse, failing", "[failing][.]" ) {
2012-02-10 09:30:13 +01:00
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);
}
2012-03-04 12:14:21 +01:00
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]" ) {}
2012-09-15 18:53:27 +02:00
TEST_CASE( "Nice descriptive name", "[tag1][tag2][tag3][.]" ) {
2012-09-15 18:53:27 +02:00
WARN( "This one ran" );
}
TEST_CASE( "first tag", "[tag1]" ) {}
TEST_CASE( "second tag", "[tag2]" ) {}
2012-10-04 09:19:09 +02:00
//
2013-06-28 17:05:13 +02:00
//TEST_CASE( "spawn a new process", "[.]" )
2012-10-04 09:19:09 +02:00
//{
// // !TBD Work in progress
// char line[200];
// FILE* output = popen("./CatchSelfTest ./failing/matchers/StartsWith", "r");
// while ( fgets(line, 199, output) )
// std::cout << line;
//}
2013-03-25 09:47:36 +01:00
TEST_CASE( "vectors can be sized and resized", "[vector]" ) {
std::vector<int> v( 5 );
2013-03-25 09:47:36 +01:00
REQUIRE( v.size() == 5 );
REQUIRE( v.capacity() >= 5 );
SECTION( "resizing bigger changes size and capacity" ) {
2013-03-25 09:47:36 +01:00
v.resize( 10 );
2013-03-25 09:47:36 +01:00
REQUIRE( v.size() == 10 );
REQUIRE( v.capacity() >= 10 );
}
SECTION( "resizing smaller changes size but not capacity" ) {
2013-03-25 09:47:36 +01:00
v.resize( 0 );
2013-03-25 09:47:36 +01:00
REQUIRE( v.size() == 0 );
REQUIRE( v.capacity() >= 5 );
SECTION( "We can use the 'swap trick' to reset the capacity" ) {
2013-03-25 09:47:36 +01:00
std::vector<int> empty;
empty.swap( v );
2013-03-25 09:47:36 +01:00
REQUIRE( v.capacity() == 0 );
}
}
SECTION( "reserving bigger changes capacity but not size" ) {
2013-03-25 09:47:36 +01:00
v.reserve( 10 );
2013-03-25 09:47:36 +01:00
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" ) {
2013-03-25 09:47:36 +01:00
v.reserve( 0 );
2013-03-25 09:47:36 +01:00
REQUIRE( v.size() == 5 );
REQUIRE( v.capacity() >= 5 );
}
}
2013-05-13 09:20:45 +02:00
2019-04-17 20:23:24 +02:00
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);
}
2019-04-17 20:23:24 +02:00
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);
}
2019-05-27 17:25:48 +02:00
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);
}
2013-05-13 09:20:45 +02:00
// 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 );
//}
2014-04-23 08:07:27 +02:00
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 );
}
2014-08-14 13:28:23 +02:00
#ifdef CATCH_CONFIG_WCHAR
2014-08-14 13:28:23 +02:00
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\"" );
2014-08-14 13:28:23 +02:00
}
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\"" );
2014-08-14 13:28:23 +02:00
}
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\"" );
2014-08-14 13:28:23 +02:00
}
TEST_CASE( "toString on wchar_t returns the string contents", "[toString]" ) {
2017-12-07 01:02:19 +01:00
auto s = const_cast<wchar_t*>( L"wide load" );
std::string result = ::Catch::Detail::stringify( s );
CHECK( result == "\"wide load\"" );
}
#endif
2017-07-13 09:52:51 +02:00
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]" ) {
2016-03-14 20:13:34 +01:00
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