rippled
Loading...
Searching...
No Matches
Value.cpp
1#include <xrpl/beast/core/LexicalCast.h>
2#include <xrpl/json/json_errors.h>
3#include <xrpl/json/json_reader.h>
4#include <xrpl/json/json_value.h>
5#include <xrpl/json/json_writer.h>
6
7#include <gtest/gtest.h>
8
9#include <algorithm>
10#include <cmath>
11#include <regex>
12#include <sstream>
13#include <string>
14
15namespace xrpl {
16
17TEST(json_value, limits)
18{
19 using namespace Json;
20 static_assert(Value::minInt == Int(~(UInt(-1) / 2)));
21 static_assert(Value::maxInt == Int(UInt(-1) / 2));
22 static_assert(Value::maxUInt == UInt(-1));
23}
24
25TEST(json_value, construct_and_compare_Json_StaticString)
26{
27 static constexpr char sample[]{"Contents of a Json::StaticString"};
28
29 static constexpr Json::StaticString test1(sample);
30 char const* addrTest1{test1};
31
32 EXPECT_EQ(addrTest1, &sample[0]);
33 EXPECT_EQ(test1.c_str(), &sample[0]);
34
35 static constexpr Json::StaticString test2{
36 "Contents of a Json::StaticString"};
37 static constexpr Json::StaticString test3{"Another StaticString"};
38
39 EXPECT_EQ(test1, test2);
40 EXPECT_NE(test1, test3);
41
42 std::string str{sample};
43 EXPECT_EQ(str, test2);
44 EXPECT_NE(str, test3);
45 EXPECT_EQ(test2, str);
46 EXPECT_NE(test3, str);
47}
48
49TEST(json_value, different_types)
50{
51 // Exercise ValueType constructor
52 static constexpr Json::StaticString staticStr{"staticStr"};
53
54 auto testCopy = [](Json::ValueType typ) {
55 Json::Value val{typ};
56 Json::Value cpy{val};
57 EXPECT_EQ(val.type(), typ);
58 EXPECT_EQ(cpy.type(), typ);
59 return val;
60 };
61 {
62 Json::Value const nullV{testCopy(Json::nullValue)};
63 EXPECT_TRUE(nullV.isNull());
64 EXPECT_FALSE(nullV.isBool());
65 EXPECT_FALSE(nullV.isInt());
66 EXPECT_FALSE(nullV.isUInt());
67 EXPECT_FALSE(nullV.isIntegral());
68 EXPECT_FALSE(nullV.isDouble());
69 EXPECT_FALSE(nullV.isNumeric());
70 EXPECT_FALSE(nullV.isString());
71 EXPECT_FALSE(nullV.isArray());
72 EXPECT_TRUE(nullV.isArrayOrNull());
73 EXPECT_FALSE(nullV.isObject());
74 EXPECT_TRUE(nullV.isObjectOrNull());
75 }
76 {
77 Json::Value const intV{testCopy(Json::intValue)};
78 EXPECT_FALSE(intV.isNull());
79 EXPECT_FALSE(intV.isBool());
80 EXPECT_TRUE(intV.isInt());
81 EXPECT_FALSE(intV.isUInt());
82 EXPECT_TRUE(intV.isIntegral());
83 EXPECT_FALSE(intV.isDouble());
84 EXPECT_TRUE(intV.isNumeric());
85 EXPECT_FALSE(intV.isString());
86 EXPECT_FALSE(intV.isArray());
87 EXPECT_FALSE(intV.isArrayOrNull());
88 EXPECT_FALSE(intV.isObject());
89 EXPECT_FALSE(intV.isObjectOrNull());
90 }
91 {
92 Json::Value const uintV{testCopy(Json::uintValue)};
93 EXPECT_FALSE(uintV.isNull());
94 EXPECT_FALSE(uintV.isBool());
95 EXPECT_FALSE(uintV.isInt());
96 EXPECT_TRUE(uintV.isUInt());
97 EXPECT_TRUE(uintV.isIntegral());
98 EXPECT_FALSE(uintV.isDouble());
99 EXPECT_TRUE(uintV.isNumeric());
100 EXPECT_FALSE(uintV.isString());
101 EXPECT_FALSE(uintV.isArray());
102 EXPECT_FALSE(uintV.isArrayOrNull());
103 EXPECT_FALSE(uintV.isObject());
104 EXPECT_FALSE(uintV.isObjectOrNull());
105 }
106 {
107 Json::Value const realV{testCopy(Json::realValue)};
108 EXPECT_FALSE(realV.isNull());
109 EXPECT_FALSE(realV.isBool());
110 EXPECT_FALSE(realV.isInt());
111 EXPECT_FALSE(realV.isUInt());
112 EXPECT_FALSE(realV.isIntegral());
113 EXPECT_TRUE(realV.isDouble());
114 EXPECT_TRUE(realV.isNumeric());
115 EXPECT_FALSE(realV.isString());
116 EXPECT_FALSE(realV.isArray());
117 EXPECT_FALSE(realV.isArrayOrNull());
118 EXPECT_FALSE(realV.isObject());
119 EXPECT_FALSE(realV.isObjectOrNull());
120 }
121 {
122 Json::Value const stringV{testCopy(Json::stringValue)};
123 EXPECT_FALSE(stringV.isNull());
124 EXPECT_FALSE(stringV.isBool());
125 EXPECT_FALSE(stringV.isInt());
126 EXPECT_FALSE(stringV.isUInt());
127 EXPECT_FALSE(stringV.isIntegral());
128 EXPECT_FALSE(stringV.isDouble());
129 EXPECT_FALSE(stringV.isNumeric());
130 EXPECT_TRUE(stringV.isString());
131 EXPECT_FALSE(stringV.isArray());
132 EXPECT_FALSE(stringV.isArrayOrNull());
133 EXPECT_FALSE(stringV.isObject());
134 EXPECT_FALSE(stringV.isObjectOrNull());
135 }
136 {
137 Json::Value const staticStrV{staticStr};
138 {
139 Json::Value cpy{staticStrV};
140 EXPECT_EQ(staticStrV.type(), Json::stringValue);
141 EXPECT_EQ(cpy.type(), Json::stringValue);
142 }
143 EXPECT_FALSE(staticStrV.isNull());
144 EXPECT_FALSE(staticStrV.isBool());
145 EXPECT_FALSE(staticStrV.isInt());
146 EXPECT_FALSE(staticStrV.isUInt());
147 EXPECT_FALSE(staticStrV.isIntegral());
148 EXPECT_FALSE(staticStrV.isDouble());
149 EXPECT_FALSE(staticStrV.isNumeric());
150 EXPECT_TRUE(staticStrV.isString());
151 EXPECT_FALSE(staticStrV.isArray());
152 EXPECT_FALSE(staticStrV.isArrayOrNull());
153 EXPECT_FALSE(staticStrV.isObject());
154 EXPECT_FALSE(staticStrV.isObjectOrNull());
155 }
156 {
157 Json::Value const boolV{testCopy(Json::booleanValue)};
158 EXPECT_FALSE(boolV.isNull());
159 EXPECT_TRUE(boolV.isBool());
160 EXPECT_FALSE(boolV.isInt());
161 EXPECT_FALSE(boolV.isUInt());
162 EXPECT_TRUE(boolV.isIntegral());
163 EXPECT_FALSE(boolV.isDouble());
164 EXPECT_TRUE(boolV.isNumeric());
165 EXPECT_FALSE(boolV.isString());
166 EXPECT_FALSE(boolV.isArray());
167 EXPECT_FALSE(boolV.isArrayOrNull());
168 EXPECT_FALSE(boolV.isObject());
169 EXPECT_FALSE(boolV.isObjectOrNull());
170 }
171 {
172 Json::Value const arrayV{testCopy(Json::arrayValue)};
173 EXPECT_FALSE(arrayV.isNull());
174 EXPECT_FALSE(arrayV.isBool());
175 EXPECT_FALSE(arrayV.isInt());
176 EXPECT_FALSE(arrayV.isUInt());
177 EXPECT_FALSE(arrayV.isIntegral());
178 EXPECT_FALSE(arrayV.isDouble());
179 EXPECT_FALSE(arrayV.isNumeric());
180 EXPECT_FALSE(arrayV.isString());
181 EXPECT_TRUE(arrayV.isArray());
182 EXPECT_TRUE(arrayV.isArrayOrNull());
183 EXPECT_FALSE(arrayV.isObject());
184 EXPECT_FALSE(arrayV.isObjectOrNull());
185 }
186 {
187 Json::Value const objectV{testCopy(Json::objectValue)};
188 EXPECT_FALSE(objectV.isNull());
189 EXPECT_FALSE(objectV.isBool());
190 EXPECT_FALSE(objectV.isInt());
191 EXPECT_FALSE(objectV.isUInt());
192 EXPECT_FALSE(objectV.isIntegral());
193 EXPECT_FALSE(objectV.isDouble());
194 EXPECT_FALSE(objectV.isNumeric());
195 EXPECT_FALSE(objectV.isString());
196 EXPECT_FALSE(objectV.isArray());
197 EXPECT_FALSE(objectV.isArrayOrNull());
198 EXPECT_TRUE(objectV.isObject());
199 EXPECT_TRUE(objectV.isObjectOrNull());
200 }
201}
202
203TEST(json_value, compare_strings)
204{
205 auto doCompare = [&](Json::Value const& lhs,
206 Json::Value const& rhs,
207 bool lhsEqRhs,
208 bool lhsLtRhs,
209 int line) {
210 SCOPED_TRACE(line);
211 EXPECT_EQ((lhs == rhs), lhsEqRhs);
212 EXPECT_NE((lhs != rhs), lhsEqRhs);
213 EXPECT_EQ((lhs < rhs), (!(lhsEqRhs || !lhsLtRhs)));
214 EXPECT_EQ((lhs <= rhs), (lhsEqRhs || lhsLtRhs));
215 EXPECT_EQ((lhs >= rhs), (lhsEqRhs || !lhsLtRhs));
216 EXPECT_EQ((lhs > rhs), (!(lhsEqRhs || lhsLtRhs)));
217 };
218
219 Json::Value const null0;
220 Json::Value const intNeg1{-1};
221 Json::Value const int0{Json::intValue};
222 Json::Value const intPos1{1};
223 Json::Value const uint0{Json::uintValue};
224 Json::Value const uint1{1u};
225 Json::Value const realNeg1{-1.0};
226 Json::Value const real0{Json::realValue};
227 Json::Value const realPos1{1.0};
228 Json::Value const str0{Json::stringValue};
229 Json::Value const str1{"1"};
230 Json::Value const boolF{false};
231 Json::Value const boolT{true};
232 Json::Value const array0{Json::arrayValue};
233 Json::Value const array1{[]() {
234 Json::Value array1;
235 array1[0u] = 1;
236 return array1;
237 }()};
238 Json::Value const obj0{Json::objectValue};
239 Json::Value const obj1{[]() {
240 Json::Value obj1;
241 obj1["one"] = 1;
242 return obj1;
243 }()};
244
245#pragma push_macro("DO_COMPARE")
246 // DO_COMPARE(lhs, rhs, lhsEqualsToRhs lhsLessThanRhs)
247#define DO_COMPARE(lhs, rhs, eq, lt) doCompare(lhs, rhs, eq, lt, __LINE__)
248 DO_COMPARE(null0, Json::Value{}, true, false);
249 DO_COMPARE(null0, intNeg1, false, true);
250 DO_COMPARE(null0, int0, false, true);
251 DO_COMPARE(null0, intPos1, false, true);
252 DO_COMPARE(null0, uint0, false, true);
253 DO_COMPARE(null0, uint1, false, true);
254 DO_COMPARE(null0, realNeg1, false, true);
255 DO_COMPARE(null0, real0, false, true);
256 DO_COMPARE(null0, realPos1, false, true);
257 DO_COMPARE(null0, str0, false, true);
258 DO_COMPARE(null0, str1, false, true);
259 DO_COMPARE(null0, boolF, false, true);
260 DO_COMPARE(null0, boolT, false, true);
261 DO_COMPARE(null0, array0, false, true);
262 DO_COMPARE(null0, array1, false, true);
263 DO_COMPARE(null0, obj0, false, true);
264 DO_COMPARE(null0, obj1, false, true);
265
266 DO_COMPARE(intNeg1, null0, false, false);
267 DO_COMPARE(intNeg1, intNeg1, true, false);
268 DO_COMPARE(intNeg1, int0, false, true);
269 DO_COMPARE(intNeg1, intPos1, false, true);
270 DO_COMPARE(intNeg1, uint0, false, true);
271 DO_COMPARE(intNeg1, uint1, false, true);
272 DO_COMPARE(intNeg1, realNeg1, false, true);
273 DO_COMPARE(intNeg1, real0, false, true);
274 DO_COMPARE(intNeg1, realPos1, false, true);
275 DO_COMPARE(intNeg1, str0, false, true);
276 DO_COMPARE(intNeg1, str1, false, true);
277 DO_COMPARE(intNeg1, boolF, false, true);
278 DO_COMPARE(intNeg1, boolT, false, true);
279 DO_COMPARE(intNeg1, array0, false, true);
280 DO_COMPARE(intNeg1, array1, false, true);
281 DO_COMPARE(intNeg1, obj0, false, true);
282 DO_COMPARE(intNeg1, obj1, false, true);
283
284 DO_COMPARE(int0, null0, false, false);
285 DO_COMPARE(int0, intNeg1, false, false);
286 DO_COMPARE(int0, int0, true, false);
287 DO_COMPARE(int0, intPos1, false, true);
288 DO_COMPARE(int0, uint0, true, false);
289 DO_COMPARE(int0, uint1, false, true);
290 DO_COMPARE(int0, realNeg1, false, true);
291 DO_COMPARE(int0, real0, false, true);
292 DO_COMPARE(int0, realPos1, false, true);
293 DO_COMPARE(int0, str0, false, true);
294 DO_COMPARE(int0, str1, false, true);
295 DO_COMPARE(int0, boolF, false, true);
296 DO_COMPARE(int0, boolT, false, true);
297 DO_COMPARE(int0, array0, false, true);
298 DO_COMPARE(int0, array1, false, true);
299 DO_COMPARE(int0, obj0, false, true);
300 DO_COMPARE(int0, obj1, false, true);
301
302 DO_COMPARE(intPos1, null0, false, false);
303 DO_COMPARE(intPos1, intNeg1, false, false);
304 DO_COMPARE(intPos1, int0, false, false);
305 DO_COMPARE(intPos1, intPos1, true, false);
306 DO_COMPARE(intPos1, uint0, false, false);
307 DO_COMPARE(intPos1, uint1, true, false);
308 DO_COMPARE(intPos1, realNeg1, false, true);
309 DO_COMPARE(intPos1, real0, false, true);
310 DO_COMPARE(intPos1, realPos1, false, true);
311 DO_COMPARE(intPos1, str0, false, true);
312 DO_COMPARE(intPos1, str1, false, true);
313 DO_COMPARE(intPos1, boolF, false, true);
314 DO_COMPARE(intPos1, boolT, false, true);
315 DO_COMPARE(intPos1, array0, false, true);
316 DO_COMPARE(intPos1, array1, false, true);
317 DO_COMPARE(intPos1, obj0, false, true);
318 DO_COMPARE(intPos1, obj1, false, true);
319
320 DO_COMPARE(uint0, null0, false, false);
321 DO_COMPARE(uint0, intNeg1, false, false);
322 DO_COMPARE(uint0, int0, true, false);
323 DO_COMPARE(uint0, intPos1, false, true);
324 DO_COMPARE(uint0, uint0, true, false);
325 DO_COMPARE(uint0, uint1, false, true);
326 DO_COMPARE(uint0, realNeg1, false, true);
327 DO_COMPARE(uint0, real0, false, true);
328 DO_COMPARE(uint0, realPos1, false, true);
329 DO_COMPARE(uint0, str0, false, true);
330 DO_COMPARE(uint0, str1, false, true);
331 DO_COMPARE(uint0, boolF, false, true);
332 DO_COMPARE(uint0, boolT, false, true);
333 DO_COMPARE(uint0, array0, false, true);
334 DO_COMPARE(uint0, array1, false, true);
335 DO_COMPARE(uint0, obj0, false, true);
336 DO_COMPARE(uint0, obj1, false, true);
337
338 DO_COMPARE(uint1, null0, false, false);
339 DO_COMPARE(uint1, intNeg1, false, false);
340 DO_COMPARE(uint1, int0, false, false);
341 DO_COMPARE(uint1, intPos1, true, false);
342 DO_COMPARE(uint1, uint0, false, false);
343 DO_COMPARE(uint1, uint1, true, false);
344 DO_COMPARE(uint1, realNeg1, false, true);
345 DO_COMPARE(uint1, real0, false, true);
346 DO_COMPARE(uint1, realPos1, false, true);
347 DO_COMPARE(uint1, str0, false, true);
348 DO_COMPARE(uint1, str1, false, true);
349 DO_COMPARE(uint1, boolF, false, true);
350 DO_COMPARE(uint1, boolT, false, true);
351 DO_COMPARE(uint1, array0, false, true);
352 DO_COMPARE(uint1, array1, false, true);
353 DO_COMPARE(uint1, obj0, false, true);
354 DO_COMPARE(uint1, obj1, false, true);
355
356 DO_COMPARE(realNeg1, null0, false, false);
357 DO_COMPARE(realNeg1, intNeg1, false, false);
358 DO_COMPARE(realNeg1, int0, false, false);
359 DO_COMPARE(realNeg1, intPos1, false, false);
360 DO_COMPARE(realNeg1, uint0, false, false);
361 DO_COMPARE(realNeg1, uint1, false, false);
362 DO_COMPARE(realNeg1, realNeg1, true, false);
363 DO_COMPARE(realNeg1, real0, false, true);
364 DO_COMPARE(realNeg1, realPos1, false, true);
365 DO_COMPARE(realNeg1, str0, false, true);
366 DO_COMPARE(realNeg1, str1, false, true);
367 DO_COMPARE(realNeg1, boolF, false, true);
368 DO_COMPARE(realNeg1, boolT, false, true);
369 DO_COMPARE(realNeg1, array0, false, true);
370 DO_COMPARE(realNeg1, array1, false, true);
371 DO_COMPARE(realNeg1, obj0, false, true);
372 DO_COMPARE(realNeg1, obj1, false, true);
373
374 DO_COMPARE(real0, null0, false, false);
375 DO_COMPARE(real0, intNeg1, false, false);
376 DO_COMPARE(real0, int0, false, false);
377 DO_COMPARE(real0, intPos1, false, false);
378 DO_COMPARE(real0, uint0, false, false);
379 DO_COMPARE(real0, uint1, false, false);
380 DO_COMPARE(real0, realNeg1, false, false);
381 DO_COMPARE(real0, real0, true, false);
382 DO_COMPARE(real0, realPos1, false, true);
383 DO_COMPARE(real0, str0, false, true);
384 DO_COMPARE(real0, str1, false, true);
385 DO_COMPARE(real0, boolF, false, true);
386 DO_COMPARE(real0, boolT, false, true);
387 DO_COMPARE(real0, array0, false, true);
388 DO_COMPARE(real0, array1, false, true);
389 DO_COMPARE(real0, obj0, false, true);
390 DO_COMPARE(real0, obj1, false, true);
391
392 DO_COMPARE(realPos1, null0, false, false);
393 DO_COMPARE(realPos1, intNeg1, false, false);
394 DO_COMPARE(realPos1, int0, false, false);
395 DO_COMPARE(realPos1, intPos1, false, false);
396 DO_COMPARE(realPos1, uint0, false, false);
397 DO_COMPARE(realPos1, uint1, false, false);
398 DO_COMPARE(realPos1, realNeg1, false, false);
399 DO_COMPARE(realPos1, real0, false, false);
400 DO_COMPARE(realPos1, realPos1, true, false);
401 DO_COMPARE(realPos1, str0, false, true);
402 DO_COMPARE(realPos1, str1, false, true);
403 DO_COMPARE(realPos1, boolF, false, true);
404 DO_COMPARE(realPos1, boolT, false, true);
405 DO_COMPARE(realPos1, array0, false, true);
406 DO_COMPARE(realPos1, array1, false, true);
407 DO_COMPARE(realPos1, obj0, false, true);
408 DO_COMPARE(realPos1, obj1, false, true);
409
410 DO_COMPARE(str0, null0, false, false);
411 DO_COMPARE(str0, intNeg1, false, false);
412 DO_COMPARE(str0, int0, false, false);
413 DO_COMPARE(str0, intPos1, false, false);
414 DO_COMPARE(str0, uint0, false, false);
415 DO_COMPARE(str0, uint1, false, false);
416 DO_COMPARE(str0, realNeg1, false, false);
417 DO_COMPARE(str0, real0, false, false);
418 DO_COMPARE(str0, realPos1, false, false);
419 DO_COMPARE(str0, str0, true, false);
420 DO_COMPARE(str0, str1, false, true);
421 DO_COMPARE(str0, boolF, false, true);
422 DO_COMPARE(str0, boolT, false, true);
423 DO_COMPARE(str0, array0, false, true);
424 DO_COMPARE(str0, array1, false, true);
425 DO_COMPARE(str0, obj0, false, true);
426 DO_COMPARE(str0, obj1, false, true);
427
428 DO_COMPARE(str1, null0, false, false);
429 DO_COMPARE(str1, intNeg1, false, false);
430 DO_COMPARE(str1, int0, false, false);
431 DO_COMPARE(str1, intPos1, false, false);
432 DO_COMPARE(str1, uint0, false, false);
433 DO_COMPARE(str1, uint1, false, false);
434 DO_COMPARE(str1, realNeg1, false, false);
435 DO_COMPARE(str1, real0, false, false);
436 DO_COMPARE(str1, realPos1, false, false);
437 DO_COMPARE(str1, str0, false, false);
438 DO_COMPARE(str1, str1, true, false);
439 DO_COMPARE(str1, boolF, false, true);
440 DO_COMPARE(str1, boolT, false, true);
441 DO_COMPARE(str1, array0, false, true);
442 DO_COMPARE(str1, array1, false, true);
443 DO_COMPARE(str1, obj0, false, true);
444 DO_COMPARE(str1, obj1, false, true);
445
446 DO_COMPARE(boolF, null0, false, false);
447 DO_COMPARE(boolF, intNeg1, false, false);
448 DO_COMPARE(boolF, int0, false, false);
449 DO_COMPARE(boolF, intPos1, false, false);
450 DO_COMPARE(boolF, uint0, false, false);
451 DO_COMPARE(boolF, uint1, false, false);
452 DO_COMPARE(boolF, realNeg1, false, false);
453 DO_COMPARE(boolF, real0, false, false);
454 DO_COMPARE(boolF, realPos1, false, false);
455 DO_COMPARE(boolF, str0, false, false);
456 DO_COMPARE(boolF, str1, false, false);
457 DO_COMPARE(boolF, boolF, true, false);
458 DO_COMPARE(boolF, boolT, false, true);
459 DO_COMPARE(boolF, array0, false, true);
460 DO_COMPARE(boolF, array1, false, true);
461 DO_COMPARE(boolF, obj0, false, true);
462 DO_COMPARE(boolF, obj1, false, true);
463
464 DO_COMPARE(boolT, null0, false, false);
465 DO_COMPARE(boolT, intNeg1, false, false);
466 DO_COMPARE(boolT, int0, false, false);
467 DO_COMPARE(boolT, intPos1, false, false);
468 DO_COMPARE(boolT, uint0, false, false);
469 DO_COMPARE(boolT, uint1, false, false);
470 DO_COMPARE(boolT, realNeg1, false, false);
471 DO_COMPARE(boolT, real0, false, false);
472 DO_COMPARE(boolT, realPos1, false, false);
473 DO_COMPARE(boolT, str0, false, false);
474 DO_COMPARE(boolT, str1, false, false);
475 DO_COMPARE(boolT, boolF, false, false);
476 DO_COMPARE(boolT, boolT, true, false);
477 DO_COMPARE(boolT, array0, false, true);
478 DO_COMPARE(boolT, array1, false, true);
479 DO_COMPARE(boolT, obj0, false, true);
480 DO_COMPARE(boolT, obj1, false, true);
481
482 DO_COMPARE(array0, null0, false, false);
483 DO_COMPARE(array0, intNeg1, false, false);
484 DO_COMPARE(array0, int0, false, false);
485 DO_COMPARE(array0, intPos1, false, false);
486 DO_COMPARE(array0, uint0, false, false);
487 DO_COMPARE(array0, uint1, false, false);
488 DO_COMPARE(array0, realNeg1, false, false);
489 DO_COMPARE(array0, real0, false, false);
490 DO_COMPARE(array0, realPos1, false, false);
491 DO_COMPARE(array0, str0, false, false);
492 DO_COMPARE(array0, str1, false, false);
493 DO_COMPARE(array0, boolF, false, false);
494 DO_COMPARE(array0, boolT, false, false);
495 DO_COMPARE(array0, array0, true, false);
496 DO_COMPARE(array0, array1, false, true);
497 DO_COMPARE(array0, obj0, false, true);
498 DO_COMPARE(array0, obj1, false, true);
499
500 DO_COMPARE(array1, null0, false, false);
501 DO_COMPARE(array1, intNeg1, false, false);
502 DO_COMPARE(array1, int0, false, false);
503 DO_COMPARE(array1, intPos1, false, false);
504 DO_COMPARE(array1, uint0, false, false);
505 DO_COMPARE(array1, uint1, false, false);
506 DO_COMPARE(array1, realNeg1, false, false);
507 DO_COMPARE(array1, real0, false, false);
508 DO_COMPARE(array1, realPos1, false, false);
509 DO_COMPARE(array1, str0, false, false);
510 DO_COMPARE(array1, str1, false, false);
511 DO_COMPARE(array1, boolF, false, false);
512 DO_COMPARE(array1, boolT, false, false);
513 DO_COMPARE(array1, array0, false, false);
514 DO_COMPARE(array1, array1, true, false);
515 DO_COMPARE(array1, obj0, false, true);
516 DO_COMPARE(array1, obj1, false, true);
517
518 DO_COMPARE(obj0, null0, false, false);
519 DO_COMPARE(obj0, intNeg1, false, false);
520 DO_COMPARE(obj0, int0, false, false);
521 DO_COMPARE(obj0, intPos1, false, false);
522 DO_COMPARE(obj0, uint0, false, false);
523 DO_COMPARE(obj0, uint1, false, false);
524 DO_COMPARE(obj0, realNeg1, false, false);
525 DO_COMPARE(obj0, real0, false, false);
526 DO_COMPARE(obj0, realPos1, false, false);
527 DO_COMPARE(obj0, str0, false, false);
528 DO_COMPARE(obj0, str1, false, false);
529 DO_COMPARE(obj0, boolF, false, false);
530 DO_COMPARE(obj0, boolT, false, false);
531 DO_COMPARE(obj0, array0, false, false);
532 DO_COMPARE(obj0, array1, false, false);
533 DO_COMPARE(obj0, obj0, true, false);
534 DO_COMPARE(obj0, obj1, false, true);
535
536 DO_COMPARE(obj1, null0, false, false);
537 DO_COMPARE(obj1, intNeg1, false, false);
538 DO_COMPARE(obj1, int0, false, false);
539 DO_COMPARE(obj1, intPos1, false, false);
540 DO_COMPARE(obj1, uint0, false, false);
541 DO_COMPARE(obj1, uint1, false, false);
542 DO_COMPARE(obj1, realNeg1, false, false);
543 DO_COMPARE(obj1, real0, false, false);
544 DO_COMPARE(obj1, realPos1, false, false);
545 DO_COMPARE(obj1, str0, false, false);
546 DO_COMPARE(obj1, str1, false, false);
547 DO_COMPARE(obj1, boolF, false, false);
548 DO_COMPARE(obj1, boolT, false, false);
549 DO_COMPARE(obj1, array0, false, false);
550 DO_COMPARE(obj1, array1, false, false);
551 DO_COMPARE(obj1, obj0, false, false);
552 DO_COMPARE(obj1, obj1, true, false);
553#undef DO_COMPARE
554#pragma pop_macro("DO_COMPARE")
555}
556
557TEST(json_value, bool)
558{
559 EXPECT_FALSE(Json::Value());
560
561 EXPECT_FALSE(Json::Value(""));
562
563 EXPECT_TRUE(bool(Json::Value("empty")));
564 EXPECT_TRUE(bool(Json::Value(false)));
565 EXPECT_TRUE(bool(Json::Value(true)));
566 EXPECT_TRUE(bool(Json::Value(0)));
567 EXPECT_TRUE(bool(Json::Value(1)));
568
569 Json::Value array(Json::arrayValue);
570 EXPECT_FALSE(array);
571 array.append(0);
572 EXPECT_TRUE(bool(array));
573
574 Json::Value object(Json::objectValue);
575 EXPECT_FALSE(object);
576 object[""] = false;
577 EXPECT_TRUE(bool(object));
578}
579
580TEST(json_value, bad_json)
581{
582 char const* s(R"({"method":"ledger","params":[{"ledger_index":1e300}]})");
583
584 Json::Value j;
585 Json::Reader r;
586
587 EXPECT_TRUE(r.parse(s, j));
588}
589
590TEST(json_value, edge_cases)
591{
592 std::uint32_t max_uint = std::numeric_limits<std::uint32_t>::max();
593 std::int32_t max_int = std::numeric_limits<std::int32_t>::max();
594 std::int32_t min_int = std::numeric_limits<std::int32_t>::min();
595
596 std::uint32_t a_uint = max_uint - 1978;
597 std::int32_t a_large_int = max_int - 1978;
598 std::int32_t a_small_int = min_int + 1978;
599
600 {
601 std::string json = "{\"max_uint\":" + std::to_string(max_uint);
602 json += ",\"max_int\":" + std::to_string(max_int);
603 json += ",\"min_int\":" + std::to_string(min_int);
604 json += ",\"a_uint\":" + std::to_string(a_uint);
605 json += ",\"a_large_int\":" + std::to_string(a_large_int);
606 json += ",\"a_small_int\":" + std::to_string(a_small_int);
607 json += "}";
608
609 Json::Value j1;
610 Json::Reader r1;
611
612 EXPECT_TRUE(r1.parse(json, j1));
613 EXPECT_EQ(j1["max_uint"].asUInt(), max_uint);
614 EXPECT_EQ(j1["max_uint"].asAbsUInt(), max_uint);
615 EXPECT_EQ(j1["max_int"].asInt(), max_int);
616 EXPECT_EQ(j1["max_int"].asAbsUInt(), max_int);
617 EXPECT_EQ(j1["min_int"].asInt(), min_int);
618 EXPECT_EQ(
619 j1["min_int"].asAbsUInt(), static_cast<std::int64_t>(min_int) * -1);
620 EXPECT_EQ(j1["a_uint"].asUInt(), a_uint);
621 EXPECT_EQ(j1["a_uint"].asAbsUInt(), a_uint);
622 EXPECT_GT(j1["a_uint"], a_large_int);
623 EXPECT_GT(j1["a_uint"], a_small_int);
624 EXPECT_EQ(j1["a_large_int"].asInt(), a_large_int);
625 EXPECT_EQ(j1["a_large_int"].asAbsUInt(), a_large_int);
626 EXPECT_EQ(j1["a_large_int"].asUInt(), a_large_int);
627 EXPECT_LT(j1["a_large_int"], a_uint);
628 EXPECT_EQ(j1["a_small_int"].asInt(), a_small_int);
629 EXPECT_EQ(
630 j1["a_small_int"].asAbsUInt(),
631 static_cast<std::int64_t>(a_small_int) * -1);
632 EXPECT_LT(j1["a_small_int"], a_uint);
633 }
634
635 std::uint64_t overflow = std::uint64_t(max_uint) + 1;
636 {
637 std::string json = "{\"overflow\":";
638 json += std::to_string(overflow);
639 json += "}";
640
641 Json::Value j2;
642 Json::Reader r2;
643
644 EXPECT_FALSE(r2.parse(json, j2));
645 }
646
647 std::int64_t underflow = std::int64_t(min_int) - 1;
648 {
649 std::string json = "{\"underflow\":";
650 json += std::to_string(underflow);
651 json += "}";
652
653 Json::Value j3;
654 Json::Reader r3;
655
656 EXPECT_FALSE(r3.parse(json, j3));
657 }
658
659 {
660 Json::Value intString{std::to_string(overflow)};
661 EXPECT_THROW(intString.asUInt(), beast::BadLexicalCast);
662 EXPECT_THROW(intString.asAbsUInt(), Json::error);
663
664 intString = "4294967295";
665 EXPECT_EQ(intString.asUInt(), 4294967295u);
666 EXPECT_EQ(intString.asAbsUInt(), 4294967295u);
667
668 intString = "0";
669 EXPECT_EQ(intString.asUInt(), 0);
670 EXPECT_EQ(intString.asAbsUInt(), 0);
671
672 intString = "-1";
673 EXPECT_THROW(intString.asUInt(), beast::BadLexicalCast);
674 EXPECT_EQ(intString.asAbsUInt(), 1);
675
676 intString = "-4294967295";
677 EXPECT_EQ(intString.asAbsUInt(), 4294967295);
678
679 intString = "-4294967296";
680 EXPECT_THROW(intString.asAbsUInt(), Json::error);
681
682 intString = "2147483648";
683 EXPECT_THROW(intString.asInt(), beast::BadLexicalCast);
684 EXPECT_EQ(intString.asAbsUInt(), 2147483648);
685
686 intString = "2147483647";
687 EXPECT_EQ(intString.asInt(), 2147483647);
688 EXPECT_EQ(intString.asAbsUInt(), 2147483647);
689
690 intString = "-2147483648";
691 EXPECT_EQ(intString.asInt(), -2147483648LL); // MSVC wants the LL
692 EXPECT_EQ(intString.asAbsUInt(), 2147483648LL);
693
694 intString = "-2147483649";
695 EXPECT_THROW(intString.asInt(), beast::BadLexicalCast);
696 EXPECT_EQ(intString.asAbsUInt(), 2147483649);
697 }
698
699 {
700 Json::Value intReal{4294967297.0};
701 EXPECT_THROW(intReal.asUInt(), Json::error);
702 EXPECT_THROW(intReal.asAbsUInt(), Json::error);
703
704 intReal = 4294967295.0;
705 EXPECT_EQ(intReal.asUInt(), 4294967295u);
706 EXPECT_EQ(intReal.asAbsUInt(), 4294967295u);
707
708 intReal = 0.0;
709 EXPECT_EQ(intReal.asUInt(), 0);
710 EXPECT_EQ(intReal.asAbsUInt(), 0);
711
712 intReal = -1.0;
713 EXPECT_THROW(intReal.asUInt(), Json::error);
714 EXPECT_EQ(intReal.asAbsUInt(), 1);
715
716 intReal = -4294967295.0;
717 EXPECT_EQ(intReal.asAbsUInt(), 4294967295);
718
719 intReal = -4294967296.0;
720 EXPECT_THROW(intReal.asAbsUInt(), Json::error);
721
722 intReal = 2147483648.0;
723 EXPECT_THROW(intReal.asInt(), Json::error);
724 EXPECT_EQ(intReal.asAbsUInt(), 2147483648);
725
726 intReal = 2147483647.0;
727 EXPECT_EQ(intReal.asInt(), 2147483647);
728 EXPECT_EQ(intReal.asAbsUInt(), 2147483647);
729
730 intReal = -2147483648.0;
731 EXPECT_EQ(intReal.asInt(), -2147483648LL); // MSVC wants the LL
732 EXPECT_EQ(intReal.asAbsUInt(), 2147483648LL);
733
734 intReal = -2147483649.0;
735 EXPECT_THROW(intReal.asInt(), Json::error);
736 EXPECT_EQ(intReal.asAbsUInt(), 2147483649);
737 }
738}
739
740TEST(json_value, copy)
741{
742 Json::Value v1{2.5};
743 EXPECT_TRUE(v1.isDouble());
744 EXPECT_EQ(v1.asDouble(), 2.5);
745
746 Json::Value v2 = v1;
747 EXPECT_TRUE(v1.isDouble());
748 EXPECT_EQ(v1.asDouble(), 2.5);
749 EXPECT_TRUE(v2.isDouble());
750 EXPECT_EQ(v2.asDouble(), 2.5);
751 EXPECT_EQ(v1, v2);
752
753 v1 = v2;
754 EXPECT_TRUE(v1.isDouble());
755 EXPECT_EQ(v1.asDouble(), 2.5);
756 EXPECT_TRUE(v2.isDouble());
757 EXPECT_EQ(v2.asDouble(), 2.5);
758 EXPECT_EQ(v1, v2);
759}
760
761TEST(json_value, move)
762{
763 Json::Value v1{2.5};
764 EXPECT_TRUE(v1.isDouble());
765 EXPECT_EQ(v1.asDouble(), 2.5);
766
767 Json::Value v2 = std::move(v1);
768 EXPECT_FALSE(v1);
769 EXPECT_TRUE(v2.isDouble());
770 EXPECT_EQ(v2.asDouble(), 2.5);
771 EXPECT_NE(v1, v2);
772
773 v1 = std::move(v2);
774 EXPECT_TRUE(v1.isDouble());
775 EXPECT_EQ(v1.asDouble(), 2.5);
776 EXPECT_FALSE(v2);
777 EXPECT_NE(v1, v2);
778}
779
780TEST(json_value, comparisons)
781{
782 Json::Value a, b;
783 auto testEquals = [&](std::string const& name) {
784 EXPECT_TRUE(a == b);
785 EXPECT_TRUE(a <= b);
786 EXPECT_TRUE(a >= b);
787
788 EXPECT_FALSE(a != b);
789 EXPECT_FALSE(a < b);
790 EXPECT_FALSE(a > b);
791
792 EXPECT_TRUE(b == a);
793 EXPECT_TRUE(b <= a);
794 EXPECT_TRUE(b >= a);
795
796 EXPECT_FALSE(b != a);
797 EXPECT_FALSE(b < a);
798 EXPECT_FALSE(b > a);
799 };
800
801 auto testGreaterThan = [&](std::string const& name) {
802 EXPECT_FALSE(a == b);
803 EXPECT_FALSE(a <= b);
804 EXPECT_TRUE(a >= b);
805
806 EXPECT_TRUE(a != b);
807 EXPECT_FALSE(a < b);
808 EXPECT_TRUE(a > b);
809
810 EXPECT_FALSE(b == a);
811 EXPECT_TRUE(b <= a);
812 EXPECT_FALSE(b >= a);
813
814 EXPECT_TRUE(b != a);
815 EXPECT_TRUE(b < a);
816 EXPECT_FALSE(b > a);
817 };
818
819 a["a"] = Json::UInt(0);
820 b["a"] = Json::Int(0);
821 testEquals("zero");
822
823 b["a"] = Json::Int(-1);
824 testGreaterThan("negative");
825
826 Json::Int big = std::numeric_limits<int>::max();
827 Json::UInt bigger = big;
828 bigger++;
829
830 a["a"] = bigger;
831 b["a"] = big;
832 testGreaterThan("big");
833}
834
835TEST(json_value, compact)
836{
837 Json::Value j;
838 Json::Reader r;
839 char const* s("{\"array\":[{\"12\":23},{},null,false,0.5]}");
840
841 auto countLines = [](std::string const& str) {
842 return 1 + std::count_if(str.begin(), str.end(), [](char c) {
843 return c == '\n';
844 });
845 };
846
847 EXPECT_TRUE(r.parse(s, j));
848 {
849 std::stringstream ss;
850 ss << j;
851 EXPECT_GT(countLines(ss.str()), 1);
852 }
853 {
854 std::stringstream ss;
855 ss << Json::Compact(std::move(j));
856 EXPECT_EQ(countLines(ss.str()), 1);
857 }
858}
859
860TEST(json_value, conversions)
861{
862 // We have Json::Int, but not Json::Double or Json::Real.
863 // We have Json::Int, Json::Value::Int, and Json::ValueType::intValue.
864 // We have Json::ValueType::realValue but Json::Value::asDouble.
865 // TODO: What's the thinking here?
866 {
867 // null
868 Json::Value val;
869 EXPECT_TRUE(val.isNull());
870 // val.asCString() should trigger an assertion failure
871 EXPECT_EQ(val.asString(), "");
872 EXPECT_EQ(val.asInt(), 0);
873 EXPECT_EQ(val.asUInt(), 0);
874 EXPECT_EQ(val.asAbsUInt(), 0);
875 EXPECT_EQ(val.asDouble(), 0.0);
876 EXPECT_FALSE(val.asBool());
877
878 EXPECT_TRUE(val.isConvertibleTo(Json::nullValue));
879 EXPECT_TRUE(val.isConvertibleTo(Json::intValue));
880 EXPECT_TRUE(val.isConvertibleTo(Json::uintValue));
881 EXPECT_TRUE(val.isConvertibleTo(Json::realValue));
882 EXPECT_TRUE(val.isConvertibleTo(Json::stringValue));
883 EXPECT_TRUE(val.isConvertibleTo(Json::booleanValue));
884 EXPECT_TRUE(val.isConvertibleTo(Json::arrayValue));
885 EXPECT_TRUE(val.isConvertibleTo(Json::objectValue));
886 }
887 {
888 // int
889 Json::Value val = -1234;
890 EXPECT_TRUE(val.isInt());
891 // val.asCString() should trigger an assertion failure
892 EXPECT_EQ(val.asString(), "-1234");
893 EXPECT_EQ(val.asInt(), -1234);
894 EXPECT_THROW(val.asUInt(), Json::error);
895 EXPECT_EQ(val.asAbsUInt(), 1234u);
896 EXPECT_EQ(val.asDouble(), -1234.0);
897 EXPECT_TRUE(val.asBool());
898
899 EXPECT_FALSE(val.isConvertibleTo(Json::nullValue));
900 EXPECT_TRUE(val.isConvertibleTo(Json::intValue));
901 EXPECT_FALSE(val.isConvertibleTo(Json::uintValue));
902 EXPECT_TRUE(val.isConvertibleTo(Json::realValue));
903 EXPECT_TRUE(val.isConvertibleTo(Json::stringValue));
904 EXPECT_TRUE(val.isConvertibleTo(Json::booleanValue));
905 EXPECT_FALSE(val.isConvertibleTo(Json::arrayValue));
906 EXPECT_FALSE(val.isConvertibleTo(Json::objectValue));
907 }
908 {
909 // uint
910 Json::Value val = 1234U;
911 EXPECT_TRUE(val.isUInt());
912 // val.asCString() should trigger an assertion failure
913 EXPECT_EQ(val.asString(), "1234");
914 EXPECT_EQ(val.asInt(), 1234);
915 EXPECT_EQ(val.asUInt(), 1234u);
916 EXPECT_EQ(val.asAbsUInt(), 1234u);
917 EXPECT_EQ(val.asDouble(), 1234.0);
918 EXPECT_TRUE(val.asBool());
919
920 EXPECT_FALSE(val.isConvertibleTo(Json::nullValue));
921 EXPECT_TRUE(val.isConvertibleTo(Json::intValue));
922 EXPECT_TRUE(val.isConvertibleTo(Json::uintValue));
923 EXPECT_TRUE(val.isConvertibleTo(Json::realValue));
924 EXPECT_TRUE(val.isConvertibleTo(Json::stringValue));
925 EXPECT_TRUE(val.isConvertibleTo(Json::booleanValue));
926 EXPECT_FALSE(val.isConvertibleTo(Json::arrayValue));
927 EXPECT_FALSE(val.isConvertibleTo(Json::objectValue));
928 }
929 {
930 // real
931 Json::Value val = 2.0;
932 EXPECT_TRUE(val.isDouble());
933 // val.asCString() should trigger an assertion failure
934 EXPECT_TRUE(std::regex_match(val.asString(), std::regex("^2\\.0*$")));
935 EXPECT_EQ(val.asInt(), 2);
936 EXPECT_EQ(val.asUInt(), 2u);
937 EXPECT_EQ(val.asAbsUInt(), 2u);
938 EXPECT_EQ(val.asDouble(), 2.0);
939 EXPECT_TRUE(val.asBool());
940
941 EXPECT_FALSE(val.isConvertibleTo(Json::nullValue));
942 EXPECT_TRUE(val.isConvertibleTo(Json::intValue));
943 EXPECT_TRUE(val.isConvertibleTo(Json::uintValue));
944 EXPECT_TRUE(val.isConvertibleTo(Json::realValue));
945 EXPECT_TRUE(val.isConvertibleTo(Json::stringValue));
946 EXPECT_TRUE(val.isConvertibleTo(Json::booleanValue));
947 EXPECT_FALSE(val.isConvertibleTo(Json::arrayValue));
948 EXPECT_FALSE(val.isConvertibleTo(Json::objectValue));
949 }
950 {
951 // numeric string
952 Json::Value val = "54321";
953 EXPECT_TRUE(val.isString());
954 EXPECT_EQ(strcmp(val.asCString(), "54321"), 0);
955 EXPECT_EQ(val.asString(), "54321");
956 EXPECT_EQ(val.asInt(), 54321);
957 EXPECT_EQ(val.asUInt(), 54321u);
958 EXPECT_EQ(val.asAbsUInt(), 54321);
959 EXPECT_THROW(val.asDouble(), Json::error);
960 EXPECT_TRUE(val.asBool());
961
962 EXPECT_FALSE(val.isConvertibleTo(Json::nullValue));
963 EXPECT_FALSE(val.isConvertibleTo(Json::intValue));
964 EXPECT_FALSE(val.isConvertibleTo(Json::uintValue));
965 EXPECT_FALSE(val.isConvertibleTo(Json::realValue));
966 EXPECT_TRUE(val.isConvertibleTo(Json::stringValue));
967 EXPECT_FALSE(val.isConvertibleTo(Json::booleanValue));
968 EXPECT_FALSE(val.isConvertibleTo(Json::arrayValue));
969 EXPECT_FALSE(val.isConvertibleTo(Json::objectValue));
970 }
971 {
972 // non-numeric string
973 Json::Value val(Json::stringValue);
974 EXPECT_TRUE(val.isString());
975 EXPECT_EQ(val.asCString(), nullptr);
976 EXPECT_EQ(val.asString(), "");
977 EXPECT_THROW(val.asInt(), std::exception);
978 EXPECT_THROW(val.asUInt(), std::exception);
979 EXPECT_THROW(val.asAbsUInt(), std::exception);
980 EXPECT_THROW(val.asDouble(), std::exception);
981 EXPECT_TRUE(val.asBool() == false);
982
983 EXPECT_TRUE(val.isConvertibleTo(Json::nullValue));
984 EXPECT_FALSE(val.isConvertibleTo(Json::intValue));
985 EXPECT_FALSE(val.isConvertibleTo(Json::uintValue));
986 EXPECT_FALSE(val.isConvertibleTo(Json::realValue));
987 EXPECT_TRUE(val.isConvertibleTo(Json::stringValue));
988 EXPECT_FALSE(val.isConvertibleTo(Json::booleanValue));
989 EXPECT_FALSE(val.isConvertibleTo(Json::arrayValue));
990 EXPECT_FALSE(val.isConvertibleTo(Json::objectValue));
991 }
992 {
993 // bool false
994 Json::Value val = false;
995 EXPECT_TRUE(val.isBool());
996 // val.asCString() should trigger an assertion failure
997 EXPECT_EQ(val.asString(), "false");
998 EXPECT_EQ(val.asInt(), 0);
999 EXPECT_EQ(val.asUInt(), 0);
1000 EXPECT_EQ(val.asAbsUInt(), 0);
1001 EXPECT_EQ(val.asDouble(), 0.0);
1002 EXPECT_FALSE(val.asBool());
1003
1004 EXPECT_TRUE(val.isConvertibleTo(Json::nullValue));
1005 EXPECT_TRUE(val.isConvertibleTo(Json::intValue));
1006 EXPECT_TRUE(val.isConvertibleTo(Json::uintValue));
1007 EXPECT_TRUE(val.isConvertibleTo(Json::realValue));
1008 EXPECT_TRUE(val.isConvertibleTo(Json::stringValue));
1009 EXPECT_TRUE(val.isConvertibleTo(Json::booleanValue));
1010 EXPECT_FALSE(val.isConvertibleTo(Json::arrayValue));
1011 EXPECT_FALSE(val.isConvertibleTo(Json::objectValue));
1012 }
1013 {
1014 // bool true
1015 Json::Value val = true;
1016 EXPECT_TRUE(val.isBool());
1017 // val.asCString() should trigger an assertion failure
1018 EXPECT_EQ(val.asString(), "true");
1019 EXPECT_EQ(val.asInt(), 1);
1020 EXPECT_EQ(val.asUInt(), 1);
1021 EXPECT_EQ(val.asAbsUInt(), 1);
1022 EXPECT_EQ(val.asDouble(), 1.0);
1023 EXPECT_TRUE(val.asBool());
1024
1025 EXPECT_FALSE(val.isConvertibleTo(Json::nullValue));
1026 EXPECT_TRUE(val.isConvertibleTo(Json::intValue));
1027 EXPECT_TRUE(val.isConvertibleTo(Json::uintValue));
1028 EXPECT_TRUE(val.isConvertibleTo(Json::realValue));
1029 EXPECT_TRUE(val.isConvertibleTo(Json::stringValue));
1030 EXPECT_TRUE(val.isConvertibleTo(Json::booleanValue));
1031 EXPECT_FALSE(val.isConvertibleTo(Json::arrayValue));
1032 EXPECT_FALSE(val.isConvertibleTo(Json::objectValue));
1033 }
1034 {
1035 // array type
1036 Json::Value val(Json::arrayValue);
1037 EXPECT_TRUE(val.isArray());
1038 // val.asCString should trigger an assertion failure
1039 EXPECT_THROW(val.asString(), Json::error);
1040 EXPECT_THROW(val.asInt(), Json::error);
1041 EXPECT_THROW(val.asUInt(), Json::error);
1042 EXPECT_THROW(val.asAbsUInt(), Json::error);
1043 EXPECT_THROW(val.asDouble(), Json::error);
1044 EXPECT_FALSE(val.asBool()); // empty or not
1045
1046 EXPECT_TRUE(val.isConvertibleTo(Json::nullValue));
1047 EXPECT_FALSE(val.isConvertibleTo(Json::intValue));
1048 EXPECT_FALSE(val.isConvertibleTo(Json::uintValue));
1049 EXPECT_FALSE(val.isConvertibleTo(Json::realValue));
1050 EXPECT_FALSE(val.isConvertibleTo(Json::stringValue));
1051 EXPECT_FALSE(val.isConvertibleTo(Json::booleanValue));
1052 EXPECT_TRUE(val.isConvertibleTo(Json::arrayValue));
1053 EXPECT_FALSE(val.isConvertibleTo(Json::objectValue));
1054 }
1055 {
1056 // object type
1057 Json::Value val(Json::objectValue);
1058 EXPECT_TRUE(val.isObject());
1059 // val.asCString should trigger an assertion failure
1060 EXPECT_THROW(val.asString(), Json::error);
1061 EXPECT_THROW(val.asInt(), Json::error);
1062 EXPECT_THROW(val.asUInt(), Json::error);
1063 EXPECT_THROW(val.asAbsUInt(), Json::error);
1064 EXPECT_THROW(val.asDouble(), Json::error);
1065 EXPECT_FALSE(val.asBool()); // empty or not
1066
1067 EXPECT_TRUE(val.isConvertibleTo(Json::nullValue));
1068 EXPECT_FALSE(val.isConvertibleTo(Json::intValue));
1069 EXPECT_FALSE(val.isConvertibleTo(Json::uintValue));
1070 EXPECT_FALSE(val.isConvertibleTo(Json::realValue));
1071 EXPECT_FALSE(val.isConvertibleTo(Json::stringValue));
1072 EXPECT_FALSE(val.isConvertibleTo(Json::booleanValue));
1073 EXPECT_FALSE(val.isConvertibleTo(Json::arrayValue));
1074 EXPECT_TRUE(val.isConvertibleTo(Json::objectValue));
1075 }
1076}
1077
1078TEST(json_value, access_members)
1079{
1080 Json::Value val;
1081 EXPECT_EQ(val.type(), Json::nullValue);
1082 EXPECT_EQ(val.size(), 0);
1083 EXPECT_FALSE(val.isValidIndex(0));
1084 EXPECT_FALSE(val.isMember("key"));
1085 {
1086 Json::Value const constVal = val;
1087 EXPECT_EQ(constVal[7u].type(), Json::nullValue);
1088 EXPECT_FALSE(constVal.isMember("key"));
1089 EXPECT_EQ(constVal["key"].type(), Json::nullValue);
1090 EXPECT_TRUE(constVal.getMemberNames().empty());
1091 EXPECT_EQ(constVal.get(1u, "default0"), "default0");
1092 EXPECT_EQ(constVal.get(std::string("not"), "oh"), "oh");
1093 EXPECT_EQ(constVal.get("missing", "default2"), "default2");
1094 }
1095
1096 val = -7;
1097 EXPECT_EQ(val.type(), Json::intValue);
1098 EXPECT_EQ(val.size(), 0);
1099 EXPECT_FALSE(val.isValidIndex(0));
1100 EXPECT_FALSE(val.isMember("key"));
1101
1102 val = 42u;
1103 EXPECT_EQ(val.type(), Json::uintValue);
1104 EXPECT_EQ(val.size(), 0);
1105 EXPECT_FALSE(val.isValidIndex(0));
1106 EXPECT_FALSE(val.isMember("key"));
1107
1108 val = 3.14159;
1109 EXPECT_EQ(val.type(), Json::realValue);
1110 EXPECT_EQ(val.size(), 0);
1111 EXPECT_FALSE(val.isValidIndex(0));
1112 EXPECT_FALSE(val.isMember("key"));
1113
1114 val = true;
1115 EXPECT_EQ(val.type(), Json::booleanValue);
1116 EXPECT_EQ(val.size(), 0);
1117 EXPECT_FALSE(val.isValidIndex(0));
1118 EXPECT_FALSE(val.isMember("key"));
1119
1120 val = "string";
1121 EXPECT_EQ(val.type(), Json::stringValue);
1122 EXPECT_EQ(val.size(), 0);
1123 EXPECT_FALSE(val.isValidIndex(0));
1124 EXPECT_FALSE(val.isMember("key"));
1125
1126 val = Json::Value(Json::objectValue);
1127 EXPECT_EQ(val.type(), Json::objectValue);
1128 EXPECT_EQ(val.size(), 0);
1129 static Json::StaticString const staticThree("three");
1130 val[staticThree] = 3;
1131 val["two"] = 2;
1132 EXPECT_EQ(val.size(), 2);
1133 EXPECT_TRUE(val.isValidIndex(1));
1134 EXPECT_FALSE(val.isValidIndex(2));
1135 EXPECT_EQ(val[staticThree], 3);
1136 EXPECT_TRUE(val.isMember("two"));
1137 EXPECT_TRUE(val.isMember(staticThree));
1138 EXPECT_FALSE(val.isMember("key"));
1139 {
1140 Json::Value const constVal = val;
1141 EXPECT_EQ(constVal["two"], 2);
1142 EXPECT_EQ(constVal["four"].type(), Json::nullValue);
1143 EXPECT_EQ(constVal[staticThree], 3);
1144 EXPECT_TRUE(constVal.isMember("two"));
1145 EXPECT_TRUE(constVal.isMember(staticThree));
1146 EXPECT_FALSE(constVal.isMember("key"));
1147 EXPECT_EQ(val.get(std::string("two"), "backup"), 2);
1148 EXPECT_EQ(val.get("missing", "default2"), "default2");
1149 }
1150
1151 val = Json::Value(Json::arrayValue);
1152 EXPECT_EQ(val.type(), Json::arrayValue);
1153 EXPECT_EQ(val.size(), 0);
1154 val[0u] = "zero";
1155 val[1u] = "one";
1156 EXPECT_EQ(val.size(), 2);
1157 EXPECT_TRUE(val.isValidIndex(1));
1158 EXPECT_FALSE(val.isValidIndex(2));
1159 EXPECT_EQ(val[20u].type(), Json::nullValue);
1160 EXPECT_FALSE(val.isMember("key"));
1161 {
1162 Json::Value const constVal = val;
1163 EXPECT_EQ(constVal[0u], "zero");
1164 EXPECT_EQ(constVal[2u].type(), Json::nullValue);
1165 EXPECT_FALSE(constVal.isMember("key"));
1166 EXPECT_EQ(val.get(1u, "default0"), "one");
1167 EXPECT_EQ(val.get(3u, "default1"), "default1");
1168 }
1169}
1170
1171TEST(json_value, remove_members)
1172{
1173 Json::Value val;
1174 EXPECT_EQ(val.removeMember(std::string("member")).type(), Json::nullValue);
1175
1176 val = Json::Value(Json::objectValue);
1177 static Json::StaticString const staticThree("three");
1178 val[staticThree] = 3;
1179 val["two"] = 2;
1180 EXPECT_EQ(val.size(), 2);
1181
1182 EXPECT_EQ(val.removeMember(std::string("six")).type(), Json::nullValue);
1183 EXPECT_EQ(val.size(), 2);
1184
1185 EXPECT_EQ(val.removeMember(staticThree), 3);
1186 EXPECT_EQ(val.size(), 1);
1187
1188 EXPECT_EQ(val.removeMember(staticThree).type(), Json::nullValue);
1189 EXPECT_EQ(val.size(), 1);
1190
1191 EXPECT_EQ(val.removeMember(std::string("two")), 2);
1192 EXPECT_EQ(val.size(), 0);
1193
1194 EXPECT_EQ(val.removeMember(std::string("two")).type(), Json::nullValue);
1195 EXPECT_EQ(val.size(), 0);
1196}
1197
1198TEST(json_value, iterator)
1199{
1200 {
1201 // Iterating an array.
1202 Json::Value arr{Json::arrayValue};
1203 arr[0u] = "zero";
1204 arr[1u] = "one";
1205 arr[2u] = "two";
1206 arr[3u] = "three";
1207
1208 Json::ValueIterator const b{arr.begin()};
1209 Json::ValueIterator const e{arr.end()};
1210
1211 Json::ValueIterator i1 = b;
1212 Json::ValueIterator i2 = e;
1213 --i2;
1214
1215 // key(), index(), and memberName() on an array iterator.
1216 EXPECT_TRUE(b != e);
1217 EXPECT_FALSE(b == e);
1218 EXPECT_EQ(i1.key(), 0);
1219 EXPECT_EQ(i2.key(), 3);
1220 EXPECT_EQ(i1.index(), 0);
1221 EXPECT_EQ(i2.index(), 3);
1222 EXPECT_STREQ(i1.memberName(), "");
1223 EXPECT_STREQ(i2.memberName(), "");
1224
1225 // Pre and post increment and decrement.
1226 *i1++ = "0";
1227 EXPECT_EQ(*i1, "one");
1228 *i1 = "1";
1229 ++i1;
1230
1231 *i2-- = "3";
1232 EXPECT_EQ(*i2, "two");
1233 EXPECT_EQ(i1, i2);
1234 *i2 = "2";
1235 EXPECT_EQ(*i1, "2");
1236 }
1237 {
1238 // Iterating a const object.
1239 Json::Value const obj{[]() {
1240 Json::Value obj{Json::objectValue};
1241 obj["0"] = 0;
1242 obj["1"] = 1;
1243 obj["2"] = 2;
1244 obj["3"] = 3;
1245 return obj;
1246 }()};
1247
1248 Json::ValueConstIterator i1{obj.begin()};
1249 Json::ValueConstIterator i2{obj.end()};
1250 --i2;
1251
1252 // key(), index(), and memberName() on an object iterator.
1253 EXPECT_TRUE(i1 != i2);
1254 EXPECT_FALSE(i1 == i2);
1255 EXPECT_EQ(i1.key(), "0");
1256 EXPECT_EQ(i2.key(), "3");
1257 EXPECT_EQ(i1.index(), -1);
1258 EXPECT_EQ(i2.index(), -1);
1259 EXPECT_STREQ(i1.memberName(), "0");
1260 EXPECT_STREQ(i2.memberName(), "3");
1261
1262 // Pre and post increment and decrement.
1263 EXPECT_EQ(*i1++, 0);
1264 EXPECT_EQ(*i1, 1);
1265 ++i1;
1266
1267 EXPECT_EQ(*i2--, 3);
1268 EXPECT_EQ(*i2, 2);
1269 EXPECT_EQ(i1, i2);
1270 EXPECT_EQ(*i1, 2);
1271 }
1272 {
1273 // Iterating a non-const null object.
1274 Json::Value nul{};
1275 EXPECT_EQ(nul.begin(), nul.end());
1276 }
1277 {
1278 // Iterating a const Int.
1279 Json::Value const i{-3};
1280 EXPECT_EQ(i.begin(), i.end());
1281 }
1282}
1283
1284TEST(json_value, nest_limits)
1285{
1286 Json::Reader r;
1287 {
1288 auto nest = [](std::uint32_t depth) -> std::string {
1289 std::string s = "{";
1290 for (std::uint32_t i{1}; i <= depth; ++i)
1291 s += "\"obj\":{";
1292 for (std::uint32_t i{1}; i <= depth; ++i)
1293 s += "}";
1294 s += "}";
1295 return s;
1296 };
1297
1298 {
1299 // Within object nest limit
1300 auto json{nest(std::min(10u, Json::Reader::nest_limit))};
1301 Json::Value j;
1302 EXPECT_TRUE(r.parse(json, j));
1303 }
1304
1305 {
1306 // Exceed object nest limit
1307 auto json{nest(Json::Reader::nest_limit + 1)};
1308 Json::Value j;
1309 EXPECT_FALSE(r.parse(json, j));
1310 }
1311 }
1312
1313 auto nest = [](std::uint32_t depth) -> std::string {
1314 std::string s = "{";
1315 for (std::uint32_t i{1}; i <= depth; ++i)
1316 s += "\"array\":[{";
1317 for (std::uint32_t i{1}; i <= depth; ++i)
1318 s += "]}";
1319 s += "}";
1320 return s;
1321 };
1322 {
1323 // Exceed array nest limit
1324 auto json{nest(Json::Reader::nest_limit + 1)};
1325 Json::Value j;
1326 EXPECT_FALSE(r.parse(json, j));
1327 }
1328}
1329
1330TEST(json_value, memory_leak)
1331{
1332 // When run with the address sanitizer, this test confirms there is no
1333 // memory leak with the scenarios below.
1334 {
1335 Json::Value a;
1336 a[0u] = 1;
1337 EXPECT_EQ(a.type(), Json::arrayValue);
1338 EXPECT_EQ(a[0u].type(), Json::intValue);
1339 a = std::move(a[0u]);
1340 EXPECT_EQ(a.type(), Json::intValue);
1341 }
1342 {
1343 Json::Value b;
1344 Json::Value temp;
1345 temp["a"] = "Probably avoids the small string optimization";
1346 temp["b"] = "Also probably avoids the small string optimization";
1347 EXPECT_EQ(temp.type(), Json::objectValue);
1348 b.append(temp);
1349 EXPECT_EQ(temp.type(), Json::objectValue);
1350 EXPECT_EQ(b.size(), 1);
1351
1352 b.append(std::move(temp));
1353 EXPECT_EQ(b.size(), 2);
1354
1355 // Note that the type() == nullValue check is implementation
1356 // specific and not guaranteed to be valid in the future.
1357 EXPECT_EQ(temp.type(), Json::nullValue);
1358 }
1359}
1360
1361} // namespace xrpl
Json::Compact
Decorator for streaming out compact json.
Definition json_writer.h:299
Json::Reader
Unserialize a JSON document into a Value.
Definition json_reader.h:18
Json::Reader::nest_limit
static constexpr unsigned nest_limit
Definition json_reader.h:71
Json::Reader::parse
bool parse(std::string const &document, Value &root)
Read a Value from a JSON document.
Definition json_reader.cpp:59
Json::StaticString
Lightweight wrapper to tag static string.
Definition json_value.h:45
Json::StaticString::c_str
constexpr char const * c_str() const
Definition json_value.h:58
Json::ValueConstIterator
const iterator for object and array value.
Definition json_value.h:562
Json::ValueIteratorBase::key
Value key() const
Return either the index or the member name of the referenced value as a Value.
Definition json_valueiterator.cpp:90
Json::ValueIteratorBase::memberName
char const * memberName() const
Return the member name of the referenced Value.
Definition json_valueiterator.cpp:117
Json::ValueIteratorBase::index
UInt index() const
Return the index of the referenced Value. -1 if it is not an arrayValue.
Definition json_valueiterator.cpp:106
Json::ValueIterator
Iterator for object and array value.
Definition json_value.h:623
Json::Value
Represents a JSON value.
Definition json_value.h:131
Json::Value::isArray
bool isArray() const
Definition json_value.cpp:1121
Json::Value::append
Value & append(Value const &value)
Append value to array at the end.
Definition json_value.cpp:978
Json::Value::size
UInt size() const
Number of values in array or object.
Definition json_value.cpp:785
Json::Value::isDouble
bool isDouble() const
Definition json_value.cpp:1103
Json::Value::asCString
char const * asCString() const
Definition json_value.cpp:464
Json::Value::asInt
Int asInt() const
Definition json_value.cpp:507
Json::Value::asAbsUInt
UInt asAbsUInt() const
Correct absolute value from int or unsigned int.
Definition json_value.cpp:551
Json::Value::isString
bool isString() const
Definition json_value.cpp:1115
Json::Value::asUInt
UInt asUInt() const
Definition json_value.cpp:614
Json::Value::getMemberNames
Members getMemberNames() const
Return a list of the member names.
Definition json_value.cpp:1052
Json::Value::type
ValueType type() const
Definition json_value.cpp:348
Json::Value::isObject
bool isObject() const
Definition json_value.cpp:1133
Json::Value::removeMember
Value removeMember(char const *key)
Remove and return the named member.
Definition json_value.cpp:1003
Json::Value::isValidIndex
bool isValidIndex(UInt index) const
Return true if index < size().
Definition json_value.cpp:929
Json::Value::asString
std::string asString() const
Returns the unquoted string value.
Definition json_value.cpp:471
Json::Value::isBool
bool isBool() const
Definition json_value.cpp:1079
Json::Value::asBool
bool asBool() const
Definition json_value.cpp:692
Json::Value::isUInt
bool isUInt() const
Definition json_value.cpp:1091
Json::Value::isNull
bool isNull() const
isNull() tests to see if this field is null.
Definition json_value.cpp:1073
Json::Value::isMember
bool isMember(char const *key) const
Return true if the object has a member named key.
Definition json_value.cpp:1030
Json::Value::get
Value get(UInt index, Value const &defaultValue) const
If the array contains at least index+1 elements, returns the element value, otherwise returns default...
Definition json_value.cpp:922
Json::Value::isConvertibleTo
bool isConvertibleTo(ValueType other) const
Definition json_value.cpp:726
Json::Value::asDouble
double asDouble() const
Definition json_value.cpp:658
Json::Value::isInt
bool isInt() const
Definition json_value.cpp:1085
std::count_if
T count_if(T... args)
std::vector::empty
T empty(T... args)
std::numeric_limits::max
T max(T... args)
std::numeric_limits::min
T min(T... args)
Json
JSON (JavaScript Object Notation).
Definition json_errors.h:6
Json::ValueType
ValueType
Type of the value held by a Value object.
Definition json_value.h:19
Json::booleanValue
@ booleanValue
bool value
Definition json_value.h:25
Json::nullValue
@ nullValue
'null' value
Definition json_value.h:20
Json::stringValue
@ stringValue
UTF-8 string value.
Definition json_value.h:24
Json::realValue
@ realValue
double value
Definition json_value.h:23
Json::arrayValue
@ arrayValue
array value (ordered list)
Definition json_value.h:26
Json::intValue
@ intValue
signed integer value
Definition json_value.h:21
Json::objectValue
@ objectValue
object value (collection of name/value pairs).
Definition json_value.h:27
Json::uintValue
@ uintValue
unsigned integer value
Definition json_value.h:22
Json::Int
int Int
Definition json_forwards.h:7
Json::UInt
unsigned int UInt
Definition json_forwards.h:8
xrpl
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:6
xrpl::TEST
TEST(json_value, limits)
Definition Value.cpp:17
std::regex_match
T regex_match(T... args)
std::stringstream::str
T str(T... args)
beast::BadLexicalCast
Thrown when a conversion is not possible with LexicalCast.
Definition LexicalCast.h:172
std::to_string
T to_string(T... args)
Generated by doxygen 1.9.8