2010-11-29 20:40:44 +01:00
/*
* 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)
*/
2012-08-16 19:47:41 +02:00
2011-04-26 09:32:40 +02:00
# include "catch.hpp"
2010-11-29 20:40:44 +01:00
2014-05-19 19:57:14 +02:00
# ifdef __clang__
2015-08-07 09:20:56 +02:00
# pragma clang diagnostic ignored "-Wc++98-compat"
# pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
2014-05-19 19:57:14 +02:00
# endif
2015-08-07 18:28:48 +02:00
# include "../include/internal/catch_xmlwriter.hpp"
2015-08-07 09:20:56 +02:00
# include <iostream>
2013-11-19 08:21:03 +01:00
TEST_CASE ( " random SECTION tests " , " [.][sections][failing] " )
2010-11-29 20:40:44 +01:00
{
int a = 1 ;
int b = 2 ;
2015-11-04 19:01:28 +01:00
2010-11-29 20:40:44 +01:00
SECTION ( " s1 " , " doesn't equal " )
{
2010-12-14 10:00:09 +01:00
REQUIRE ( a ! = b ) ;
REQUIRE ( b ! = a ) ;
2010-11-29 20:40:44 +01:00
}
2010-11-30 07:48:21 +01:00
2010-11-29 20:40:44 +01:00
SECTION ( " s2 " , " not equal " )
{
2011-02-17 21:15:20 +01:00
REQUIRE ( a ! = b ) ;
2010-11-29 20:40:44 +01:00
}
}
2010-11-30 07:48:21 +01:00
2013-11-19 08:21:03 +01:00
TEST_CASE ( " nested SECTION tests " , " [.][sections][failing] " )
2010-12-15 20:36:39 +01:00
{
int a = 1 ;
int b = 2 ;
2015-11-04 19:01:28 +01:00
2010-12-15 20:36:39 +01:00
SECTION ( " s1 " , " 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 ( " s2 " , " not equal " )
{
2011-02-17 21:15:20 +01:00
REQUIRE ( a ! = b ) ;
}
}
}
2013-11-19 08:21:03 +01:00
TEST_CASE ( " more nested SECTION tests " , " [sections][failing][.] " )
2011-02-17 21:15:20 +01:00
{
int a = 1 ;
int b = 2 ;
2015-11-04 19:01:28 +01:00
2011-02-17 21:15:20 +01:00
SECTION ( " s1 " , " doesn't equal " )
{
SECTION ( " s2 " , " equal " )
{
2011-02-21 09:50:05 +01:00
REQUIRE ( a = = b ) ;
2011-02-17 21:15:20 +01:00
}
SECTION ( " s3 " , " not equal " )
{
2011-02-21 09:50:05 +01:00
REQUIRE ( a ! = b ) ;
}
SECTION ( " s4 " , " less than " )
{
2011-02-28 09:18:52 +01:00
REQUIRE ( a < b ) ;
2010-12-15 20:36:39 +01:00
}
}
}
2013-11-19 08:21:03 +01:00
TEST_CASE ( " even more nested SECTION tests " , " [sections] " )
2012-05-04 08:55:11 +02:00
{
SECTION ( " c " , " " )
{
SECTION ( " d (leaf) " , " " )
{
2015-11-03 08:46:37 +01:00
SUCCEED ( " " ) ; // avoid failing due to no tests
2012-05-04 08:55:11 +02:00
}
2015-11-04 19:01:28 +01:00
2012-05-04 08:55:11 +02:00
SECTION ( " e (leaf) " , " " )
{
2015-11-03 08:46:37 +01:00
SUCCEED ( " " ) ; // avoid failing due to no tests
2012-05-04 08:55:11 +02:00
}
}
SECTION ( " f (leaf) " , " " )
{
2015-11-03 08:46:37 +01:00
SUCCEED ( " " ) ; // avoid failing due to no tests
2012-05-04 08:55:11 +02:00
}
}
2013-11-19 08:21:03 +01:00
TEST_CASE ( " looped SECTION tests " , " [.][failing][sections] " )
2010-12-28 15:41:57 +01:00
{
int a = 1 ;
2015-11-04 19:01:28 +01:00
2010-12-28 15:41:57 +01:00
for ( int b = 0 ; b < 10 ; + + b )
{
std : : ostringstream oss ;
oss < < " b is currently: " < < b ;
SECTION ( " s1 " , oss . str ( ) )
{
2015-11-04 19:01:28 +01:00
CHECK ( b > a ) ;
2010-12-28 15:41:57 +01:00
}
}
}
2013-11-19 08:21:03 +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 } ;
2015-11-04 19:01:28 +01:00
2010-12-28 15:41:57 +01:00
for ( size_t i = 0 ; i < sizeof ( fib ) / sizeof ( int ) ; + + i )
{
INFO ( " Testing if fib[ " < < i < < " ] ( " < < fib [ i ] < < " ) is even " ) ;
2015-11-04 19:01:28 +01:00
CHECK ( ( fib [ i ] % 2 ) = = 0 ) ;
2010-12-28 15:41:57 +01:00
}
}
2014-05-16 07:50:00 +02:00
TEST_CASE ( " Sends stuff to stdout and stderr " , " [.] " )
2010-11-30 07:48:21 +01:00
{
2013-12-19 09:07:33 +01:00
std : : cout < < " A string sent directly to stdout " < < std : : endl ;
2015-11-04 19:01:28 +01:00
2013-12-19 09:07:33 +01:00
std : : cerr < < " A string sent directly to stderr " < < std : : endl ;
2010-12-28 15:41:57 +01:00
}
2011-02-23 21:02:18 +01:00
2011-12-27 11:59:41 +01:00
inline const char * makeString ( bool makeNull )
2011-02-23 21:02:18 +01:00
{
2015-07-01 08:33:27 +02:00
return makeNull ? CATCH_NULL : " valid string " ;
2011-02-23 21:02:18 +01:00
}
2013-11-19 08:21:03 +01:00
TEST_CASE ( " null strings " , " " )
2011-02-23 21:02:18 +01:00
{
2015-07-01 08:33:27 +02:00
REQUIRE ( makeString ( false ) ! = static_cast < char * > ( CATCH_NULL ) ) ;
REQUIRE ( makeString ( true ) = = static_cast < char * > ( CATCH_NULL ) ) ;
2011-02-23 21:02:18 +01:00
}
2011-03-09 20:45:05 +01:00
2012-02-10 09:30:13 +01:00
inline bool testCheckedIf ( bool flag )
{
CHECKED_IF ( flag )
return true ;
else
return false ;
}
2013-11-19 08:21:03 +01:00
TEST_CASE ( " checkedIf " , " " )
2012-02-10 09:30:13 +01:00
{
REQUIRE ( testCheckedIf ( true ) ) ;
}
2013-11-19 08:21:03 +01:00
TEST_CASE ( " checkedIf, failing " , " [failing][.] " )
2012-02-10 09:30:13 +01:00
{
REQUIRE ( testCheckedIf ( false ) ) ;
}
inline bool testCheckedElse ( bool flag )
{
CHECKED_ELSE ( flag )
return false ;
2015-11-04 19:01:28 +01:00
2012-02-10 09:30:13 +01:00
return true ;
}
2013-11-19 08:21:03 +01:00
TEST_CASE ( " checkedElse " , " " )
2012-02-10 09:30:13 +01:00
{
REQUIRE ( testCheckedElse ( true ) ) ;
}
2013-11-19 08:21:03 +01:00
TEST_CASE ( " checkedElse, failing " , " [failing][.] " )
2012-02-10 09:30:13 +01:00
{
REQUIRE ( testCheckedElse ( false ) ) ;
}
2012-02-10 19:58:06 +01:00
2013-11-19 08:21:03 +01:00
TEST_CASE ( " xmlentitycheck " , " " )
2012-02-10 19:58:06 +01:00
{
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> " )
{
2015-11-03 08:46:37 +01:00
SUCCEED ( " " ) ; // We need this here to stop it failing due to no tests
2012-02-10 19:58:06 +01:00
}
SECTION ( " encoded chars " , " these should all be encoded: &&& \" \" \" <<<& \" <<& \" " )
{
2015-11-03 08:46:37 +01:00
SUCCEED ( " " ) ; // We need this here to stop it failing due to no tests
2012-02-10 19:58:06 +01:00
}
}
2012-02-28 21:04:25 +01:00
2013-11-19 08:21:03 +01:00
TEST_CASE ( " send a single char to INFO " , " [failing][.] " )
2012-02-28 21:04:25 +01:00
{
INFO ( 3 ) ;
2015-11-04 19:01:28 +01:00
REQUIRE ( false ) ;
2012-02-28 21:04:25 +01:00
}
2012-02-29 09:39:22 +01:00
2013-11-19 08:21:03 +01:00
TEST_CASE ( " atomic if " , " [failing][0] " )
2012-02-29 09:39:22 +01:00
{
size_t x = 0 ;
2015-11-04 19:01:28 +01:00
2012-02-29 09:39:22 +01:00
if ( x )
REQUIRE ( x > 0 ) ;
else
REQUIRE ( x = = 0 ) ;
}
2012-03-04 12:14:21 +01:00
2012-03-04 21:10:36 +01:00
inline const char * testStringForMatching ( )
{
return " this string contains 'abc' as a substring " ;
}
2015-11-05 19:46:00 +01:00
inline const char * testStringForMatching2 ( )
{
return " some completely different text that contains one common word " ;
}
2015-11-05 19:10:33 +01:00
using namespace Catch : : Matchers ;
2012-03-04 21:10:36 +01:00
2013-11-19 08:21:03 +01:00
TEST_CASE ( " String matchers " , " [matchers] " )
2012-03-17 19:20:06 +01:00
{
2015-11-04 19:01:28 +01:00
REQUIRE_THAT ( testStringForMatching ( ) , Contains ( " string " ) ) ;
2012-03-04 21:10:36 +01:00
CHECK_THAT ( testStringForMatching ( ) , Contains ( " abc " ) ) ;
CHECK_THAT ( testStringForMatching ( ) , StartsWith ( " this " ) ) ;
CHECK_THAT ( testStringForMatching ( ) , EndsWith ( " substring " ) ) ;
2012-03-04 12:14:21 +01:00
}
2013-11-19 08:21:03 +01:00
TEST_CASE ( " Contains string matcher " , " [.][failing][matchers] " )
2012-03-04 21:10:36 +01:00
{
CHECK_THAT ( testStringForMatching ( ) , Contains ( " not there " ) ) ;
}
2012-03-04 12:14:21 +01:00
2013-11-19 08:21:03 +01:00
TEST_CASE ( " StartsWith string matcher " , " [.][failing][matchers] " )
2012-03-04 21:10:36 +01:00
{
CHECK_THAT ( testStringForMatching ( ) , StartsWith ( " string " ) ) ;
}
2012-03-04 12:14:21 +01:00
2013-11-19 08:21:03 +01:00
TEST_CASE ( " EndsWith string matcher " , " [.][failing][matchers] " )
2012-03-04 12:14:21 +01:00
{
2012-03-04 21:10:36 +01:00
CHECK_THAT ( testStringForMatching ( ) , EndsWith ( " this " ) ) ;
2012-03-04 12:14:21 +01:00
}
2012-05-24 09:29:03 +02:00
2013-11-19 08:21:03 +01:00
TEST_CASE ( " Equals string matcher " , " [.][failing][matchers] " )
2012-05-24 09:29:03 +02:00
{
CHECK_THAT ( testStringForMatching ( ) , Equals ( " something else " ) ) ;
}
2013-11-19 08:21:03 +01:00
TEST_CASE ( " Equals string matcher, with NULL " , " [matchers] " )
2013-04-23 08:59:56 +02:00
{
2015-07-01 08:33:27 +02:00
REQUIRE_THAT ( " " , Equals ( CATCH_NULL ) ) ;
2013-04-23 08:59:56 +02:00
}
2013-11-19 08:21:03 +01:00
TEST_CASE ( " AllOf matcher " , " [matchers] " )
2012-10-12 08:58:17 +02:00
{
CHECK_THAT ( testStringForMatching ( ) , AllOf ( Catch : : Contains ( " string " ) , Catch : : Contains ( " abc " ) ) ) ;
}
2013-11-19 08:21:03 +01:00
TEST_CASE ( " AnyOf matcher " , " [matchers] " )
2012-10-12 08:58:17 +02:00
{
CHECK_THAT ( testStringForMatching ( ) , AnyOf ( Catch : : Contains ( " string " ) , Catch : : Contains ( " not there " ) ) ) ;
CHECK_THAT ( testStringForMatching ( ) , AnyOf ( Catch : : Contains ( " not there " ) , Catch : : Contains ( " string " ) ) ) ;
}
2013-11-19 08:21:03 +01:00
TEST_CASE ( " Equals " , " [matchers] " )
2012-05-24 09:29:03 +02:00
{
CHECK_THAT ( testStringForMatching ( ) , Equals ( " this string contains 'abc' as a substring " ) ) ;
}
2012-05-31 20:40:26 +02:00
2015-11-06 07:54:15 +01:00
TEST_CASE ( " Matchers can be (AllOf) composed with the && operator " , " [matchers][operators][operator&&] " )
2015-11-05 19:46:00 +01:00
{
CHECK_THAT ( testStringForMatching ( ) ,
Contains ( " string " ) & &
Contains ( " abc " ) & &
Contains ( " substring " ) & &
Contains ( " contains " ) ) ;
}
2015-11-06 07:54:15 +01:00
TEST_CASE ( " Matchers can be (AnyOf) composed with the || operator " , " [matchers][operators][operator||] " )
2015-11-05 19:46:00 +01:00
{
CHECK_THAT ( testStringForMatching ( ) , Contains ( " string " ) | | Contains ( " different " ) | | Contains ( " random " ) ) ;
CHECK_THAT ( testStringForMatching2 ( ) , Contains ( " string " ) | | Contains ( " different " ) | | Contains ( " random " ) ) ;
}
2015-11-06 07:54:15 +01:00
TEST_CASE ( " Matchers can be composed with both && and || " , " [matchers][operators][operator||][operator&&] " )
2015-11-05 19:46:00 +01:00
{
CHECK_THAT ( testStringForMatching ( ) , ( Contains ( " string " ) | | Contains ( " different " ) ) & & Contains ( " substring " ) ) ;
}
2015-11-06 07:54:15 +01:00
TEST_CASE ( " Matchers can be composed with both && and || - failing " , " [matchers][operators][operator||][operator&&][.failing] " )
2015-11-05 19:46:00 +01:00
{
CHECK_THAT ( testStringForMatching ( ) , ( Contains ( " string " ) | | Contains ( " different " ) ) & & Contains ( " random " ) ) ;
}
TEST_CASE ( " Matchers can be negated (Not) with the ! operator " , " [matchers][operators][not] " )
{
CHECK_THAT ( testStringForMatching ( ) , ! Contains ( " different " ) ) ;
}
TEST_CASE ( " Matchers can be negated (Not) with the ! operator - failing " , " [matchers][operators][not][.failing] " )
{
CHECK_THAT ( testStringForMatching ( ) , ! Contains ( " substring " ) ) ;
}
2012-05-31 20:40:26 +02:00
inline unsigned int Factorial ( unsigned int number )
{
// return number <= 1 ? number : Factorial(number-1)*number;
return number > 1 ? Factorial ( number - 1 ) * number : 1 ;
}
2013-06-04 09:37:28 +02:00
TEST_CASE ( " Factorials are computed " , " [factorial] " ) {
2012-05-31 20:40:26 +02:00
REQUIRE ( Factorial ( 0 ) = = 1 ) ;
REQUIRE ( Factorial ( 1 ) = = 1 ) ;
REQUIRE ( Factorial ( 2 ) = = 2 ) ;
REQUIRE ( Factorial ( 3 ) = = 6 ) ;
REQUIRE ( Factorial ( 10 ) = = 3628800 ) ;
}
2012-08-31 09:10:36 +02:00
2013-11-19 08:21:03 +01:00
TEST_CASE ( " An empty test with no assertions " , " [empty] " )
2012-08-31 09:10:36 +02:00
{
}
2012-09-15 18:53:27 +02:00
2013-06-28 17:05:13 +02:00
TEST_CASE ( " Nice descriptive name " , " [tag1][tag2][tag3][.] " )
2012-09-15 18:53:27 +02:00
{
WARN ( " This one ran " ) ;
}
2012-09-26 19:38:26 +02:00
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 ) ;
2015-11-04 19:01:28 +01:00
2013-03-25 09:47:36 +01:00
REQUIRE ( v . size ( ) = = 5 ) ;
REQUIRE ( v . capacity ( ) > = 5 ) ;
2015-11-04 19:01:28 +01:00
2013-03-25 09:47:36 +01:00
SECTION ( " resizing bigger changes size and capacity " , " " ) {
v . resize ( 10 ) ;
2015-11-04 19:01:28 +01:00
2013-03-25 09:47:36 +01:00
REQUIRE ( v . size ( ) = = 10 ) ;
REQUIRE ( v . capacity ( ) > = 10 ) ;
}
SECTION ( " resizing smaller changes size but not capacity " , " " ) {
v . resize ( 0 ) ;
2015-11-04 19:01:28 +01:00
2013-03-25 09:47:36 +01:00
REQUIRE ( v . size ( ) = = 0 ) ;
REQUIRE ( v . capacity ( ) > = 5 ) ;
2015-11-04 19:01:28 +01:00
2013-03-25 09:47:36 +01:00
SECTION ( " We can use the 'swap trick' to reset the capacity " , " " ) {
std : : vector < int > empty ;
empty . swap ( v ) ;
2015-11-04 19:01:28 +01:00
2013-03-25 09:47:36 +01:00
REQUIRE ( v . capacity ( ) = = 0 ) ;
}
}
SECTION ( " reserving bigger changes capacity but not size " , " " ) {
v . reserve ( 10 ) ;
2015-11-04 19:01:28 +01:00
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 ) ;
2015-11-04 19:01:28 +01:00
2013-03-25 09:47:36 +01:00
REQUIRE ( v . size ( ) = = 5 ) ;
REQUIRE ( v . capacity ( ) > = 5 ) ;
}
}
2013-05-13 09:20:45 +02:00
// https://github.com/philsquared/Catch/issues/166
2013-11-19 08:21:03 +01:00
TEST_CASE ( " A couple of nested sections followed by a failure " , " [failing][.] " )
2013-07-24 20:13:08 +02:00
{
SECTION ( " Outer " , " " )
SECTION ( " Inner " , " " )
SUCCEED ( " that's not flying - that's failing in style " ) ;
FAIL ( " to infinity and beyond " ) ;
}
2014-04-15 19:44:37 +02:00
TEST_CASE ( " not allowed " , " [!throws] " )
{
// This test case should not be included if you run with -e on the command line
2014-06-30 08:53:11 +02:00
SUCCEED ( " " ) ;
2014-04-15 19:44:37 +02:00
}
2014-04-22 09:19:11 +02:00
//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
TEST_CASE ( " toString on const wchar_t const pointer returns the string contents " , " [toString] " ) {
const wchar_t * const s = L " wide load " ;
2014-08-14 13:53:21 +02:00
std : : string result = Catch : : toString ( s ) ;
2014-08-14 13:28:23 +02:00
CHECK ( result = = " \" wide load \" " ) ;
}
TEST_CASE ( " toString on const wchar_t pointer returns the string contents " , " [toString] " ) {
const wchar_t * s = L " wide load " ;
2014-08-14 13:53:21 +02:00
std : : string result = Catch : : toString ( s ) ;
2014-08-14 13:28:23 +02:00
CHECK ( result = = " \" wide load \" " ) ;
}
TEST_CASE ( " toString on wchar_t const pointer returns the string contents " , " [toString] " ) {
2014-08-19 09:16:44 +02:00
wchar_t * const s = const_cast < wchar_t * const > ( L " wide load " ) ;
2014-08-14 13:53:21 +02:00
std : : string result = Catch : : toString ( s ) ;
2014-08-14 13:28:23 +02:00
CHECK ( result = = " \" wide load \" " ) ;
}
TEST_CASE ( " toString on wchar_t returns the string contents " , " [toString] " ) {
2014-08-19 09:16:44 +02:00
wchar_t * s = const_cast < wchar_t * > ( L " wide load " ) ;
2014-08-14 13:53:21 +02:00
std : : string result = Catch : : toString ( s ) ;
2014-08-14 13:28:23 +02:00
CHECK ( result = = " \" wide load \" " ) ;
2014-08-19 09:16:44 +02:00
}
2014-08-22 09:07:39 +02:00
2015-07-23 19:45:31 +02:00
inline std : : string encode ( std : : string const & str , Catch : : XmlEncode : : ForWhat forWhat = Catch : : XmlEncode : : ForTextNodes ) {
std : : ostringstream oss ;
oss < < Catch : : XmlEncode ( str , forWhat ) ;
return oss . str ( ) ;
}
TEST_CASE ( " XmlEncode " ) {
SECTION ( " normal string " ) {
REQUIRE ( encode ( " normal string " ) = = " normal string " ) ;
}
SECTION ( " empty string " ) {
REQUIRE ( encode ( " " ) = = " " ) ;
}
SECTION ( " string with ampersand " ) {
REQUIRE ( encode ( " smith & jones " ) = = " smith & jones " ) ;
}
SECTION ( " string with less-than " ) {
REQUIRE ( encode ( " smith < jones " ) = = " smith < jones " ) ;
}
SECTION ( " string with greater-than " ) {
REQUIRE ( encode ( " smith > jones " ) = = " smith > jones " ) ;
REQUIRE ( encode ( " smith ]]> jones " ) = = " smith ]]> jones " ) ;
}
SECTION ( " string with quotes " ) {
std : : string stringWithQuotes = " don't \" quote \" me on that " ;
REQUIRE ( encode ( stringWithQuotes ) = = stringWithQuotes ) ;
REQUIRE ( encode ( stringWithQuotes , Catch : : XmlEncode : : ForAttributes ) = = " don't "quote" me on that " ) ;
}
SECTION ( " string with control char (1) " ) {
REQUIRE ( encode ( " [ \x01 ] " ) = = " [] " ) ;
}
SECTION ( " string with control char (x7F) " ) {
REQUIRE ( encode ( " [ \x7F ] " ) = = " [] " ) ;
}
}
2015-07-23 20:03:33 +02:00
# ifdef CATCH_CONFIG_CPP11_LONG_LONG
TEST_CASE ( " long long " ) {
long long l = std : : numeric_limits < long long > : : max ( ) ;
2015-11-04 19:01:28 +01:00
2015-07-23 20:03:33 +02:00
REQUIRE ( l = = std : : numeric_limits < long long > : : max ( ) ) ;
}
# endif
2014-08-22 09:13:15 +02:00
//TEST_CASE( "Divide by Zero signal handler", "[.][sig]" ) {
// int i = 0;
// int x = 10/i; // This should cause the signal to fire
// CHECK( x == 0 );
//}
2016-03-14 20:13:34 +01:00
TEST_CASE ( " This test 'should' fail but doesn't " , " [.][failing][!shouldfail] " )
{
SUCCEED ( " oops! " ) ;
}