2010-11-10 00:24:00 +01:00
|
|
|
/*
|
|
|
|
* ConditionTests.cpp
|
|
|
|
* Catch - Test
|
|
|
|
*
|
|
|
|
* Created by Phil on 08/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)
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2010-11-12 09:12:01 +01:00
|
|
|
#include "../catch.hpp"
|
2010-11-10 00:24:00 +01:00
|
|
|
|
|
|
|
#include <string>
|
2011-03-15 23:41:27 +01:00
|
|
|
#include <limits>
|
2010-11-10 00:24:00 +01:00
|
|
|
|
|
|
|
struct TestData
|
|
|
|
{
|
|
|
|
TestData()
|
|
|
|
: int_seven( 7 ),
|
|
|
|
str_hello( "hello" ),
|
|
|
|
float_nine_point_one( 9.1f ),
|
|
|
|
double_pi( 3.1415926535 )
|
|
|
|
{}
|
|
|
|
|
|
|
|
int int_seven;
|
|
|
|
std::string str_hello;
|
|
|
|
float float_nine_point_one;
|
|
|
|
double double_pi;
|
|
|
|
};
|
|
|
|
|
2010-12-14 10:00:09 +01:00
|
|
|
// The "failing" tests all use the CHECK macro, which continues if the specific test fails.
|
|
|
|
// This allows us to see all results, even if an earlier check fails
|
2010-11-10 00:24:00 +01:00
|
|
|
|
|
|
|
// Equality tests
|
2011-01-14 09:47:43 +01:00
|
|
|
TEST_CASE( "./succeeding/conditions/equality", "Equality checks that should succeed" )
|
2010-11-10 00:24:00 +01:00
|
|
|
{
|
|
|
|
TestData data;
|
|
|
|
|
2010-12-14 10:00:09 +01:00
|
|
|
REQUIRE( data.int_seven == 7 );
|
|
|
|
REQUIRE( data.float_nine_point_one == Approx( 9.1f ) );
|
|
|
|
REQUIRE( data.double_pi == Approx( 3.1415926535 ) );
|
|
|
|
REQUIRE( data.str_hello == "hello" );
|
|
|
|
REQUIRE( data.str_hello.size() == 5 );
|
2010-11-10 00:24:00 +01:00
|
|
|
|
|
|
|
double x = 1.1 + 0.1 + 0.1;
|
2010-12-14 10:00:09 +01:00
|
|
|
REQUIRE( x == Approx( 1.3 ) );
|
2010-11-10 00:24:00 +01:00
|
|
|
}
|
|
|
|
|
2011-01-14 09:47:43 +01:00
|
|
|
TEST_CASE( "./failing/conditions/equality", "Equality checks that should fail" )
|
2010-11-10 00:24:00 +01:00
|
|
|
{
|
|
|
|
TestData data;
|
|
|
|
|
|
|
|
CHECK( data.int_seven == 6 );
|
|
|
|
CHECK( data.int_seven == 8 );
|
|
|
|
CHECK( data.int_seven == 0 );
|
|
|
|
CHECK( data.float_nine_point_one == Approx( 9.11f ) );
|
|
|
|
CHECK( data.float_nine_point_one == Approx( 9.0f ) );
|
2011-01-31 11:10:20 +01:00
|
|
|
CHECK( data.float_nine_point_one == Approx( 1 ) );
|
|
|
|
CHECK( data.float_nine_point_one == Approx( 0 ) );
|
2010-11-10 00:24:00 +01:00
|
|
|
CHECK( data.double_pi == Approx( 3.1415 ) );
|
|
|
|
CHECK( data.str_hello == "goodbye" );
|
|
|
|
CHECK( data.str_hello == "hell" );
|
|
|
|
CHECK( data.str_hello == "hello1" );
|
|
|
|
CHECK( data.str_hello.size() == 6 );
|
|
|
|
|
|
|
|
double x = 1.1 + 0.1 + 0.1;
|
|
|
|
CHECK( x == Approx( 1.301 ) );
|
|
|
|
}
|
|
|
|
|
2011-01-14 09:47:43 +01:00
|
|
|
TEST_CASE( "./succeeding/conditions/inequality", "Inequality checks that should succeed" )
|
2010-11-10 00:24:00 +01:00
|
|
|
{
|
|
|
|
TestData data;
|
|
|
|
|
2010-12-14 10:00:09 +01:00
|
|
|
REQUIRE( data.int_seven != 6 );
|
|
|
|
REQUIRE( data.int_seven != 8 );
|
|
|
|
REQUIRE( data.float_nine_point_one != Approx( 9.11f ) );
|
|
|
|
REQUIRE( data.float_nine_point_one != Approx( 9.0f ) );
|
2011-01-31 11:10:20 +01:00
|
|
|
REQUIRE( data.float_nine_point_one != Approx( 1 ) );
|
|
|
|
REQUIRE( data.float_nine_point_one != Approx( 0 ) );
|
2010-12-14 10:00:09 +01:00
|
|
|
REQUIRE( data.double_pi != Approx( 3.1415 ) );
|
|
|
|
REQUIRE( data.str_hello != "goodbye" );
|
|
|
|
REQUIRE( data.str_hello != "hell" );
|
|
|
|
REQUIRE( data.str_hello != "hello1" );
|
|
|
|
REQUIRE( data.str_hello.size() != 6 );
|
2010-11-10 00:24:00 +01:00
|
|
|
}
|
|
|
|
|
2011-01-14 09:47:43 +01:00
|
|
|
TEST_CASE( "./failing/conditions/inequality", "Inequality checks that should fails" )
|
2010-11-10 00:24:00 +01:00
|
|
|
{
|
|
|
|
TestData data;
|
|
|
|
|
|
|
|
CHECK( data.int_seven != 7 );
|
|
|
|
CHECK( data.float_nine_point_one != Approx( 9.1f ) );
|
|
|
|
CHECK( data.double_pi != Approx( 3.1415926535 ) );
|
|
|
|
CHECK( data.str_hello != "hello" );
|
|
|
|
CHECK( data.str_hello.size() != 5 );
|
|
|
|
}
|
|
|
|
|
|
|
|
// Ordering comparison tests
|
2011-01-14 09:47:43 +01:00
|
|
|
TEST_CASE( "./succeeding/conditions/ordered", "Ordering comparison checks that should succeed" )
|
2010-11-10 00:24:00 +01:00
|
|
|
{
|
|
|
|
TestData data;
|
|
|
|
|
2010-12-14 10:00:09 +01:00
|
|
|
REQUIRE( data.int_seven < 8 );
|
|
|
|
REQUIRE( data.int_seven > 6 );
|
|
|
|
REQUIRE( data.int_seven > 0 );
|
|
|
|
REQUIRE( data.int_seven > -1 );
|
2010-11-10 00:24:00 +01:00
|
|
|
|
2010-12-14 10:00:09 +01:00
|
|
|
REQUIRE( data.int_seven >= 7 );
|
|
|
|
REQUIRE( data.int_seven >= 6 );
|
|
|
|
REQUIRE( data.int_seven <= 7 );
|
|
|
|
REQUIRE( data.int_seven <= 8 );
|
2010-11-10 00:24:00 +01:00
|
|
|
|
2010-12-14 10:00:09 +01:00
|
|
|
REQUIRE( data.float_nine_point_one > 9 );
|
|
|
|
REQUIRE( data.float_nine_point_one < 10 );
|
|
|
|
REQUIRE( data.float_nine_point_one < 9.2 );
|
2010-11-10 00:24:00 +01:00
|
|
|
|
2010-12-14 10:00:09 +01:00
|
|
|
REQUIRE( data.str_hello <= "hello" );
|
|
|
|
REQUIRE( data.str_hello >= "hello" );
|
2010-11-10 00:24:00 +01:00
|
|
|
|
2010-12-14 10:00:09 +01:00
|
|
|
REQUIRE( data.str_hello < "hellp" );
|
|
|
|
REQUIRE( data.str_hello < "zebra" );
|
|
|
|
REQUIRE( data.str_hello > "hellm" );
|
|
|
|
REQUIRE( data.str_hello > "a" );
|
2010-11-10 00:24:00 +01:00
|
|
|
}
|
|
|
|
|
2011-01-14 09:47:43 +01:00
|
|
|
TEST_CASE( "./failing/conditions/ordered", "Ordering comparison checks that should fail" )
|
2010-11-10 00:24:00 +01:00
|
|
|
{
|
|
|
|
TestData data;
|
|
|
|
|
|
|
|
CHECK( data.int_seven > 7 );
|
|
|
|
CHECK( data.int_seven < 7 );
|
|
|
|
CHECK( data.int_seven > 8 );
|
|
|
|
CHECK( data.int_seven < 6 );
|
|
|
|
CHECK( data.int_seven < 0 );
|
|
|
|
CHECK( data.int_seven < -1 );
|
|
|
|
|
|
|
|
CHECK( data.int_seven >= 8 );
|
|
|
|
CHECK( data.int_seven <= 6 );
|
|
|
|
|
|
|
|
CHECK( data.float_nine_point_one < 9 );
|
|
|
|
CHECK( data.float_nine_point_one > 10 );
|
|
|
|
CHECK( data.float_nine_point_one > 9.2 );
|
|
|
|
|
|
|
|
CHECK( data.str_hello > "hello" );
|
|
|
|
CHECK( data.str_hello < "hello" );
|
|
|
|
CHECK( data.str_hello > "hellp" );
|
|
|
|
CHECK( data.str_hello > "z" );
|
|
|
|
CHECK( data.str_hello < "hellm" );
|
|
|
|
CHECK( data.str_hello < "a" );
|
|
|
|
|
|
|
|
CHECK( data.str_hello >= "z" );
|
|
|
|
CHECK( data.str_hello <= "a" );
|
|
|
|
}
|
|
|
|
|
2011-03-09 20:45:05 +01:00
|
|
|
// Comparisons with int literals
|
|
|
|
TEST_CASE( "./succeeding/conditions/int literals", "Comparisons with int literals don't warn when mixing signed/ unsigned" )
|
|
|
|
{
|
|
|
|
int i = 1;
|
|
|
|
unsigned int ui = 2;
|
|
|
|
long l = 3;
|
|
|
|
unsigned long ul = 4;
|
|
|
|
char c = 5;
|
|
|
|
unsigned char uc = 6;
|
|
|
|
|
|
|
|
REQUIRE( i == 1 );
|
|
|
|
REQUIRE( ui == 2 );
|
|
|
|
REQUIRE( l == 3 );
|
|
|
|
REQUIRE( ul == 4 );
|
|
|
|
REQUIRE( c == 5 );
|
|
|
|
REQUIRE( uc == 6 );
|
|
|
|
|
|
|
|
REQUIRE( 1 == i );
|
|
|
|
REQUIRE( 2 == ui );
|
|
|
|
REQUIRE( 3 == l );
|
|
|
|
REQUIRE( 4 == ul );
|
|
|
|
REQUIRE( 5 == c );
|
|
|
|
REQUIRE( 6 == uc );
|
|
|
|
|
|
|
|
REQUIRE( 62270208023445 > ul );
|
|
|
|
}
|
|
|
|
|
2011-03-15 23:22:19 +01:00
|
|
|
// Because we have to do some conversions when comparing certain signed/ unsigned types (to avoid
|
|
|
|
// spurious warnings when comparing integer literals with unsigned integers), we have a set of tests
|
|
|
|
// here to confirm that the behaviour is correct at the boundaries
|
|
|
|
TEST_CASE( "./succeeding/conditions/unsigned-negative", "Comparisons between negative signed and unsigned ints, expected to succeed" )
|
|
|
|
{
|
|
|
|
using namespace Catch::Generators;
|
|
|
|
|
|
|
|
int negative = GENERATE( values( -1, -2, (std::numeric_limits<int>::min)() ) );
|
|
|
|
unsigned int ui = GENERATE( values( 0u, 1u, 2u, (std::numeric_limits<unsigned int>::max)() ) );
|
|
|
|
|
|
|
|
CHECK( ui > negative );
|
|
|
|
CHECK( negative < ui );
|
|
|
|
CHECK( ui >= negative );
|
|
|
|
CHECK( negative <= ui );
|
|
|
|
CHECK( ui != negative );
|
|
|
|
CHECK( negative != ui );
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_CASE( "./failing/conditions/unsigned-negative", "Comparisons between negative signed and unsigned ints, expected to fail" )
|
|
|
|
{
|
|
|
|
using namespace Catch::Generators;
|
|
|
|
|
|
|
|
int negative = GENERATE( values( -1, -2, (std::numeric_limits<int>::min)() ) );
|
|
|
|
unsigned int ui = GENERATE( values( 0u, 1u, 2u, (std::numeric_limits<unsigned int>::max)() ) );
|
|
|
|
|
|
|
|
CHECK( ui < negative );
|
|
|
|
CHECK( negative > ui );
|
|
|
|
CHECK( ui <= negative );
|
|
|
|
CHECK( negative >= ui );
|
|
|
|
CHECK( ui == negative );
|
|
|
|
CHECK( negative == ui );
|
|
|
|
}
|
|
|
|
|
2011-03-18 15:39:58 +01:00
|
|
|
TEST_CASE( "./succeeding/conditions/ptr", "Pointers can be compared to null" )
|
|
|
|
{
|
|
|
|
TestData* p = NULL;
|
|
|
|
TestData* pNULL = NULL;
|
|
|
|
|
|
|
|
REQUIRE( p == NULL );
|
|
|
|
REQUIRE( p == pNULL );
|
|
|
|
|
|
|
|
TestData data;
|
|
|
|
p = &data;
|
|
|
|
REQUIRE( p != NULL );
|
|
|
|
}
|
|
|
|
|
2010-11-10 00:24:00 +01:00
|
|
|
// Not (!) tests
|
2010-11-10 08:59:07 +01:00
|
|
|
// The problem with the ! operator is that it has right-to-left associativity.
|
2010-12-14 10:05:51 +01:00
|
|
|
// This means we can't isolate it when we decompose. The simple REQUIRE( !false ) form, therefore,
|
2010-11-10 08:59:07 +01:00
|
|
|
// cannot have the operand value extracted. The test will work correctly, and the situation
|
|
|
|
// is detected and a warning issued.
|
2010-12-14 10:00:09 +01:00
|
|
|
// An alternative form of the macros (CHECK_FALSE and REQUIRE_FALSE) can be used instead to capture
|
2010-11-10 08:59:07 +01:00
|
|
|
// the operand value.
|
2011-01-14 09:47:43 +01:00
|
|
|
TEST_CASE( "./succeeding/conditions/not", "'Not' checks that should succeed" )
|
2010-11-10 00:24:00 +01:00
|
|
|
{
|
|
|
|
bool falseValue = false;
|
|
|
|
|
2010-12-14 10:00:09 +01:00
|
|
|
REQUIRE( !false );
|
|
|
|
REQUIRE_FALSE( false );
|
2010-11-10 00:24:00 +01:00
|
|
|
|
2010-12-14 10:00:09 +01:00
|
|
|
REQUIRE( !falseValue );
|
|
|
|
REQUIRE_FALSE( falseValue );
|
2010-11-10 00:24:00 +01:00
|
|
|
|
2010-12-14 10:00:09 +01:00
|
|
|
REQUIRE( !(1 == 2) );
|
|
|
|
REQUIRE_FALSE( 1 == 2 );
|
2010-11-10 00:24:00 +01:00
|
|
|
}
|
|
|
|
|
2011-01-14 09:47:43 +01:00
|
|
|
TEST_CASE( "./failing/conditions/not", "'Not' checks that should fail" )
|
2010-11-10 00:24:00 +01:00
|
|
|
{
|
|
|
|
bool trueValue = true;
|
|
|
|
|
|
|
|
CHECK( !true );
|
2010-12-14 10:00:09 +01:00
|
|
|
CHECK_FALSE( true );
|
2010-11-10 00:24:00 +01:00
|
|
|
|
|
|
|
CHECK( !trueValue );
|
2010-12-14 10:00:09 +01:00
|
|
|
CHECK_FALSE( trueValue );
|
2010-11-10 00:24:00 +01:00
|
|
|
|
|
|
|
CHECK( !(1 == 1) );
|
2010-12-14 10:00:09 +01:00
|
|
|
CHECK_FALSE( 1 == 1 );
|
2010-11-10 00:24:00 +01:00
|
|
|
}
|
|
|
|
|