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