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