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