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