Skip to content
Browse files

Made the unit test's output more readable, adding to jsontest's

capabilities (and simplifying its implementation) in the process.

git-svn-id: https://jsoncpp.svn.sourceforge.net/svnroot/jsoncpp/trunk@223 1f120ed1-78a5-a849-adca-83f0a9e25bb6
  • Loading branch information...
1 parent 3df0a17 commit 1da375d63c442bae17d69a78c8775f5e025f9dc6 aaronjacobs committed with rjeczalik May 26, 2011
Showing with 205 additions and 269 deletions.
  1. +0 −68 src/test_lib_json/jsontest.cpp
  2. +16 −12 src/test_lib_json/jsontest.h
  3. +189 −189 src/test_lib_json/main.cpp
View
68 src/test_lib_json/jsontest.cpp
@@ -250,74 +250,6 @@ TestResult::addToLastFailure( const std::string &message )
}
-TestResult &
-TestResult::operator << ( bool value )
-{
- return addToLastFailure( value ? "true" : "false" );
-}
-
-
-TestResult &
-TestResult::operator << ( int value )
-{
- char buffer[32];
- sprintf( buffer, "%d", value );
- return addToLastFailure( buffer );
-}
-
-
-TestResult &
-TestResult::operator << ( unsigned int value )
-{
- char buffer[32];
- sprintf( buffer, "%u", value );
- return addToLastFailure( buffer );
-}
-
-
-#ifdef JSON_HAS_INT64
-TestResult &
-TestResult::operator << ( Json::Int64 value )
-{
- char buffer[32];
- sprintf( buffer, "%lld", value );
- return addToLastFailure( buffer );
-}
-
-TestResult &
-TestResult::operator << ( Json::UInt64 value )
-{
- char buffer[32];
- sprintf( buffer, "%ull", value );
- return addToLastFailure( buffer );
-}
-#endif
-
-
-TestResult &
-TestResult::operator << ( double value )
-{
- char buffer[32];
- sprintf( buffer, "%16g", value );
- return addToLastFailure( buffer );
-}
-
-
-TestResult &
-TestResult::operator << ( const char *value )
-{
- return addToLastFailure( value ? value
- : "<NULL>" );
-}
-
-
-TestResult &
-TestResult::operator << ( const std::string &value )
-{
- return addToLastFailure( value );
-}
-
-
// class TestCase
// //////////////////////////////////////////////////////////////////
View
28 src/test_lib_json/jsontest.h
@@ -7,8 +7,10 @@
# define JSONTEST_H_INCLUDED
# include <json/config.h>
+# include <json/value.h>
# include <stdio.h>
# include <deque>
+# include <sstream>
# include <string>
// //////////////////////////////////////////////////////////////////
@@ -84,16 +86,18 @@ namespace JsonTest {
void printFailure( bool printTestName ) const;
- TestResult &operator << ( bool value );
- TestResult &operator << ( int value );
- TestResult &operator << ( unsigned int value );
-#ifdef JSON_HAS_INT64
- TestResult &operator << ( Json::Int64 value );
- TestResult &operator << ( Json::UInt64 value );
-#endif
- TestResult &operator << ( double value );
- TestResult &operator << ( const char *value );
- TestResult &operator << ( const std::string &value );
+ // Generic operator that will work with anything ostream can deal with.
+ template <typename T>
+ TestResult &operator << ( const T& value ) {
+ std::ostringstream oss;
+ oss << value;
+ return addToLastFailure(oss.str());
+ }
+
+ // Specialized versions.
+ TestResult &operator << ( bool value ) {
+ return addToLastFailure(value ? "true" : "false");
+ }
private:
TestResult &addToLastFailure( const std::string &message );
@@ -177,9 +181,9 @@ namespace JsonTest {
Factories tests_;
};
- template<typename T>
+ template<typename T, typename U>
TestResult &
- checkEqual( TestResult &result, const T &expected, const T &actual,
+ checkEqual( TestResult &result, const T &expected, const U &actual,
const char *file, unsigned int line, const char *expr )
{
if ( expected != actual )
View
378 src/test_lib_json/main.cpp
@@ -119,20 +119,20 @@ JSONTEST_FIXTURE( ValueTest, objects )
JSONTEST_ASSERT_PRED( checkIs( emptyObject_, checks ) );
JSONTEST_ASSERT_PRED( checkIs( object1_, checks ) );
- JSONTEST_ASSERT_EQUAL( Json::objectValue, emptyObject_.type());
+ JSONTEST_ASSERT_EQUAL(Json::objectValue, emptyObject_.type());
// Access through const reference
const Json::Value &constObject = object1_;
- JSONTEST_ASSERT( Json::Value(1234) == constObject["id"] );
- JSONTEST_ASSERT( Json::Value() == constObject["unknown id"] );
+ JSONTEST_ASSERT_EQUAL(Json::Value(1234), constObject["id"]);
+ JSONTEST_ASSERT_EQUAL(Json::Value(), constObject["unknown id"]);
// Access through non-const reference
- JSONTEST_ASSERT( Json::Value(1234) == object1_["id"] );
- JSONTEST_ASSERT( Json::Value() == object1_["unknown id"] );
+ JSONTEST_ASSERT_EQUAL(Json::Value(1234), object1_["id"]);
+ JSONTEST_ASSERT_EQUAL(Json::Value(), object1_["unknown id"]);
object1_["some other id"] = "foo";
- JSONTEST_ASSERT( Json::Value("foo") == object1_["some other id"] );
+ JSONTEST_ASSERT_EQUAL(Json::Value("foo"), object1_["some other id"]);
}
@@ -146,26 +146,26 @@ JSONTEST_FIXTURE( ValueTest, arrays )
JSONTEST_ASSERT_PRED( checkIs( emptyArray_, checks ) );
JSONTEST_ASSERT_PRED( checkIs( array1_, checks ) );
- JSONTEST_ASSERT_EQUAL( Json::arrayValue, array1_.type());
+ JSONTEST_ASSERT_EQUAL(Json::arrayValue, array1_.type());
// Access through const reference
const Json::Value &constArray = array1_;
- JSONTEST_ASSERT( Json::Value(1234) == constArray[index0] );
- JSONTEST_ASSERT( Json::Value(1234) == constArray[0] );
+ JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray[index0]);
+ JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray[0]);
// Access through non-const reference
- JSONTEST_ASSERT( Json::Value(1234) == array1_[index0] );
- JSONTEST_ASSERT( Json::Value(1234) == array1_[0] );
+ JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_[index0]);
+ JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_[0]);
array1_[2] = Json::Value(17);
- JSONTEST_ASSERT( Json::Value() == array1_[1] );
- JSONTEST_ASSERT( Json::Value(17) == array1_[2] );
+ JSONTEST_ASSERT_EQUAL(Json::Value(), array1_[1]);
+ JSONTEST_ASSERT_EQUAL(Json::Value(17), array1_[2]);
}
JSONTEST_FIXTURE( ValueTest, null )
{
- JSONTEST_ASSERT_EQUAL( Json::nullValue, null_.type());
+ JSONTEST_ASSERT_EQUAL(Json::nullValue, null_.type());
IsCheck checks;
checks.isNull_ = true;
@@ -175,30 +175,30 @@ JSONTEST_FIXTURE( ValueTest, null )
JSONTEST_FIXTURE( ValueTest, strings )
{
- JSONTEST_ASSERT_EQUAL( Json::stringValue, string1_.type());
+ JSONTEST_ASSERT_EQUAL(Json::stringValue, string1_.type());
IsCheck checks;
checks.isString_ = true;
JSONTEST_ASSERT_PRED( checkIs( emptyString_, checks ) );
JSONTEST_ASSERT_PRED( checkIs( string_, checks ) );
JSONTEST_ASSERT_PRED( checkIs( string1_, checks ) );
- JSONTEST_ASSERT( std::string("a") == string1_.asString());
- JSONTEST_ASSERT( std::string("a") == string1_.asCString());
+ JSONTEST_ASSERT_STRING_EQUAL("a", string1_.asString());
+ JSONTEST_ASSERT_STRING_EQUAL("a", string1_.asCString());
}
JSONTEST_FIXTURE( ValueTest, bools )
{
- JSONTEST_ASSERT_EQUAL( Json::booleanValue, false_.type());
+ JSONTEST_ASSERT_EQUAL(Json::booleanValue, false_.type());
IsCheck checks;
checks.isBool_ = true;
JSONTEST_ASSERT_PRED( checkIs( false_, checks ) );
JSONTEST_ASSERT_PRED( checkIs( true_, checks ) );
- JSONTEST_ASSERT( true == true_.asBool());
- JSONTEST_ASSERT( false == false_.asBool());
+ JSONTEST_ASSERT_EQUAL(true, true_.asBool());
+ JSONTEST_ASSERT_EQUAL(false, false_.asBool());
}
@@ -222,12 +222,12 @@ JSONTEST_FIXTURE( ValueTest, integers )
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
- JSONTEST_ASSERT( 0 == val.asInt());
- JSONTEST_ASSERT( 0 == val.asLargestInt());
- JSONTEST_ASSERT( 0 == val.asUInt());
- JSONTEST_ASSERT( 0 == val.asLargestUInt());
- JSONTEST_ASSERT( 0.0 == val.asDouble());
- JSONTEST_ASSERT( 0.0 == val.asFloat());
+ JSONTEST_ASSERT_EQUAL(0, val.asInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asUInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
+ JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
// Default uint
val = Json::Value(Json::uintValue);
@@ -244,12 +244,12 @@ JSONTEST_FIXTURE( ValueTest, integers )
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
- JSONTEST_ASSERT( 0 == val.asInt());
- JSONTEST_ASSERT( 0 == val.asLargestInt());
- JSONTEST_ASSERT( 0 == val.asUInt());
- JSONTEST_ASSERT( 0 == val.asLargestUInt());
- JSONTEST_ASSERT( 0.0 == val.asDouble());
- JSONTEST_ASSERT( 0.0 == val.asFloat());
+ JSONTEST_ASSERT_EQUAL(0, val.asInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asUInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
+ JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
// Default real
val = Json::Value(Json::realValue);
@@ -266,17 +266,17 @@ JSONTEST_FIXTURE( ValueTest, integers )
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
- JSONTEST_ASSERT( 0 == val.asInt());
- JSONTEST_ASSERT( 0 == val.asLargestInt());
- JSONTEST_ASSERT( 0 == val.asUInt());
- JSONTEST_ASSERT( 0 == val.asLargestUInt());
- JSONTEST_ASSERT( 0.0 == val.asDouble());
- JSONTEST_ASSERT( 0.0 == val.asFloat());
+ JSONTEST_ASSERT_EQUAL(0, val.asInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asUInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
+ JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
// Zero (signed constructor arg)
val = Json::Value(0);
- JSONTEST_ASSERT_EQUAL( Json::intValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
checks = IsCheck();
checks.isInt_ = true;
@@ -288,17 +288,17 @@ JSONTEST_FIXTURE( ValueTest, integers )
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
- JSONTEST_ASSERT( 0 == val.asInt());
- JSONTEST_ASSERT( 0 == val.asLargestInt());
- JSONTEST_ASSERT( 0 == val.asUInt());
- JSONTEST_ASSERT( 0 == val.asLargestUInt());
- JSONTEST_ASSERT( 0.0 == val.asDouble());
- JSONTEST_ASSERT( 0.0 == val.asFloat());
+ JSONTEST_ASSERT_EQUAL(0, val.asInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asUInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
+ JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
// Zero (unsigned constructor arg)
val = Json::Value(0u);
- JSONTEST_ASSERT_EQUAL( Json::uintValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
checks = IsCheck();
checks.isInt_ = true;
@@ -310,17 +310,17 @@ JSONTEST_FIXTURE( ValueTest, integers )
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
- JSONTEST_ASSERT( 0 == val.asInt());
- JSONTEST_ASSERT( 0 == val.asLargestInt());
- JSONTEST_ASSERT( 0 == val.asUInt());
- JSONTEST_ASSERT( 0 == val.asLargestUInt());
- JSONTEST_ASSERT( 0.0 == val.asDouble());
- JSONTEST_ASSERT( 0.0 == val.asFloat());
+ JSONTEST_ASSERT_EQUAL(0, val.asInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asUInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
+ JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
// Zero (floating-point constructor arg)
val = Json::Value(0.0);
- JSONTEST_ASSERT_EQUAL( Json::realValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
checks = IsCheck();
checks.isInt_ = true;
@@ -332,17 +332,17 @@ JSONTEST_FIXTURE( ValueTest, integers )
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
- JSONTEST_ASSERT( 0 == val.asInt());
- JSONTEST_ASSERT( 0 == val.asLargestInt());
- JSONTEST_ASSERT( 0 == val.asUInt());
- JSONTEST_ASSERT( 0 == val.asLargestUInt());
- JSONTEST_ASSERT( 0.0 == val.asDouble());
- JSONTEST_ASSERT( 0.0 == val.asFloat());
+ JSONTEST_ASSERT_EQUAL(0, val.asInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asUInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
+ JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
// 2^20 (signed constructor arg)
val = Json::Value(1 << 20);
- JSONTEST_ASSERT_EQUAL( Json::intValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
checks = IsCheck();
checks.isInt_ = true;
@@ -354,17 +354,17 @@ JSONTEST_FIXTURE( ValueTest, integers )
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
- JSONTEST_ASSERT( (1 << 20) == val.asInt());
- JSONTEST_ASSERT( (1 << 20) == val.asLargestInt());
- JSONTEST_ASSERT( (1 << 20) == val.asUInt());
- JSONTEST_ASSERT( (1 << 20) == val.asLargestUInt());
- JSONTEST_ASSERT( (1 << 20) == val.asDouble());
- JSONTEST_ASSERT( (1 << 20) == val.asFloat());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
// 2^20 (unsigned constructor arg)
val = Json::Value(1u << 20);
- JSONTEST_ASSERT_EQUAL( Json::uintValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
checks = IsCheck();
checks.isInt_ = true;
@@ -376,17 +376,17 @@ JSONTEST_FIXTURE( ValueTest, integers )
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
- JSONTEST_ASSERT( (1 << 20) == val.asInt());
- JSONTEST_ASSERT( (1 << 20) == val.asLargestInt());
- JSONTEST_ASSERT( (1 << 20) == val.asUInt());
- JSONTEST_ASSERT( (1 << 20) == val.asLargestUInt());
- JSONTEST_ASSERT( (1 << 20) == val.asDouble());
- JSONTEST_ASSERT( (1 << 20) == val.asFloat());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
// 2^20 (floating-point constructor arg)
val = Json::Value((1 << 20) / 1.0);
- JSONTEST_ASSERT_EQUAL( Json::realValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
checks = IsCheck();
checks.isInt_ = true;
@@ -398,17 +398,17 @@ JSONTEST_FIXTURE( ValueTest, integers )
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
- JSONTEST_ASSERT( (1 << 20) == val.asInt());
- JSONTEST_ASSERT( (1 << 20) == val.asLargestInt());
- JSONTEST_ASSERT( (1 << 20) == val.asUInt());
- JSONTEST_ASSERT( (1 << 20) == val.asLargestUInt());
- JSONTEST_ASSERT( (1 << 20) == val.asDouble());
- JSONTEST_ASSERT( (1 << 20) == val.asFloat());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
// -2^20
val = Json::Value(-(1 << 20));
- JSONTEST_ASSERT_EQUAL( Json::intValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
checks = IsCheck();
checks.isInt_ = true;
@@ -418,15 +418,15 @@ JSONTEST_FIXTURE( ValueTest, integers )
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
- JSONTEST_ASSERT( -(1 << 20) == val.asInt());
- JSONTEST_ASSERT( -(1 << 20) == val.asLargestInt());
- JSONTEST_ASSERT( -(1 << 20) == val.asDouble());
- JSONTEST_ASSERT( -(1 << 20) == val.asFloat());
+ JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asInt());
+ JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asDouble());
+ JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asFloat());
// int32 max
val = Json::Value(kint32max);
- JSONTEST_ASSERT_EQUAL( Json::intValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
checks = IsCheck();
checks.isInt_ = true;
@@ -438,17 +438,17 @@ JSONTEST_FIXTURE( ValueTest, integers )
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
- JSONTEST_ASSERT( kint32max == val.asInt());
- JSONTEST_ASSERT( kint32max == val.asLargestInt());
- JSONTEST_ASSERT( kint32max == val.asUInt());
- JSONTEST_ASSERT( kint32max == val.asLargestUInt());
- JSONTEST_ASSERT( kint32max == val.asDouble());
- JSONTEST_ASSERT( kint32max == val.asFloat());
+ JSONTEST_ASSERT_EQUAL(kint32max, val.asInt());
+ JSONTEST_ASSERT_EQUAL(kint32max, val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(kint32max, val.asUInt());
+ JSONTEST_ASSERT_EQUAL(kint32max, val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL(kint32max, val.asDouble());
+ JSONTEST_ASSERT_EQUAL(kint32max, val.asFloat());
// int32 min
val = Json::Value(kint32min);
- JSONTEST_ASSERT_EQUAL( Json::intValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
checks = IsCheck();
checks.isInt_ = true;
@@ -458,15 +458,15 @@ JSONTEST_FIXTURE( ValueTest, integers )
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
- JSONTEST_ASSERT( kint32min == val.asInt());
- JSONTEST_ASSERT( kint32min == val.asLargestInt());
- JSONTEST_ASSERT( kint32min == val.asDouble());
- JSONTEST_ASSERT( kint32min == val.asFloat());
+ JSONTEST_ASSERT_EQUAL(kint32min, val.asInt());
+ JSONTEST_ASSERT_EQUAL(kint32min, val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(kint32min, val.asDouble());
+ JSONTEST_ASSERT_EQUAL(kint32min, val.asFloat());
// uint32 max
val = Json::Value(kuint32max);
- JSONTEST_ASSERT_EQUAL( Json::uintValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
checks = IsCheck();
checks.isInt64_ = true;
@@ -478,57 +478,57 @@ JSONTEST_FIXTURE( ValueTest, integers )
JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
#ifndef JSON_NO_INT64
- JSONTEST_ASSERT( kuint32max == val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(kuint32max, val.asLargestInt());
#endif
- JSONTEST_ASSERT( kuint32max == val.asUInt());
- JSONTEST_ASSERT( kuint32max == val.asLargestUInt());
- JSONTEST_ASSERT( kuint32max == val.asDouble());
- JSONTEST_ASSERT( kuint32max == val.asFloat());
+ JSONTEST_ASSERT_EQUAL(kuint32max, val.asUInt());
+ JSONTEST_ASSERT_EQUAL(kuint32max, val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL(kuint32max, val.asDouble());
+ JSONTEST_ASSERT_EQUAL(kuint32max, val.asFloat());
#ifdef JSON_NO_INT64
// int64 max
val = Json::Value(double(kint64max));
- JSONTEST_ASSERT_EQUAL( Json::realValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
checks = IsCheck();
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
- JSONTEST_ASSERT( double(kint64max) == val.asDouble());
- JSONTEST_ASSERT( float(kint64max) == val.asFloat());
+ JSONTEST_ASSERT_EQUAL(double(kint64max), val.asDouble());
+ JSONTEST_ASSERT_EQUAL(float(kint64max), val.asFloat());
// int64 min
val = Json::Value(double(kint64min));
- JSONTEST_ASSERT_EQUAL( Json::realValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
checks = IsCheck();
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
- JSONTEST_ASSERT( double(kint64min) == val.asDouble());
- JSONTEST_ASSERT( float(kint64min) == val.asFloat());
+ JSONTEST_ASSERT_EQUAL(double(kint64min), val.asDouble());
+ JSONTEST_ASSERT_EQUAL(float(kint64min), val.asFloat());
// uint64 max
val = Json::Value(double(kuint64max));
- JSONTEST_ASSERT_EQUAL( Json::realValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
checks = IsCheck();
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
- JSONTEST_ASSERT( double(kuint64max) == val.asDouble());
- JSONTEST_ASSERT( float(kuint64max) == val.asFloat());
+ JSONTEST_ASSERT_EQUAL(double(kuint64max), val.asDouble());
+ JSONTEST_ASSERT_EQUAL(float(kuint64max), val.asFloat());
#else // ifdef JSON_NO_INT64
// 2^40 (signed constructor arg)
val = Json::Value(1LL << 40);
- JSONTEST_ASSERT_EQUAL( Json::intValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
checks = IsCheck();
checks.isInt64_ = true;
@@ -538,17 +538,17 @@ JSONTEST_FIXTURE( ValueTest, integers )
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
- JSONTEST_ASSERT( (1LL << 40) == val.asInt64());
- JSONTEST_ASSERT( (1LL << 40) == val.asLargestInt());
- JSONTEST_ASSERT( (1LL << 40) == val.asUInt64());
- JSONTEST_ASSERT( (1LL << 40) == val.asLargestUInt());
- JSONTEST_ASSERT( (1LL << 40) == val.asDouble());
- JSONTEST_ASSERT( (1LL << 40) == val.asFloat());
+ JSONTEST_ASSERT_EQUAL((1LL << 40), val.asInt64());
+ JSONTEST_ASSERT_EQUAL((1LL << 40), val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL((1LL << 40), val.asUInt64());
+ JSONTEST_ASSERT_EQUAL((1LL << 40), val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL((1LL << 40), val.asDouble());
+ JSONTEST_ASSERT_EQUAL((1LL << 40), val.asFloat());
// 2^40 (unsigned constructor arg)
val = Json::Value(1ULL << 40);
- JSONTEST_ASSERT_EQUAL( Json::uintValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
checks = IsCheck();
checks.isInt64_ = true;
@@ -558,17 +558,17 @@ JSONTEST_FIXTURE( ValueTest, integers )
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
- JSONTEST_ASSERT( (1LL << 40) == val.asInt64());
- JSONTEST_ASSERT( (1LL << 40) == val.asLargestInt());
- JSONTEST_ASSERT( (1LL << 40) == val.asUInt64());
- JSONTEST_ASSERT( (1LL << 40) == val.asLargestUInt());
- JSONTEST_ASSERT( (1LL << 40) == val.asDouble());
- JSONTEST_ASSERT( (1LL << 40) == val.asFloat());
+ JSONTEST_ASSERT_EQUAL((1LL << 40), val.asInt64());
+ JSONTEST_ASSERT_EQUAL((1LL << 40), val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL((1LL << 40), val.asUInt64());
+ JSONTEST_ASSERT_EQUAL((1LL << 40), val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL((1LL << 40), val.asDouble());
+ JSONTEST_ASSERT_EQUAL((1LL << 40), val.asFloat());
// 2^40 (floating-point constructor arg)
val = Json::Value((1LL << 40) / 1.0);
- JSONTEST_ASSERT_EQUAL( Json::realValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
checks = IsCheck();
checks.isInt64_ = true;
@@ -578,17 +578,17 @@ JSONTEST_FIXTURE( ValueTest, integers )
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
- JSONTEST_ASSERT( (1LL << 40) == val.asInt64());
- JSONTEST_ASSERT( (1LL << 40) == val.asLargestInt());
- JSONTEST_ASSERT( (1LL << 40) == val.asUInt64());
- JSONTEST_ASSERT( (1LL << 40) == val.asLargestUInt());
- JSONTEST_ASSERT( (1LL << 40) == val.asDouble());
- JSONTEST_ASSERT( (1LL << 40) == val.asFloat());
+ JSONTEST_ASSERT_EQUAL((1LL << 40), val.asInt64());
+ JSONTEST_ASSERT_EQUAL((1LL << 40), val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL((1LL << 40), val.asUInt64());
+ JSONTEST_ASSERT_EQUAL((1LL << 40), val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL((1LL << 40), val.asDouble());
+ JSONTEST_ASSERT_EQUAL((1LL << 40), val.asFloat());
// -2^40
val = Json::Value(-(1LL << 40));
- JSONTEST_ASSERT_EQUAL( Json::intValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
checks = IsCheck();
checks.isInt64_ = true;
@@ -597,15 +597,15 @@ JSONTEST_FIXTURE( ValueTest, integers )
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
- JSONTEST_ASSERT( -(1LL << 40) == val.asInt64());
- JSONTEST_ASSERT( -(1LL << 40) == val.asLargestInt());
- JSONTEST_ASSERT( -(1LL << 40) == val.asDouble());
- JSONTEST_ASSERT( -(1LL << 40) == val.asFloat());
+ JSONTEST_ASSERT_EQUAL(-(1LL << 40), val.asInt64());
+ JSONTEST_ASSERT_EQUAL(-(1LL << 40), val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(-(1LL << 40), val.asDouble());
+ JSONTEST_ASSERT_EQUAL(-(1LL << 40), val.asFloat());
// int64 max
val = Json::Value(Json::Int64(kint64max));
- JSONTEST_ASSERT_EQUAL( Json::intValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
checks = IsCheck();
checks.isInt64_ = true;
@@ -615,18 +615,18 @@ JSONTEST_FIXTURE( ValueTest, integers )
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
- JSONTEST_ASSERT( kint64max == val.asInt64());
- JSONTEST_ASSERT( kint64max == val.asLargestInt());
- JSONTEST_ASSERT( kint64max == val.asUInt64());
- JSONTEST_ASSERT( kint64max == val.asLargestUInt());
- JSONTEST_ASSERT( double(kint64max) == val.asDouble());
- JSONTEST_ASSERT( float(kint64max) == val.asFloat());
+ JSONTEST_ASSERT_EQUAL(kint64max, val.asInt64());
+ JSONTEST_ASSERT_EQUAL(kint64max, val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(kint64max, val.asUInt64());
+ JSONTEST_ASSERT_EQUAL(kint64max, val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL(double(kint64max), val.asDouble());
+ JSONTEST_ASSERT_EQUAL(float(kint64max), val.asFloat());
// int64 max (floating point constructor). Note that kint64max is not exactly
// representable as a double, and will be rounded up to be higher.
val = Json::Value(double(kint64max));
- JSONTEST_ASSERT_EQUAL( Json::realValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
checks = IsCheck();
checks.isUInt64_ = true;
@@ -635,15 +635,15 @@ JSONTEST_FIXTURE( ValueTest, integers )
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
- JSONTEST_ASSERT( 9223372036854775808ULL == val.asUInt64());
- JSONTEST_ASSERT( 9223372036854775808ULL == val.asLargestUInt());
- JSONTEST_ASSERT( 9223372036854775808ULL == val.asDouble());
- JSONTEST_ASSERT( 9223372036854775808ULL == val.asFloat());
+ JSONTEST_ASSERT_EQUAL(9223372036854775808ULL, val.asUInt64());
+ JSONTEST_ASSERT_EQUAL(9223372036854775808ULL, val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL(9223372036854775808ULL, val.asDouble());
+ JSONTEST_ASSERT_EQUAL(9223372036854775808ULL, val.asFloat());
// int64 min
val = Json::Value(Json::Int64(kint64min));
- JSONTEST_ASSERT_EQUAL( Json::intValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
checks = IsCheck();
checks.isInt64_ = true;
@@ -652,16 +652,16 @@ JSONTEST_FIXTURE( ValueTest, integers )
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
- JSONTEST_ASSERT( kint64min == val.asInt64());
- JSONTEST_ASSERT( kint64min == val.asLargestInt());
- JSONTEST_ASSERT( double(kint64min) == val.asDouble());
- JSONTEST_ASSERT( float(kint64min) == val.asFloat());
+ JSONTEST_ASSERT_EQUAL(kint64min, val.asInt64());
+ JSONTEST_ASSERT_EQUAL(kint64min, val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(double(kint64min), val.asDouble());
+ JSONTEST_ASSERT_EQUAL(float(kint64min), val.asFloat());
// int64 min (floating point constructor). Note that kint64min *is* exactly
// representable as a double.
val = Json::Value(double(kint64min));
- JSONTEST_ASSERT_EQUAL( Json::realValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
checks = IsCheck();
checks.isInt64_ = true;
@@ -670,15 +670,15 @@ JSONTEST_FIXTURE( ValueTest, integers )
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
- JSONTEST_ASSERT( -9223372036854775808LL == val.asInt64());
- JSONTEST_ASSERT( -9223372036854775808LL == val.asLargestInt());
- JSONTEST_ASSERT( -9223372036854775808.0 == val.asDouble());
- JSONTEST_ASSERT( -9223372036854775808.0 == val.asFloat());
+ JSONTEST_ASSERT_EQUAL(-9223372036854775808LL, val.asInt64());
+ JSONTEST_ASSERT_EQUAL(-9223372036854775808LL, val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(-9223372036854775808.0, val.asDouble());
+ JSONTEST_ASSERT_EQUAL(-9223372036854775808.0, val.asFloat());
// uint64 max
val = Json::Value(Json::UInt64(kuint64max));
- JSONTEST_ASSERT_EQUAL( Json::uintValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
checks = IsCheck();
checks.isUInt64_ = true;
@@ -687,24 +687,24 @@ JSONTEST_FIXTURE( ValueTest, integers )
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
- JSONTEST_ASSERT( kuint64max == val.asUInt64());
- JSONTEST_ASSERT( kuint64max == val.asLargestUInt());
- JSONTEST_ASSERT( double(kuint64max) == val.asDouble());
- JSONTEST_ASSERT( float(kuint64max) == val.asFloat());
+ JSONTEST_ASSERT_EQUAL(kuint64max, val.asUInt64());
+ JSONTEST_ASSERT_EQUAL(kuint64max, val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL(double(kuint64max), val.asDouble());
+ JSONTEST_ASSERT_EQUAL(float(kuint64max), val.asFloat());
// uint64 max (floating point constructor). Note that kuint64max is not
// exactly representable as a double, and will be rounded up to be higher.
val = Json::Value(double(kuint64max));
- JSONTEST_ASSERT_EQUAL( Json::realValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
checks = IsCheck();
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
- JSONTEST_ASSERT( 18446744073709551616.0 == val.asDouble());
- JSONTEST_ASSERT( 18446744073709551616.0 == val.asFloat());
+ JSONTEST_ASSERT_EQUAL(18446744073709551616.0, val.asDouble());
+ JSONTEST_ASSERT_EQUAL(18446744073709551616.0, val.asFloat());
#endif
}
@@ -717,28 +717,28 @@ JSONTEST_FIXTURE( ValueTest, nonIntegers )
// Positive number
val = Json::Value(0.25);
- JSONTEST_ASSERT_EQUAL( Json::realValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
checks = IsCheck();
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
- JSONTEST_ASSERT( 0.25 == val.asDouble());
- JSONTEST_ASSERT( 0.25 == val.asFloat());
+ JSONTEST_ASSERT_EQUAL(0.25, val.asDouble());
+ JSONTEST_ASSERT_EQUAL(0.25, val.asFloat());
// Negative number
val = Json::Value(-0.25);
- JSONTEST_ASSERT_EQUAL( Json::realValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
checks = IsCheck();
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
- JSONTEST_ASSERT( -0.25 == val.asDouble());
- JSONTEST_ASSERT( -0.25 == val.asFloat());
+ JSONTEST_ASSERT_EQUAL(-0.25, val.asDouble());
+ JSONTEST_ASSERT_EQUAL(-0.25, val.asFloat());
}
@@ -757,7 +757,7 @@ ValueTest::checkConstMemberCount( const Json::Value &value, unsigned int expecte
void
ValueTest::checkMemberCount( Json::Value &value, unsigned int expectedCount )
{
- JSONTEST_ASSERT_EQUAL( expectedCount, value.size() );
+ JSONTEST_ASSERT_EQUAL(expectedCount, value.size() );
unsigned int count = 0;
Json::Value::iterator itEnd = value.end();
@@ -791,23 +791,23 @@ ValueTest::IsCheck::IsCheck()
void
ValueTest::checkIs( const Json::Value &value, const IsCheck &check )
{
- JSONTEST_ASSERT_EQUAL( check.isObject_, value.isObject() );
- JSONTEST_ASSERT_EQUAL( check.isArray_, value.isArray() );
- JSONTEST_ASSERT_EQUAL( check.isBool_, value.isBool() );
- JSONTEST_ASSERT_EQUAL( check.isDouble_, value.isDouble() );
- JSONTEST_ASSERT_EQUAL( check.isInt_, value.isInt() );
- JSONTEST_ASSERT_EQUAL( check.isUInt_, value.isUInt() );
- JSONTEST_ASSERT_EQUAL( check.isIntegral_, value.isIntegral() );
- JSONTEST_ASSERT_EQUAL( check.isNumeric_, value.isNumeric() );
- JSONTEST_ASSERT_EQUAL( check.isString_, value.isString() );
- JSONTEST_ASSERT_EQUAL( check.isNull_, value.isNull() );
+ JSONTEST_ASSERT_EQUAL(check.isObject_, value.isObject() );
+ JSONTEST_ASSERT_EQUAL(check.isArray_, value.isArray() );
+ JSONTEST_ASSERT_EQUAL(check.isBool_, value.isBool() );
+ JSONTEST_ASSERT_EQUAL(check.isDouble_, value.isDouble() );
+ JSONTEST_ASSERT_EQUAL(check.isInt_, value.isInt() );
+ JSONTEST_ASSERT_EQUAL(check.isUInt_, value.isUInt() );
+ JSONTEST_ASSERT_EQUAL(check.isIntegral_, value.isIntegral() );
+ JSONTEST_ASSERT_EQUAL(check.isNumeric_, value.isNumeric() );
+ JSONTEST_ASSERT_EQUAL(check.isString_, value.isString() );
+ JSONTEST_ASSERT_EQUAL(check.isNull_, value.isNull() );
#ifdef JSON_HAS_INT64
- JSONTEST_ASSERT_EQUAL( check.isInt64_, value.isInt64() );
- JSONTEST_ASSERT_EQUAL( check.isUInt64_, value.isUInt64() );
+ JSONTEST_ASSERT_EQUAL(check.isInt64_, value.isInt64() );
+ JSONTEST_ASSERT_EQUAL(check.isUInt64_, value.isUInt64() );
#else
- JSONTEST_ASSERT_EQUAL( false, value.isInt64() );
- JSONTEST_ASSERT_EQUAL( false, value.isUInt64() );
+ JSONTEST_ASSERT_EQUAL(false, value.isInt64() );
+ JSONTEST_ASSERT_EQUAL(false, value.isUInt64() );
#endif
}

0 comments on commit 1da375d

Please sign in to comment.
Something went wrong with that request. Please try again.