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