Home | History | Annotate | Download | only in test_lib_json 
      1 // Copyright 2007-2010 Baptiste Lepilleur
      2 // Distributed under MIT license, or public domain if desired and
      3 // recognized in your jurisdiction.
      4 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
      5 
      6 #include <json/config.h>
      7 #include <json/json.h>
      8 #include "jsontest.h"
      9 
     10 // Make numeric limits more convenient to talk about.
     11 // Assumes int type in 32 bits.
     12 #define kint32max Json::Value::maxInt
     13 #define kint32min Json::Value::minInt
     14 #define kuint32max Json::Value::maxUInt
     15 #define kint64max Json::Value::maxInt64
     16 #define kint64min Json::Value::minInt64
     17 #define kuint64max Json::Value::maxUInt64
     18 
     19 static const double kdint64max = double(kint64max);
     20 static const float kfint64max = float(kint64max);
     21 static const float kfint32max = float(kint32max);
     22 static const float kfuint32max = float(kuint32max);
     23 
     24 
     25 // //////////////////////////////////////////////////////////////////
     26 // //////////////////////////////////////////////////////////////////
     27 // Json Library test cases
     28 // //////////////////////////////////////////////////////////////////
     29 // //////////////////////////////////////////////////////////////////
     30 
     31 #if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
     32 static inline double uint64ToDouble( Json::UInt64 value )
     33 {
     34     return static_cast<double>( value );
     35 }
     36 #else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
     37 static inline double uint64ToDouble( Json::UInt64 value )
     38 {
     39     return static_cast<double>( Json::Int64(value/2) ) * 2.0 + Json::Int64(value & 1);
     40 }
     41 #endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
     42 
     43 struct ValueTest : JsonTest::TestCase
     44 {
     45    Json::Value null_;
     46    Json::Value emptyArray_;
     47    Json::Value emptyObject_;
     48    Json::Value integer_;
     49    Json::Value unsignedInteger_;
     50    Json::Value smallUnsignedInteger_;
     51    Json::Value real_;
     52    Json::Value float_;
     53    Json::Value array1_;
     54    Json::Value object1_;
     55    Json::Value emptyString_;
     56    Json::Value string1_;
     57    Json::Value string_;
     58    Json::Value true_;
     59    Json::Value false_;
     60 
     61 
     62    ValueTest()
     63       : emptyArray_( Json::arrayValue )
     64       , emptyObject_( Json::objectValue )
     65       , integer_( 123456789 )
     66       , smallUnsignedInteger_( Json::Value::UInt( Json::Value::maxInt ) )
     67       , unsignedInteger_( 34567890u )
     68       , real_( 1234.56789 )
     69       , float_( 0.00390625f )
     70       , emptyString_( "" )
     71       , string1_( "a" )
     72       , string_( "sometext with space" )
     73       , true_( true )
     74       , false_( false )
     75    {
     76       array1_.append( 1234 );
     77       object1_["id"] = 1234;
     78    }
     79 
     80    struct IsCheck
     81    {
     82       /// Initialize all checks to \c false by default.
     83       IsCheck();
     84 
     85       bool isObject_;
     86       bool isArray_;
     87       bool isBool_;
     88       bool isString_;
     89       bool isNull_;
     90 
     91       bool isInt_;
     92       bool isInt64_;
     93       bool isUInt_;
     94       bool isUInt64_;
     95       bool isIntegral_;
     96       bool isDouble_;
     97       bool isNumeric_;
     98    };
     99 
    100    void checkConstMemberCount( const Json::Value &value, unsigned int expectedCount );
    101 
    102    void checkMemberCount( Json::Value &value, unsigned int expectedCount );
    103 
    104    void checkIs( const Json::Value &value, const IsCheck &check );
    105 
    106    void checkIsLess( const Json::Value &x, const Json::Value &y );
    107 
    108    void checkIsEqual( const Json::Value &x, const Json::Value &y );
    109 
    110    /// Normalize the representation of floating-point number by stripped leading 0 in exponent.
    111    static std::string normalizeFloatingPointStr( const std::string &s );
    112 };
    113 
    114 
    115 std::string
    116 ValueTest::normalizeFloatingPointStr( const std::string &s )
    117 {
    118     std::string::size_type index = s.find_last_of( "eE" );
    119     if ( index != std::string::npos )
    120     {
    121         std::string::size_type hasSign = (s[index+1] == '+' || s[index+1] == '-') ? 1 : 0;
    122         std::string::size_type exponentStartIndex = index + 1 + hasSign;
    123         std::string normalized = s.substr( 0, exponentStartIndex );
    124         std::string::size_type indexDigit = s.find_first_not_of( '0', exponentStartIndex );
    125         std::string exponent = "0";
    126         if ( indexDigit != std::string::npos ) // There is an exponent different from 0
    127         {
    128             exponent = s.substr( indexDigit );
    129         }
    130         return normalized + exponent;
    131     }
    132     return s;
    133 }
    134 
    135 
    136 JSONTEST_FIXTURE( ValueTest, checkNormalizeFloatingPointStr )
    137 {
    138     JSONTEST_ASSERT_STRING_EQUAL( "0.0", normalizeFloatingPointStr("0.0") );
    139     JSONTEST_ASSERT_STRING_EQUAL( "0e0", normalizeFloatingPointStr("0e0") );
    140     JSONTEST_ASSERT_STRING_EQUAL( "1234.0", normalizeFloatingPointStr("1234.0") );
    141     JSONTEST_ASSERT_STRING_EQUAL( "1234.0e0", normalizeFloatingPointStr("1234.0e0") );
    142     JSONTEST_ASSERT_STRING_EQUAL( "1234.0e+0", normalizeFloatingPointStr("1234.0e+0") );
    143     JSONTEST_ASSERT_STRING_EQUAL( "1234e-1", normalizeFloatingPointStr("1234e-1") );
    144     JSONTEST_ASSERT_STRING_EQUAL( "1234e10", normalizeFloatingPointStr("1234e10") );
    145     JSONTEST_ASSERT_STRING_EQUAL( "1234e10", normalizeFloatingPointStr("1234e010") );
    146     JSONTEST_ASSERT_STRING_EQUAL( "1234e+10", normalizeFloatingPointStr("1234e+010") );
    147     JSONTEST_ASSERT_STRING_EQUAL( "1234e-10", normalizeFloatingPointStr("1234e-010") );
    148     JSONTEST_ASSERT_STRING_EQUAL( "1234e+100", normalizeFloatingPointStr("1234e+100") );
    149     JSONTEST_ASSERT_STRING_EQUAL( "1234e-100", normalizeFloatingPointStr("1234e-100") );
    150     JSONTEST_ASSERT_STRING_EQUAL( "1234e+1", normalizeFloatingPointStr("1234e+001") );
    151 }
    152 
    153 
    154 JSONTEST_FIXTURE( ValueTest, memberCount )
    155 {
    156    JSONTEST_ASSERT_PRED( checkMemberCount(emptyArray_, 0) );
    157    JSONTEST_ASSERT_PRED( checkMemberCount(emptyObject_, 0) );
    158    JSONTEST_ASSERT_PRED( checkMemberCount(array1_, 1) );
    159    JSONTEST_ASSERT_PRED( checkMemberCount(object1_, 1) );
    160    JSONTEST_ASSERT_PRED( checkMemberCount(null_, 0) );
    161    JSONTEST_ASSERT_PRED( checkMemberCount(integer_, 0) );
    162    JSONTEST_ASSERT_PRED( checkMemberCount(unsignedInteger_, 0) );
    163    JSONTEST_ASSERT_PRED( checkMemberCount(smallUnsignedInteger_, 0) );
    164    JSONTEST_ASSERT_PRED( checkMemberCount(real_, 0) );
    165    JSONTEST_ASSERT_PRED( checkMemberCount(emptyString_, 0) );
    166    JSONTEST_ASSERT_PRED( checkMemberCount(string_, 0) );
    167    JSONTEST_ASSERT_PRED( checkMemberCount(true_, 0) );
    168 }
    169 
    170 
    171 JSONTEST_FIXTURE( ValueTest, objects )
    172 {
    173    // Types
    174    IsCheck checks;
    175    checks.isObject_ = true;
    176    JSONTEST_ASSERT_PRED( checkIs( emptyObject_, checks ) );
    177    JSONTEST_ASSERT_PRED( checkIs( object1_, checks ) );
    178 
    179    JSONTEST_ASSERT_EQUAL(Json::objectValue, emptyObject_.type());
    180 
    181    // Empty object okay
    182    JSONTEST_ASSERT(emptyObject_.isConvertibleTo(Json::nullValue));
    183 
    184    // Non-empty object not okay
    185    JSONTEST_ASSERT(!object1_.isConvertibleTo(Json::nullValue));
    186 
    187    // Always okay
    188    JSONTEST_ASSERT(emptyObject_.isConvertibleTo(Json::objectValue));
    189 
    190    // Never okay
    191    JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::arrayValue));
    192    JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::intValue));
    193    JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::uintValue));
    194    JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::realValue));
    195    JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::booleanValue));
    196    JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::stringValue));
    197 
    198    // Access through const reference
    199    const Json::Value &constObject = object1_;
    200 
    201    JSONTEST_ASSERT_EQUAL(Json::Value(1234), constObject["id"]);
    202    JSONTEST_ASSERT_EQUAL(Json::Value(), constObject["unknown id"]);
    203 
    204    // Access through non-const reference
    205    JSONTEST_ASSERT_EQUAL(Json::Value(1234), object1_["id"]);
    206    JSONTEST_ASSERT_EQUAL(Json::Value(), object1_["unknown id"]);
    207 
    208    object1_["some other id"] = "foo";
    209    JSONTEST_ASSERT_EQUAL(Json::Value("foo"), object1_["some other id"]);
    210 }
    211 
    212 
    213 JSONTEST_FIXTURE( ValueTest, arrays )
    214 {
    215    const unsigned int index0 = 0;
    216 
    217    // Types
    218    IsCheck checks;
    219    checks.isArray_ = true;
    220    JSONTEST_ASSERT_PRED( checkIs( emptyArray_, checks ) );
    221    JSONTEST_ASSERT_PRED( checkIs( array1_, checks ) );
    222 
    223    JSONTEST_ASSERT_EQUAL(Json::arrayValue, array1_.type());
    224 
    225    // Empty array okay
    226    JSONTEST_ASSERT(emptyArray_.isConvertibleTo(Json::nullValue));
    227 
    228    // Non-empty array not okay
    229    JSONTEST_ASSERT(!array1_.isConvertibleTo(Json::nullValue));
    230 
    231    // Always okay
    232    JSONTEST_ASSERT(emptyArray_.isConvertibleTo(Json::arrayValue));
    233 
    234    // Never okay
    235    JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::objectValue));
    236    JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::intValue));
    237    JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::uintValue));
    238    JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::realValue));
    239    JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::booleanValue));
    240    JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::stringValue));
    241 
    242    // Access through const reference
    243    const Json::Value &constArray = array1_;
    244    JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray[index0]);
    245    JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray[0]);
    246 
    247    // Access through non-const reference
    248    JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_[index0]);
    249    JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_[0]);
    250 
    251    array1_[2] = Json::Value(17);
    252    JSONTEST_ASSERT_EQUAL(Json::Value(), array1_[1]);
    253    JSONTEST_ASSERT_EQUAL(Json::Value(17), array1_[2]);
    254 }
    255 
    256 
    257 JSONTEST_FIXTURE( ValueTest, null )
    258 {
    259    JSONTEST_ASSERT_EQUAL(Json::nullValue, null_.type());
    260 
    261    IsCheck checks;
    262    checks.isNull_ = true;
    263    JSONTEST_ASSERT_PRED( checkIs( null_, checks ) );
    264 
    265    JSONTEST_ASSERT(null_.isConvertibleTo(Json::nullValue));
    266    JSONTEST_ASSERT(null_.isConvertibleTo(Json::intValue));
    267    JSONTEST_ASSERT(null_.isConvertibleTo(Json::uintValue));
    268    JSONTEST_ASSERT(null_.isConvertibleTo(Json::realValue));
    269    JSONTEST_ASSERT(null_.isConvertibleTo(Json::booleanValue));
    270    JSONTEST_ASSERT(null_.isConvertibleTo(Json::stringValue));
    271    JSONTEST_ASSERT(null_.isConvertibleTo(Json::arrayValue));
    272    JSONTEST_ASSERT(null_.isConvertibleTo(Json::objectValue));
    273 
    274    JSONTEST_ASSERT_EQUAL(Json::Int(0), null_.asInt());
    275    JSONTEST_ASSERT_EQUAL(Json::LargestInt(0), null_.asLargestInt());
    276    JSONTEST_ASSERT_EQUAL(Json::UInt(0), null_.asUInt());
    277    JSONTEST_ASSERT_EQUAL(Json::LargestUInt(0), null_.asLargestUInt());
    278    JSONTEST_ASSERT_EQUAL(0.0, null_.asDouble());
    279    JSONTEST_ASSERT_EQUAL(0.0, null_.asFloat());
    280    JSONTEST_ASSERT_STRING_EQUAL("", null_.asString());
    281 }
    282 
    283 
    284 JSONTEST_FIXTURE( ValueTest, strings )
    285 {
    286    JSONTEST_ASSERT_EQUAL(Json::stringValue, string1_.type());
    287 
    288    IsCheck checks;
    289    checks.isString_ = true;
    290    JSONTEST_ASSERT_PRED( checkIs( emptyString_, checks ) );
    291    JSONTEST_ASSERT_PRED( checkIs( string_, checks ) );
    292    JSONTEST_ASSERT_PRED( checkIs( string1_, checks ) );
    293 
    294    // Empty string okay
    295    JSONTEST_ASSERT(emptyString_.isConvertibleTo(Json::nullValue));
    296 
    297    // Non-empty string not okay
    298    JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::nullValue));
    299 
    300    // Always okay
    301    JSONTEST_ASSERT(string1_.isConvertibleTo(Json::stringValue));
    302 
    303    // Never okay
    304    JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::objectValue));
    305    JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::arrayValue));
    306    JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::intValue));
    307    JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::uintValue));
    308    JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::realValue));
    309 
    310    JSONTEST_ASSERT_STRING_EQUAL("a", string1_.asString());
    311    JSONTEST_ASSERT_STRING_EQUAL("a", string1_.asCString());
    312 }
    313 
    314 
    315 JSONTEST_FIXTURE( ValueTest, bools )
    316 {
    317    JSONTEST_ASSERT_EQUAL(Json::booleanValue, false_.type());
    318 
    319    IsCheck checks;
    320    checks.isBool_ = true;
    321    JSONTEST_ASSERT_PRED( checkIs( false_, checks ) );
    322    JSONTEST_ASSERT_PRED( checkIs( true_, checks ) );
    323 
    324    // False okay
    325    JSONTEST_ASSERT(false_.isConvertibleTo(Json::nullValue));
    326 
    327    // True not okay
    328    JSONTEST_ASSERT(!true_.isConvertibleTo(Json::nullValue));
    329 
    330    // Always okay
    331    JSONTEST_ASSERT(true_.isConvertibleTo(Json::intValue));
    332    JSONTEST_ASSERT(true_.isConvertibleTo(Json::uintValue));
    333    JSONTEST_ASSERT(true_.isConvertibleTo(Json::realValue));
    334    JSONTEST_ASSERT(true_.isConvertibleTo(Json::booleanValue));
    335    JSONTEST_ASSERT(true_.isConvertibleTo(Json::stringValue));
    336 
    337    // Never okay
    338    JSONTEST_ASSERT(!true_.isConvertibleTo(Json::arrayValue));
    339    JSONTEST_ASSERT(!true_.isConvertibleTo(Json::objectValue));
    340 
    341    JSONTEST_ASSERT_EQUAL(true, true_.asBool());
    342    JSONTEST_ASSERT_EQUAL(1, true_.asInt());
    343    JSONTEST_ASSERT_EQUAL(1, true_.asLargestInt());
    344    JSONTEST_ASSERT_EQUAL(1, true_.asUInt());
    345    JSONTEST_ASSERT_EQUAL(1, true_.asLargestUInt());
    346    JSONTEST_ASSERT_EQUAL(1.0, true_.asDouble());
    347    JSONTEST_ASSERT_EQUAL(1.0, true_.asFloat());
    348 
    349    JSONTEST_ASSERT_EQUAL(false, false_.asBool());
    350    JSONTEST_ASSERT_EQUAL(0, false_.asInt());
    351    JSONTEST_ASSERT_EQUAL(0, false_.asLargestInt());
    352    JSONTEST_ASSERT_EQUAL(0, false_.asUInt());
    353    JSONTEST_ASSERT_EQUAL(0, false_.asLargestUInt());
    354    JSONTEST_ASSERT_EQUAL(0.0, false_.asDouble());
    355    JSONTEST_ASSERT_EQUAL(0.0, false_.asFloat());
    356 }
    357 
    358 
    359 JSONTEST_FIXTURE( ValueTest, integers )
    360 {
    361    IsCheck checks;
    362    Json::Value val;
    363 
    364    // Conversions that don't depend on the value.
    365    JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::realValue));
    366    JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::stringValue));
    367    JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::booleanValue));
    368    JSONTEST_ASSERT(!Json::Value(17).isConvertibleTo(Json::arrayValue));
    369    JSONTEST_ASSERT(!Json::Value(17).isConvertibleTo(Json::objectValue));
    370 
    371    JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::realValue));
    372    JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::stringValue));
    373    JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::booleanValue));
    374    JSONTEST_ASSERT(!Json::Value(17U).isConvertibleTo(Json::arrayValue));
    375    JSONTEST_ASSERT(!Json::Value(17U).isConvertibleTo(Json::objectValue));
    376 
    377    JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::realValue));
    378    JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::stringValue));
    379    JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::booleanValue));
    380    JSONTEST_ASSERT(!Json::Value(17.0).isConvertibleTo(Json::arrayValue));
    381    JSONTEST_ASSERT(!Json::Value(17.0).isConvertibleTo(Json::objectValue));
    382 
    383    // Default int
    384    val = Json::Value(Json::intValue);
    385 
    386    JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
    387 
    388    checks = IsCheck();
    389    checks.isInt_ = true;
    390    checks.isInt64_ = true;
    391    checks.isUInt_ = true;
    392    checks.isUInt64_ = true;
    393    checks.isIntegral_ = true;
    394    checks.isDouble_ = true;
    395    checks.isNumeric_ = true;
    396    JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
    397 
    398    JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
    399    JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
    400    JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
    401 
    402    JSONTEST_ASSERT_EQUAL(0, val.asInt());
    403    JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
    404    JSONTEST_ASSERT_EQUAL(0, val.asUInt());
    405    JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
    406    JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
    407    JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
    408    JSONTEST_ASSERT_EQUAL(false, val.asBool());
    409    JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
    410 
    411    // Default uint
    412    val = Json::Value(Json::uintValue);
    413 
    414    JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
    415 
    416    checks = IsCheck();
    417    checks.isInt_ = true;
    418    checks.isInt64_ = true;
    419    checks.isUInt_ = true;
    420    checks.isUInt64_ = true;
    421    checks.isIntegral_ = true;
    422    checks.isDouble_ = true;
    423    checks.isNumeric_ = true;
    424    JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
    425 
    426    JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
    427    JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
    428    JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
    429 
    430    JSONTEST_ASSERT_EQUAL(0, val.asInt());
    431    JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
    432    JSONTEST_ASSERT_EQUAL(0, val.asUInt());
    433    JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
    434    JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
    435    JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
    436    JSONTEST_ASSERT_EQUAL(false, val.asBool());
    437    JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
    438 
    439    // Default real
    440    val = Json::Value(Json::realValue);
    441 
    442    JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
    443 
    444    JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
    445    JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
    446    JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
    447 
    448    checks = IsCheck();
    449    checks.isInt_ = true;
    450    checks.isInt64_ = true;
    451    checks.isUInt_ = true;
    452    checks.isUInt64_ = true;
    453    checks.isIntegral_ = true;
    454    checks.isDouble_ = true;
    455    checks.isNumeric_ = true;
    456    JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
    457 
    458    JSONTEST_ASSERT_EQUAL(0, val.asInt());
    459    JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
    460    JSONTEST_ASSERT_EQUAL(0, val.asUInt());
    461    JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
    462    JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
    463    JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
    464    JSONTEST_ASSERT_EQUAL(false, val.asBool());
    465    JSONTEST_ASSERT_STRING_EQUAL("0.0", val.asString());
    466 
    467    // Zero (signed constructor arg)
    468    val = Json::Value(0);
    469 
    470    JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
    471 
    472    checks = IsCheck();
    473    checks.isInt_ = true;
    474    checks.isInt64_ = true;
    475    checks.isUInt_ = true;
    476    checks.isUInt64_ = true;
    477    checks.isIntegral_ = true;
    478    checks.isDouble_ = true;
    479    checks.isNumeric_ = true;
    480    JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
    481 
    482    JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
    483    JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
    484    JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
    485 
    486    JSONTEST_ASSERT_EQUAL(0, val.asInt());
    487    JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
    488    JSONTEST_ASSERT_EQUAL(0, val.asUInt());
    489    JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
    490    JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
    491    JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
    492    JSONTEST_ASSERT_EQUAL(false, val.asBool());
    493    JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
    494 
    495    // Zero (unsigned constructor arg)
    496    val = Json::Value(0u);
    497 
    498    JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
    499 
    500    checks = IsCheck();
    501    checks.isInt_ = true;
    502    checks.isInt64_ = true;
    503    checks.isUInt_ = true;
    504    checks.isUInt64_ = true;
    505    checks.isIntegral_ = true;
    506    checks.isDouble_ = true;
    507    checks.isNumeric_ = true;
    508    JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
    509 
    510    JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
    511    JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
    512    JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
    513 
    514    JSONTEST_ASSERT_EQUAL(0, val.asInt());
    515    JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
    516    JSONTEST_ASSERT_EQUAL(0, val.asUInt());
    517    JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
    518    JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
    519    JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
    520    JSONTEST_ASSERT_EQUAL(false, val.asBool());
    521    JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
    522 
    523    // Zero (floating-point constructor arg)
    524    val = Json::Value(0.0);
    525 
    526    JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
    527 
    528    checks = IsCheck();
    529    checks.isInt_ = true;
    530    checks.isInt64_ = true;
    531    checks.isUInt_ = true;
    532    checks.isUInt64_ = true;
    533    checks.isIntegral_ = true;
    534    checks.isDouble_ = true;
    535    checks.isNumeric_ = true;
    536    JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
    537 
    538    JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
    539    JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
    540    JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
    541 
    542    JSONTEST_ASSERT_EQUAL(0, val.asInt());
    543    JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
    544    JSONTEST_ASSERT_EQUAL(0, val.asUInt());
    545    JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
    546    JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
    547    JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
    548    JSONTEST_ASSERT_EQUAL(false, val.asBool());
    549    JSONTEST_ASSERT_STRING_EQUAL("0.0", val.asString());
    550 
    551    // 2^20 (signed constructor arg)
    552    val = Json::Value(1 << 20);
    553 
    554    JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
    555    checks = IsCheck();
    556    checks.isInt_ = true;
    557    checks.isInt64_ = true;
    558    checks.isUInt_ = true;
    559    checks.isUInt64_ = true;
    560    checks.isIntegral_ = true;
    561    checks.isDouble_ = true;
    562    checks.isNumeric_ = true;
    563    JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
    564 
    565    JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
    566    JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
    567    JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
    568 
    569    JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
    570    JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
    571    JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
    572    JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
    573    JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
    574    JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
    575    JSONTEST_ASSERT_EQUAL(true, val.asBool());
    576    JSONTEST_ASSERT_STRING_EQUAL("1048576", val.asString());
    577 
    578    // 2^20 (unsigned constructor arg)
    579    val = Json::Value(Json::UInt(1 << 20));
    580 
    581    JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
    582 
    583    checks = IsCheck();
    584    checks.isInt_ = true;
    585    checks.isInt64_ = true;
    586    checks.isUInt_ = true;
    587    checks.isUInt64_ = true;
    588    checks.isIntegral_ = true;
    589    checks.isDouble_ = true;
    590    checks.isNumeric_ = true;
    591    JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
    592 
    593    JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
    594    JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
    595    JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
    596 
    597    JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
    598    JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
    599    JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
    600    JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
    601    JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
    602    JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
    603    JSONTEST_ASSERT_EQUAL(true, val.asBool());
    604    JSONTEST_ASSERT_STRING_EQUAL("1048576", val.asString());
    605 
    606    // 2^20 (floating-point constructor arg)
    607    val = Json::Value((1 << 20) / 1.0);
    608 
    609    JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
    610 
    611    checks = IsCheck();
    612    checks.isInt_ = true;
    613    checks.isInt64_ = true;
    614    checks.isUInt_ = true;
    615    checks.isUInt64_ = true;
    616    checks.isIntegral_ = true;
    617    checks.isDouble_ = true;
    618    checks.isNumeric_ = true;
    619    JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
    620 
    621    JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
    622    JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
    623    JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
    624 
    625    JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
    626    JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
    627    JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
    628    JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
    629    JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
    630    JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
    631    JSONTEST_ASSERT_EQUAL(true, val.asBool());
    632    JSONTEST_ASSERT_STRING_EQUAL("1048576.0", normalizeFloatingPointStr(val.asString()));
    633 
    634    // -2^20
    635    val = Json::Value(-(1 << 20));
    636 
    637    JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
    638 
    639    checks = IsCheck();
    640    checks.isInt_ = true;
    641    checks.isInt64_ = true;
    642    checks.isIntegral_ = true;
    643    checks.isDouble_ = true;
    644    checks.isNumeric_ = true;
    645    JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
    646 
    647    JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
    648    JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
    649    JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
    650 
    651    JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asInt());
    652    JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asLargestInt());
    653    JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asDouble());
    654    JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asFloat());
    655    JSONTEST_ASSERT_EQUAL(true, val.asBool());
    656    JSONTEST_ASSERT_STRING_EQUAL("-1048576", val.asString());
    657 
    658    // int32 max
    659    val = Json::Value(kint32max);
    660 
    661    JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
    662 
    663    checks = IsCheck();
    664    checks.isInt_ = true;
    665    checks.isInt64_ = true;
    666    checks.isUInt_ = true;
    667    checks.isUInt64_ = true;
    668    checks.isIntegral_ = true;
    669    checks.isDouble_ = true;
    670    checks.isNumeric_ = true;
    671    JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
    672 
    673    JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
    674    JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
    675    JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
    676 
    677    JSONTEST_ASSERT_EQUAL(kint32max, val.asInt());
    678    JSONTEST_ASSERT_EQUAL(kint32max, val.asLargestInt());
    679    JSONTEST_ASSERT_EQUAL(kint32max, val.asUInt());
    680    JSONTEST_ASSERT_EQUAL(kint32max, val.asLargestUInt());
    681    JSONTEST_ASSERT_EQUAL(kint32max, val.asDouble());
    682    JSONTEST_ASSERT_EQUAL(kfint32max, val.asFloat());
    683    JSONTEST_ASSERT_EQUAL(true, val.asBool());
    684    JSONTEST_ASSERT_STRING_EQUAL("2147483647", val.asString());
    685 
    686    // int32 min
    687    val = Json::Value(kint32min);
    688 
    689    JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
    690 
    691    checks = IsCheck();
    692    checks.isInt_ = true;
    693    checks.isInt64_ = true;
    694    checks.isIntegral_ = true;
    695    checks.isDouble_ = true;
    696    checks.isNumeric_ = true;
    697    JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
    698 
    699    JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
    700    JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
    701    JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
    702 
    703    JSONTEST_ASSERT_EQUAL(kint32min, val.asInt());
    704    JSONTEST_ASSERT_EQUAL(kint32min, val.asLargestInt());
    705    JSONTEST_ASSERT_EQUAL(kint32min, val.asDouble());
    706    JSONTEST_ASSERT_EQUAL(kint32min, val.asFloat());
    707    JSONTEST_ASSERT_EQUAL(true, val.asBool());
    708    JSONTEST_ASSERT_STRING_EQUAL("-2147483648", val.asString());
    709 
    710    // uint32 max
    711    val = Json::Value(kuint32max);
    712 
    713    JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
    714 
    715    checks = IsCheck();
    716    checks.isInt64_ = true;
    717    checks.isUInt_ = true;
    718    checks.isUInt64_ = true;
    719    checks.isIntegral_ = true;
    720    checks.isDouble_ = true;
    721    checks.isNumeric_ = true;
    722    JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
    723 
    724    JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
    725    JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
    726    JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
    727 
    728 #ifndef JSON_NO_INT64
    729    JSONTEST_ASSERT_EQUAL(kuint32max, val.asLargestInt());
    730 #endif
    731    JSONTEST_ASSERT_EQUAL(kuint32max, val.asUInt());
    732    JSONTEST_ASSERT_EQUAL(kuint32max, val.asLargestUInt());
    733    JSONTEST_ASSERT_EQUAL(kuint32max, val.asDouble());
    734    JSONTEST_ASSERT_EQUAL(kfuint32max, val.asFloat());
    735    JSONTEST_ASSERT_EQUAL(true, val.asBool());
    736    JSONTEST_ASSERT_STRING_EQUAL("4294967295", val.asString());
    737 
    738 #ifdef JSON_NO_INT64
    739    // int64 max
    740    val = Json::Value(double(kint64max));
    741 
    742    JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
    743 
    744    checks = IsCheck();
    745    checks.isDouble_ = true;
    746    checks.isNumeric_ = true;
    747    JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
    748 
    749    JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
    750    JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
    751    JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
    752 
    753    JSONTEST_ASSERT_EQUAL(double(kint64max), val.asDouble());
    754    JSONTEST_ASSERT_EQUAL(float(kint64max), val.asFloat());
    755    JSONTEST_ASSERT_EQUAL(true, val.asBool());
    756    JSONTEST_ASSERT_STRING_EQUAL("9.22337e+18", val.asString());
    757 
    758    // int64 min
    759    val = Json::Value(double(kint64min));
    760 
    761    JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
    762 
    763    checks = IsCheck();
    764    checks.isDouble_ = true;
    765    checks.isNumeric_ = true;
    766    JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
    767 
    768    JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
    769    JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
    770    JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
    771 
    772    JSONTEST_ASSERT_EQUAL(double(kint64min), val.asDouble());
    773    JSONTEST_ASSERT_EQUAL(float(kint64min), val.asFloat());
    774    JSONTEST_ASSERT_EQUAL(true, val.asBool());
    775    JSONTEST_ASSERT_STRING_EQUAL("-9.22337e+18", val.asString());
    776 
    777    // uint64 max
    778    val = Json::Value(double(kuint64max));
    779 
    780    JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
    781 
    782    checks = IsCheck();
    783    checks.isDouble_ = true;
    784    checks.isNumeric_ = true;
    785    JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
    786 
    787    JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
    788    JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
    789    JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
    790 
    791    JSONTEST_ASSERT_EQUAL(double(kuint64max), val.asDouble());
    792    JSONTEST_ASSERT_EQUAL(float(kuint64max), val.asFloat());
    793    JSONTEST_ASSERT_EQUAL(true, val.asBool());
    794    JSONTEST_ASSERT_STRING_EQUAL("1.84467e+19", val.asString());
    795 #else  // ifdef JSON_NO_INT64
    796    // 2^40 (signed constructor arg)
    797    val = Json::Value(Json::Int64(1) << 40);
    798 
    799    JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
    800 
    801    checks = IsCheck();
    802    checks.isInt64_ = true;
    803    checks.isUInt64_ = true;
    804    checks.isIntegral_ = true;
    805    checks.isDouble_ = true;
    806    checks.isNumeric_ = true;
    807    JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
    808 
    809    JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
    810    JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
    811    JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
    812 
    813    JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
    814    JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
    815    JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
    816    JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
    817    JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
    818    JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
    819    JSONTEST_ASSERT_EQUAL(true, val.asBool());
    820    JSONTEST_ASSERT_STRING_EQUAL("1099511627776", val.asString());
    821 
    822    // 2^40 (unsigned constructor arg)
    823    val = Json::Value(Json::UInt64(1) << 40);
    824 
    825    JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
    826 
    827    checks = IsCheck();
    828    checks.isInt64_ = true;
    829    checks.isUInt64_ = true;
    830    checks.isIntegral_ = true;
    831    checks.isDouble_ = true;
    832    checks.isNumeric_ = true;
    833    JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
    834 
    835    JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
    836    JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
    837    JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
    838 
    839    JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
    840    JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
    841    JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
    842    JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
    843    JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
    844    JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
    845    JSONTEST_ASSERT_EQUAL(true, val.asBool());
    846    JSONTEST_ASSERT_STRING_EQUAL("1099511627776", val.asString());
    847 
    848    // 2^40 (floating-point constructor arg)
    849    val = Json::Value((Json::Int64(1) << 40) / 1.0);
    850 
    851    JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
    852 
    853    checks = IsCheck();
    854    checks.isInt64_ = true;
    855    checks.isUInt64_ = true;
    856    checks.isIntegral_ = true;
    857    checks.isDouble_ = true;
    858    checks.isNumeric_ = true;
    859    JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
    860 
    861    JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
    862    JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
    863    JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
    864 
    865    JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
    866    JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
    867    JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
    868    JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
    869    JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
    870    JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
    871    JSONTEST_ASSERT_EQUAL(true, val.asBool());
    872    JSONTEST_ASSERT_STRING_EQUAL("1099511627776.0", normalizeFloatingPointStr(val.asString()));
    873 
    874    // -2^40
    875    val = Json::Value(-(Json::Int64(1) << 40));
    876 
    877    JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
    878 
    879    checks = IsCheck();
    880    checks.isInt64_ = true;
    881    checks.isIntegral_ = true;
    882    checks.isDouble_ = true;
    883    checks.isNumeric_ = true;
    884    JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
    885 
    886    JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
    887    JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
    888    JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
    889 
    890    JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asInt64());
    891    JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asLargestInt());
    892    JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asDouble());
    893    JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asFloat());
    894    JSONTEST_ASSERT_EQUAL(true, val.asBool());
    895    JSONTEST_ASSERT_STRING_EQUAL("-1099511627776", val.asString());
    896 
    897    // int64 max
    898    val = Json::Value(Json::Int64(kint64max));
    899 
    900    JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
    901 
    902    checks = IsCheck();
    903    checks.isInt64_ = true;
    904    checks.isUInt64_ = true;
    905    checks.isIntegral_ = true;
    906    checks.isDouble_ = true;
    907    checks.isNumeric_ = true;
    908    JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
    909 
    910    JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
    911    JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
    912    JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
    913 
    914    JSONTEST_ASSERT_EQUAL(kint64max, val.asInt64());
    915    JSONTEST_ASSERT_EQUAL(kint64max, val.asLargestInt());
    916    JSONTEST_ASSERT_EQUAL(kint64max, val.asUInt64());
    917    JSONTEST_ASSERT_EQUAL(kint64max, val.asLargestUInt());
    918    JSONTEST_ASSERT_EQUAL(double(kint64max), val.asDouble());
    919    JSONTEST_ASSERT_EQUAL(float(kint64max), val.asFloat());
    920    JSONTEST_ASSERT_EQUAL(true, val.asBool());
    921    JSONTEST_ASSERT_STRING_EQUAL("9223372036854775807", val.asString());
    922 
    923    // int64 max (floating point constructor). Note that kint64max is not exactly
    924    // representable as a double, and will be rounded up to be higher.
    925    val = Json::Value(double(kint64max));
    926 
    927    JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
    928 
    929    checks = IsCheck();
    930    checks.isUInt64_ = true;
    931    checks.isIntegral_ = true;
    932    checks.isDouble_ = true;
    933    checks.isNumeric_ = true;
    934    JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
    935 
    936    JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
    937    JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
    938    JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
    939 
    940    JSONTEST_ASSERT_EQUAL(Json::UInt64(1) << 63, val.asUInt64());
    941    JSONTEST_ASSERT_EQUAL(Json::UInt64(1) << 63, val.asLargestUInt());
    942    JSONTEST_ASSERT_EQUAL(uint64ToDouble(Json::UInt64(1) << 63), val.asDouble());
    943    JSONTEST_ASSERT_EQUAL(float(uint64ToDouble(Json::UInt64(1) << 63)), val.asFloat());
    944    JSONTEST_ASSERT_EQUAL(true, val.asBool());
    945    JSONTEST_ASSERT_STRING_EQUAL("9.223372036854776e+18", normalizeFloatingPointStr(val.asString()));
    946 
    947    // int64 min
    948    val = Json::Value(Json::Int64(kint64min));
    949 
    950    JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
    951 
    952    checks = IsCheck();
    953    checks.isInt64_ = true;
    954    checks.isIntegral_ = true;
    955    checks.isDouble_ = true;
    956    checks.isNumeric_ = true;
    957    JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
    958 
    959    JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
    960    JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
    961    JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
    962 
    963    JSONTEST_ASSERT_EQUAL(kint64min, val.asInt64());
    964    JSONTEST_ASSERT_EQUAL(kint64min, val.asLargestInt());
    965    JSONTEST_ASSERT_EQUAL(double(kint64min), val.asDouble());
    966    JSONTEST_ASSERT_EQUAL(float(kint64min), val.asFloat());
    967    JSONTEST_ASSERT_EQUAL(true, val.asBool());
    968    JSONTEST_ASSERT_STRING_EQUAL("-9223372036854775808", val.asString());
    969 
    970    // int64 min (floating point constructor). Note that kint64min *is* exactly
    971    // representable as a double.
    972    val = Json::Value(double(kint64min));
    973 
    974    JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
    975 
    976    checks = IsCheck();
    977    checks.isInt64_ = true;
    978    checks.isIntegral_ = true;
    979    checks.isDouble_ = true;
    980    checks.isNumeric_ = true;
    981    JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
    982 
    983    JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
    984    JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
    985    JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
    986 
    987    JSONTEST_ASSERT_EQUAL(kint64min, val.asInt64());
    988    JSONTEST_ASSERT_EQUAL(kint64min, val.asLargestInt());
    989    JSONTEST_ASSERT_EQUAL(-9223372036854775808.0, val.asDouble());
    990    JSONTEST_ASSERT_EQUAL(-9223372036854775808.0, val.asFloat());
    991    JSONTEST_ASSERT_EQUAL(true, val.asBool());
    992    JSONTEST_ASSERT_STRING_EQUAL("-9.223372036854776e+18", normalizeFloatingPointStr(val.asString()));
    993 
    994    // uint64 max
    995    val = Json::Value(Json::UInt64(kuint64max));
    996 
    997    JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
    998 
    999    checks = IsCheck();
   1000    checks.isUInt64_ = true;
   1001    checks.isIntegral_ = true;
   1002    checks.isDouble_ = true;
   1003    checks.isNumeric_ = true;
   1004    JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
   1005 
   1006    JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
   1007    JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
   1008    JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
   1009 
   1010    JSONTEST_ASSERT_EQUAL(kuint64max, val.asUInt64());
   1011    JSONTEST_ASSERT_EQUAL(kuint64max, val.asLargestUInt());
   1012    JSONTEST_ASSERT_EQUAL(uint64ToDouble(kuint64max), val.asDouble());
   1013    JSONTEST_ASSERT_EQUAL(float(uint64ToDouble(kuint64max)), val.asFloat());
   1014    JSONTEST_ASSERT_EQUAL(true, val.asBool());
   1015    JSONTEST_ASSERT_STRING_EQUAL("18446744073709551615", val.asString());
   1016 
   1017    // uint64 max (floating point constructor). Note that kuint64max is not
   1018    // exactly representable as a double, and will be rounded up to be higher.
   1019    val = Json::Value(uint64ToDouble(kuint64max));
   1020 
   1021    JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
   1022 
   1023    checks = IsCheck();
   1024    checks.isDouble_ = true;
   1025    checks.isNumeric_ = true;
   1026    JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
   1027 
   1028    JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
   1029    JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
   1030    JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
   1031 
   1032    JSONTEST_ASSERT_EQUAL(18446744073709551616.0, val.asDouble());
   1033    JSONTEST_ASSERT_EQUAL(18446744073709551616.0, val.asFloat());
   1034    JSONTEST_ASSERT_EQUAL(true, val.asBool());
   1035    JSONTEST_ASSERT_STRING_EQUAL("1.844674407370955e+19", normalizeFloatingPointStr(val.asString()));
   1036 #endif
   1037 }
   1038 
   1039 
   1040 JSONTEST_FIXTURE( ValueTest, nonIntegers )
   1041 {
   1042    IsCheck checks;
   1043    Json::Value val;
   1044 
   1045    // Small positive number
   1046    val = Json::Value(1.5);
   1047 
   1048    JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
   1049 
   1050    checks = IsCheck();
   1051    checks.isDouble_ = true;
   1052    checks.isNumeric_ = true;
   1053    JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
   1054 
   1055    JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
   1056    JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
   1057    JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
   1058    JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
   1059    JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
   1060    JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
   1061    JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
   1062    JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
   1063 
   1064    JSONTEST_ASSERT_EQUAL(1.5, val.asDouble());
   1065    JSONTEST_ASSERT_EQUAL(1.5, val.asFloat());
   1066    JSONTEST_ASSERT_EQUAL(1, val.asInt());
   1067    JSONTEST_ASSERT_EQUAL(1, val.asLargestInt());
   1068    JSONTEST_ASSERT_EQUAL(1, val.asUInt());
   1069    JSONTEST_ASSERT_EQUAL(1, val.asLargestUInt());
   1070    JSONTEST_ASSERT_EQUAL(true, val.asBool());
   1071    JSONTEST_ASSERT_EQUAL("1.50", val.asString());
   1072 
   1073    // Small negative number
   1074    val = Json::Value(-1.5);
   1075 
   1076    JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
   1077 
   1078    checks = IsCheck();
   1079    checks.isDouble_ = true;
   1080    checks.isNumeric_ = true;
   1081    JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
   1082 
   1083    JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
   1084    JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
   1085    JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
   1086    JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
   1087    JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
   1088    JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
   1089    JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
   1090    JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
   1091 
   1092    JSONTEST_ASSERT_EQUAL(-1.5, val.asDouble());
   1093    JSONTEST_ASSERT_EQUAL(-1.5, val.asFloat());
   1094    JSONTEST_ASSERT_EQUAL(-1, val.asInt());
   1095    JSONTEST_ASSERT_EQUAL(-1, val.asLargestInt());
   1096    JSONTEST_ASSERT_EQUAL(true, val.asBool());
   1097    JSONTEST_ASSERT_EQUAL("-1.50", val.asString());
   1098 
   1099    // A bit over int32 max
   1100    val = Json::Value(kint32max + 0.5);
   1101 
   1102    JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
   1103 
   1104    checks = IsCheck();
   1105    checks.isDouble_ = true;
   1106    checks.isNumeric_ = true;
   1107    JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
   1108 
   1109    JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
   1110    JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
   1111    JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
   1112    JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
   1113    JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
   1114    JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
   1115    JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
   1116    JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
   1117 
   1118    JSONTEST_ASSERT_EQUAL(2147483647.5, val.asDouble());
   1119    JSONTEST_ASSERT_EQUAL(float(2147483647.5), val.asFloat());
   1120    JSONTEST_ASSERT_EQUAL(2147483647U, val.asUInt());
   1121 #ifdef JSON_HAS_INT64
   1122    JSONTEST_ASSERT_EQUAL(2147483647L, val.asLargestInt());
   1123    JSONTEST_ASSERT_EQUAL(2147483647U, val.asLargestUInt());
   1124 #endif
   1125    JSONTEST_ASSERT_EQUAL(true, val.asBool());
   1126    JSONTEST_ASSERT_EQUAL("2147483647.50", normalizeFloatingPointStr(val.asString()));
   1127 
   1128    // A bit under int32 min
   1129    val = Json::Value(kint32min - 0.5);
   1130 
   1131    JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
   1132 
   1133    checks = IsCheck();
   1134    checks.isDouble_ = true;
   1135    checks.isNumeric_ = true;
   1136    JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
   1137 
   1138    JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
   1139    JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
   1140    JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
   1141    JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
   1142    JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
   1143    JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
   1144    JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
   1145    JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
   1146 
   1147    JSONTEST_ASSERT_EQUAL(-2147483648.5, val.asDouble());
   1148    JSONTEST_ASSERT_EQUAL(float(-2147483648.5), val.asFloat());
   1149 #ifdef JSON_HAS_INT64
   1150    JSONTEST_ASSERT_EQUAL(-Json::Int64(1)<< 31, val.asLargestInt());
   1151 #endif
   1152    JSONTEST_ASSERT_EQUAL(true, val.asBool());
   1153    JSONTEST_ASSERT_EQUAL("-2147483648.50", normalizeFloatingPointStr(val.asString()));
   1154 
   1155    // A bit over uint32 max
   1156    val = Json::Value(kuint32max + 0.5);
   1157 
   1158    JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
   1159 
   1160    checks = IsCheck();
   1161    checks.isDouble_ = true;
   1162    checks.isNumeric_ = true;
   1163    JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
   1164 
   1165    JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
   1166    JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
   1167    JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
   1168    JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
   1169    JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
   1170    JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
   1171    JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
   1172    JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
   1173 
   1174    JSONTEST_ASSERT_EQUAL(4294967295.5, val.asDouble());
   1175    JSONTEST_ASSERT_EQUAL(float(4294967295.5), val.asFloat());
   1176 #ifdef JSON_HAS_INT64
   1177    JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 32)-1, val.asLargestInt());
   1178    JSONTEST_ASSERT_EQUAL((Json::UInt64(1) << 32)-Json::UInt64(1), val.asLargestUInt());
   1179 #endif
   1180    JSONTEST_ASSERT_EQUAL(true, val.asBool());
   1181    JSONTEST_ASSERT_EQUAL("4294967295.50", normalizeFloatingPointStr(val.asString()));
   1182 
   1183    val = Json::Value(1.2345678901234);
   1184    JSONTEST_ASSERT_STRING_EQUAL( "1.23456789012340", normalizeFloatingPointStr(val.asString()));
   1185 }
   1186 
   1187 
   1188 void
   1189 ValueTest::checkConstMemberCount( const Json::Value &value, unsigned int expectedCount )
   1190 {
   1191    unsigned int count = 0;
   1192    Json::Value::const_iterator itEnd = value.end();
   1193    for ( Json::Value::const_iterator it = value.begin(); it != itEnd; ++it )
   1194    {
   1195       ++count;
   1196    }
   1197    JSONTEST_ASSERT_EQUAL( expectedCount, count ) << "Json::Value::const_iterator";
   1198 }
   1199 
   1200 void
   1201 ValueTest::checkMemberCount( Json::Value &value, unsigned int expectedCount )
   1202 {
   1203    JSONTEST_ASSERT_EQUAL(expectedCount, value.size() );
   1204 
   1205    unsigned int count = 0;
   1206    Json::Value::iterator itEnd = value.end();
   1207    for ( Json::Value::iterator it = value.begin(); it != itEnd; ++it )
   1208    {
   1209       ++count;
   1210    }
   1211    JSONTEST_ASSERT_EQUAL( expectedCount, count ) << "Json::Value::iterator";
   1212 
   1213    JSONTEST_ASSERT_PRED( checkConstMemberCount(value, expectedCount) );
   1214 }
   1215 
   1216 
   1217 ValueTest::IsCheck::IsCheck()
   1218    : isObject_( false )
   1219    , isArray_( false )
   1220    , isBool_( false )
   1221    , isString_( false )
   1222    , isNull_( false )
   1223    , isInt_( false )
   1224    , isInt64_( false )
   1225    , isUInt_( false )
   1226    , isUInt64_( false )
   1227    , isIntegral_( false )
   1228    , isDouble_( false )
   1229    , isNumeric_( false )
   1230 {
   1231 }
   1232 
   1233 
   1234 void
   1235 ValueTest::checkIs( const Json::Value &value, const IsCheck &check )
   1236 {
   1237    JSONTEST_ASSERT_EQUAL(check.isObject_, value.isObject() );
   1238    JSONTEST_ASSERT_EQUAL(check.isArray_, value.isArray() );
   1239    JSONTEST_ASSERT_EQUAL(check.isBool_, value.isBool() );
   1240    JSONTEST_ASSERT_EQUAL(check.isDouble_, value.isDouble() );
   1241    JSONTEST_ASSERT_EQUAL(check.isInt_, value.isInt() );
   1242    JSONTEST_ASSERT_EQUAL(check.isUInt_, value.isUInt() );
   1243    JSONTEST_ASSERT_EQUAL(check.isIntegral_, value.isIntegral() );
   1244    JSONTEST_ASSERT_EQUAL(check.isNumeric_, value.isNumeric() );
   1245    JSONTEST_ASSERT_EQUAL(check.isString_, value.isString() );
   1246    JSONTEST_ASSERT_EQUAL(check.isNull_, value.isNull() );
   1247 
   1248 #ifdef JSON_HAS_INT64
   1249    JSONTEST_ASSERT_EQUAL(check.isInt64_, value.isInt64() );
   1250    JSONTEST_ASSERT_EQUAL(check.isUInt64_, value.isUInt64() );
   1251 #else
   1252    JSONTEST_ASSERT_EQUAL(false, value.isInt64() );
   1253    JSONTEST_ASSERT_EQUAL(false, value.isUInt64() );
   1254 #endif
   1255 }
   1256 
   1257 JSONTEST_FIXTURE( ValueTest, compareNull )
   1258 {
   1259     JSONTEST_ASSERT_PRED( checkIsEqual( Json::Value(), Json::Value() ) );
   1260 }
   1261 
   1262 
   1263 JSONTEST_FIXTURE( ValueTest, compareInt )
   1264 {
   1265     JSONTEST_ASSERT_PRED( checkIsLess( 0, 10 ) );
   1266     JSONTEST_ASSERT_PRED( checkIsEqual( 10, 10 ) );
   1267     JSONTEST_ASSERT_PRED( checkIsEqual( -10, -10 ) );
   1268     JSONTEST_ASSERT_PRED( checkIsLess( -10, 0 ) );
   1269 }
   1270 
   1271 
   1272 JSONTEST_FIXTURE( ValueTest, compareUInt )
   1273 {
   1274     JSONTEST_ASSERT_PRED( checkIsLess( 0u, 10u ) );
   1275     JSONTEST_ASSERT_PRED( checkIsLess( 0u, Json::Value::maxUInt ) );
   1276     JSONTEST_ASSERT_PRED( checkIsEqual( 10u, 10u ) );
   1277 }
   1278 
   1279 
   1280 JSONTEST_FIXTURE( ValueTest, compareDouble )
   1281 {
   1282     JSONTEST_ASSERT_PRED( checkIsLess( 0.0, 10.0 ) );
   1283     JSONTEST_ASSERT_PRED( checkIsEqual( 10.0, 10.0 ) );
   1284     JSONTEST_ASSERT_PRED( checkIsEqual( -10.0, -10.0 ) );
   1285     JSONTEST_ASSERT_PRED( checkIsLess( -10.0, 0.0 ) );
   1286 }
   1287 
   1288 
   1289 JSONTEST_FIXTURE( ValueTest, compareString )
   1290 {
   1291     JSONTEST_ASSERT_PRED( checkIsLess( "", " " ) );
   1292     JSONTEST_ASSERT_PRED( checkIsLess( "", "a" ) );
   1293     JSONTEST_ASSERT_PRED( checkIsLess( "abcd", "zyui" ) );
   1294     JSONTEST_ASSERT_PRED( checkIsLess( "abc", "abcd" ) );
   1295     JSONTEST_ASSERT_PRED( checkIsEqual( "abcd", "abcd" ) );
   1296     JSONTEST_ASSERT_PRED( checkIsEqual( " ", " " ) );
   1297     JSONTEST_ASSERT_PRED( checkIsLess( "ABCD", "abcd" ) );
   1298     JSONTEST_ASSERT_PRED( checkIsEqual( "ABCD", "ABCD" ) );
   1299 }
   1300 
   1301 
   1302 JSONTEST_FIXTURE( ValueTest, compareBoolean )
   1303 {
   1304     JSONTEST_ASSERT_PRED( checkIsLess( false, true ) );
   1305     JSONTEST_ASSERT_PRED( checkIsEqual( false, false ) );
   1306     JSONTEST_ASSERT_PRED( checkIsEqual( true, true ) );
   1307 }
   1308 
   1309 
   1310 JSONTEST_FIXTURE( ValueTest, compareArray )
   1311 {
   1312     // array compare size then content
   1313     Json::Value emptyArray(Json::arrayValue);
   1314     Json::Value l1aArray;
   1315     l1aArray.append( 0 );
   1316     Json::Value l1bArray;
   1317     l1bArray.append( 10 );
   1318     Json::Value l2aArray;
   1319     l2aArray.append( 0 );
   1320     l2aArray.append( 0 );
   1321     Json::Value l2bArray;
   1322     l2bArray.append( 0 );
   1323     l2bArray.append( 10 );
   1324     JSONTEST_ASSERT_PRED( checkIsLess( emptyArray, l1aArray ) );
   1325     JSONTEST_ASSERT_PRED( checkIsLess( emptyArray, l2aArray ) );
   1326     JSONTEST_ASSERT_PRED( checkIsLess( l1aArray, l2aArray ) );
   1327     JSONTEST_ASSERT_PRED( checkIsLess( l2aArray, l2bArray ) );
   1328     JSONTEST_ASSERT_PRED( checkIsEqual( emptyArray, Json::Value( emptyArray ) ) );
   1329     JSONTEST_ASSERT_PRED( checkIsEqual( l1aArray, Json::Value( l1aArray) ) );
   1330     JSONTEST_ASSERT_PRED( checkIsEqual( l2bArray, Json::Value( l2bArray) ) );
   1331 }
   1332 
   1333 
   1334 JSONTEST_FIXTURE( ValueTest, compareObject )
   1335 {
   1336     // object compare size then content
   1337     Json::Value emptyObject(Json::objectValue);
   1338     Json::Value l1aObject;
   1339     l1aObject["key1"] = 0;
   1340     Json::Value l1bObject;
   1341     l1aObject["key1"] = 10;
   1342     Json::Value l2aObject;
   1343     l2aObject["key1"] = 0;
   1344     l2aObject["key2"] = 0;
   1345     JSONTEST_ASSERT_PRED( checkIsLess( emptyObject, l1aObject ) );
   1346     JSONTEST_ASSERT_PRED( checkIsLess( emptyObject, l2aObject ) );
   1347     JSONTEST_ASSERT_PRED( checkIsLess( l1aObject, l2aObject ) );
   1348     JSONTEST_ASSERT_PRED( checkIsEqual( emptyObject, Json::Value( emptyObject ) ) );
   1349     JSONTEST_ASSERT_PRED( checkIsEqual( l1aObject, Json::Value( l1aObject ) ) );
   1350     JSONTEST_ASSERT_PRED( checkIsEqual( l2aObject, Json::Value( l2aObject ) ) );
   1351 }
   1352 
   1353 
   1354 JSONTEST_FIXTURE( ValueTest, compareType )
   1355 {
   1356     // object of different type are ordered according to their type
   1357     JSONTEST_ASSERT_PRED( checkIsLess( Json::Value(), Json::Value(1) ) );
   1358     JSONTEST_ASSERT_PRED( checkIsLess( Json::Value(1), Json::Value(1u) ) );
   1359     JSONTEST_ASSERT_PRED( checkIsLess( Json::Value(1u), Json::Value(1.0) ) );
   1360     JSONTEST_ASSERT_PRED( checkIsLess( Json::Value(1.0), Json::Value("a") ) );
   1361     JSONTEST_ASSERT_PRED( checkIsLess( Json::Value("a"), Json::Value(true) ) );
   1362     JSONTEST_ASSERT_PRED( checkIsLess( Json::Value(true), Json::Value(Json::arrayValue) ) );
   1363     JSONTEST_ASSERT_PRED( checkIsLess( Json::Value(Json::arrayValue), Json::Value(Json::objectValue) ) );
   1364 }
   1365 
   1366 
   1367 void
   1368 ValueTest::checkIsLess( const Json::Value &x, const Json::Value &y )
   1369 {
   1370     JSONTEST_ASSERT( x < y );
   1371     JSONTEST_ASSERT( y > x );
   1372     JSONTEST_ASSERT( x <= y );
   1373     JSONTEST_ASSERT( y >= x );
   1374     JSONTEST_ASSERT( !(x == y) );
   1375     JSONTEST_ASSERT( !(y == x) );
   1376     JSONTEST_ASSERT( !(x >= y) );
   1377     JSONTEST_ASSERT( !(y <= x) );
   1378     JSONTEST_ASSERT( !(x > y) );
   1379     JSONTEST_ASSERT( !(y < x) );
   1380     JSONTEST_ASSERT( x.compare( y ) < 0 );
   1381     JSONTEST_ASSERT( y.compare( x ) >= 0 );
   1382 }
   1383 
   1384 
   1385 void
   1386 ValueTest::checkIsEqual( const Json::Value &x, const Json::Value &y )
   1387 {
   1388     JSONTEST_ASSERT( x == y );
   1389     JSONTEST_ASSERT( y == x );
   1390     JSONTEST_ASSERT( x <= y );
   1391     JSONTEST_ASSERT( y <= x );
   1392     JSONTEST_ASSERT( x >= y );
   1393     JSONTEST_ASSERT( y >= x );
   1394     JSONTEST_ASSERT( !(x < y) );
   1395     JSONTEST_ASSERT( !(y < x) );
   1396     JSONTEST_ASSERT( !(x > y) );
   1397     JSONTEST_ASSERT( !(y > x) );
   1398     JSONTEST_ASSERT( x.compare( y ) == 0 );
   1399     JSONTEST_ASSERT( y.compare( x ) == 0 );
   1400 }
   1401 
   1402 int main( int argc, const char *argv[] )
   1403 {
   1404    JsonTest::Runner runner;
   1405    JSONTEST_REGISTER_FIXTURE( runner, ValueTest, checkNormalizeFloatingPointStr );
   1406    JSONTEST_REGISTER_FIXTURE( runner, ValueTest, memberCount );
   1407    JSONTEST_REGISTER_FIXTURE( runner, ValueTest, objects );
   1408    JSONTEST_REGISTER_FIXTURE( runner, ValueTest, arrays );
   1409    JSONTEST_REGISTER_FIXTURE( runner, ValueTest, null );
   1410    JSONTEST_REGISTER_FIXTURE( runner, ValueTest, strings );
   1411    JSONTEST_REGISTER_FIXTURE( runner, ValueTest, bools );
   1412    JSONTEST_REGISTER_FIXTURE( runner, ValueTest, integers );
   1413    JSONTEST_REGISTER_FIXTURE( runner, ValueTest, nonIntegers );
   1414    JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareNull );
   1415    JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareInt );
   1416    JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareUInt );
   1417    JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareDouble );
   1418    JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareString );
   1419    JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareBoolean );
   1420    JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareArray );
   1421    JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareObject );
   1422    JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareType );
   1423    return runner.runCommandLine( argc, argv );
   1424 }
   1425