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