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