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