generic-library/jsoncpp
1
0
Fork 0
mirror of https://github.com/open-source-parsers/jsoncpp.git synced 2025-04-20 07:51:32 +02:00
Code Issues Projects Releases Wiki Activity

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

Browse Source 
capabilities (and simplifying its implementation) in the process.
This commit is contained in:
Aaron Jacobs 2011-05-26 00:30:39 +00:00
parent 2a2b5cf3ad
commit b0ec41c3e3
3 changed files with 205 additions and 269 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
src/test_lib_json/jsontest.cpp
View File

@ -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
// //////////////////////////////////////////////////////////////////

28
src/test_lib_json/jsontest.h
View File

@ -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 )

288
src/test_lib_json/main.cpp
View File

@ -124,15 +124,15 @@ JSONTEST_FIXTURE( ValueTest, objects )
// 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"]);
}
@ -150,16 +150,16 @@ JSONTEST_FIXTURE( ValueTest, arrays )
// 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]);
}
@ -183,8 +183,8 @@ JSONTEST_FIXTURE( ValueTest, strings )
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());
}
@ -197,8 +197,8 @@ JSONTEST_FIXTURE( ValueTest, bools )
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,12 +266,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());
// Zero (signed constructor arg)
val = Json::Value(0);
@ -288,12 +288,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());
// Zero (unsigned constructor arg)
val = Json::Value(0u);
@ -310,12 +310,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());
// Zero (floating-point constructor arg)
val = Json::Value(0.0);
@ -332,12 +332,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());
// 2^20 (signed constructor arg)
val = Json::Value(1 << 20);
@ -354,12 +354,12 @@ 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);
@ -376,12 +376,12 @@ 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);
@ -398,12 +398,12 @@ 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));
@ -418,10 +418,10 @@ 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);
@ -438,12 +438,12 @@ 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);
@ -458,10 +458,10 @@ 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);
@ -478,12 +478,12 @@ 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
@ -496,8 +496,8 @@ JSONTEST_FIXTURE( ValueTest, integers )
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));
@ -509,8 +509,8 @@ JSONTEST_FIXTURE( ValueTest, integers )
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));
@ -522,8 +522,8 @@ JSONTEST_FIXTURE( ValueTest, integers )
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);
@ -538,12 +538,12 @@ 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);
@ -558,12 +558,12 @@ 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);
@ -578,12 +578,12 @@ 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));
@ -597,10 +597,10 @@ 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));
@ -615,12 +615,12 @@ 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.
@ -635,10 +635,10 @@ 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));
@ -652,10 +652,10 @@ 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.
@ -670,10 +670,10 @@ 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));
@ -687,10 +687,10 @@ 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.
@ -703,8 +703,8 @@ JSONTEST_FIXTURE( ValueTest, integers )
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
}
@ -724,8 +724,8 @@ JSONTEST_FIXTURE( ValueTest, nonIntegers )
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);
@ -737,8 +737,8 @@ JSONTEST_FIXTURE( ValueTest, nonIntegers )
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());
}