rippled
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 <ripple/beast/core/LexicalCast.h>
21 #include <ripple/beast/type_name.h>
22 #include <ripple/beast/unit_test.h>
23 #include <ripple/json/json_reader.h>
24 #include <ripple/json/json_value.h>
25 #include <ripple/json/json_writer.h>
26 
27 #include <algorithm>
28 #include <regex>
29 
30 namespace ripple {
31 
32 struct 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 
1397 BEAST_DEFINE_TESTSUITE(json_value, json, ripple);
1398 
1399 } // namespace ripple
Json::Value::isInt
bool isInt() const
Definition: json_value.cpp:979
ripple::json_value_test
Definition: json_value_test.cpp:32
Json::ValueIterator
Iterator for object and array value.
Definition: json_value.h:620
std::strcmp
T strcmp(T... args)
regex
Json::Value::isObject
bool isObject() const
Definition: json_value.cpp:1027
std::string
STL class.
Json::Value::isString
bool isString() const
Definition: json_value.cpp:1009
ripple::BEAST_DEFINE_TESTSUITE
BEAST_DEFINE_TESTSUITE(AccountTxPaging, app, ripple)
Json::Value::isValidIndex
bool isValidIndex(UInt index) const
Return true if index < size().
Definition: json_value.cpp:841
std::exception
STL class.
Json::arrayValue
@ arrayValue
array value (ordered list)
Definition: json_value.h:42
Json::booleanValue
@ booleanValue
bool value
Definition: json_value.h:41
Json::UInt
unsigned int UInt
Definition: json_forwards.h:27
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:834
Json::Compact
Decorator for streaming out compact json.
Definition: json_writer.h:316
ripple::json_value_test::test_bool
void test_bool()
Definition: json_value_test.cpp:571
Json::Value::isDouble
bool isDouble() const
Definition: json_value.cpp:997
std::stringstream
STL class.
Json::realValue
@ realValue
double value
Definition: json_value.h:39
std::regex_match
T regex_match(T... args)
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::Value::isNull
bool isNull() const
isNull() tests to see if this field is null.
Definition: json_value.cpp:967
beast::BadLexicalCast
Thrown when a conversion is not possible with LexicalCast.
Definition: LexicalCast.h:256
Json::Reader
Unserialize a JSON document into a Value.
Definition: json_reader.h:36
ripple::json_value_test::test_nest_limits
void test_nest_limits()
Definition: json_value_test.cpp:1297
algorithm
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::Value::asBool
bool asBool() const
Definition: json_value.cpp:619
ripple::json_value_test::test_StaticString
void test_StaticString()
Definition: json_value_test.cpp:35
Json::uintValue
@ uintValue
unsigned integer value
Definition: json_value.h:38
Json::Value::append
Value & append(const Value &value)
Append value to array at the end.
Definition: json_value.cpp:882
Json::objectValue
@ objectValue
object value (collection of name/value pairs).
Definition: json_value.h:43
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
Json::Value::isConvertibleTo
bool isConvertibleTo(ValueType other) const
Definition: json_value.cpp:651
Json::ValueConstIterator
const iterator for object and array value.
Definition: json_value.h:559
std::to_string
T to_string(T... args)
ripple::json_value_test::test_iterator
void test_iterator()
Definition: json_value_test.cpp:1210
ripple::json_value_test::test_leak
void test_leak()
Definition: json_value_test.cpp:1344
Json::Value::size
UInt size() const
Number of values in array or object.
Definition: json_value.cpp:706
Json::Value::isMember
bool isMember(const char *key) const
Return true if the object has a member named key.
Definition: json_value.cpp:932
Json::stringValue
@ stringValue
UTF-8 string value.
Definition: json_value.h:40
std::uint32_t
Json::ValueType
ValueType
Type of the value held by a Value object.
Definition: json_value.h:35
Json::Value::asCString
const char * asCString() const
Definition: json_value.cpp:462
ripple::json_value_test::test_removeMember
void test_removeMember()
Definition: json_value_test.cpp:1179
std::regex
Json::Int
int Int
Definition: json_forwards.h:26
ripple::json_value_test::test_bad_json
void test_bad_json()
Definition: json_value_test.cpp:595
ripple::json_value_test::test_compact
void test_compact()
Definition: json_value_test.cpp:822
ripple::json_value_test::test_types
void test_types()
Definition: json_value_test.cpp:60
Json::Value::isArray
bool isArray() const
Definition: json_value.cpp:1015
std::numeric_limits::min
T min(T... args)
ripple::json_value_test::test_comparisons
void test_comparisons()
Definition: json_value_test.cpp:766
Json::Value::getMemberNames
Members getMemberNames() const
Return a list of the member names.
Definition: json_value.cpp:948
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition: RCLCensorshipDetector.h:29
Json::Value::removeMember
Value removeMember(const char *key)
Remove and return the named member.
Definition: json_value.cpp:907
Json::StaticString
Lightweight wrapper to tag static string.
Definition: json_value.h:60
Json::Reader::nest_limit
static constexpr unsigned nest_limit
Definition: json_reader.h:90
Json::intValue
@ intValue
signed integer value
Definition: json_value.h:37
ripple::json_value_test::test_move
void test_move()
Definition: json_value_test.cpp:744
Json::Value::asUInt
UInt asUInt() const
Definition: json_value.cpp:545
Json::Value::isUInt
bool isUInt() const
Definition: json_value.cpp:985
ripple::json_value_test::test_access
void test_access()
Definition: json_value_test.cpp:1085
Json::Reader::parse
bool parse(std::string const &document, Value &root)
Read a Value from a JSON document.
Definition: json_reader.cpp:74
Json::nullValue
@ nullValue
'null' value
Definition: json_value.h:36
std::count_if
T count_if(T... args)
ripple::json_value_test::test_conversions
void test_conversions()
Definition: json_value_test.cpp:848
std::vector::empty
T empty(T... args)
Json::Value::isBool
bool isBool() const
Definition: json_value.cpp:973
std::stringstream::str
T str(T... args)
Json::Value::asInt
Int asInt() const
Definition: json_value.cpp:503
std::numeric_limits::max
T max(T... args)
ripple::json_value_test::test_copy
void test_copy()
Definition: json_value_test.cpp:720
Json::Value::asDouble
double asDouble() const
Definition: json_value.cpp:587
Json::Value::type
ValueType type() const
Definition: json_value.cpp:350
ripple::json_value_test::run
void run() override
Definition: json_value_test.cpp:1376
Json::Value
Represents a JSON value.
Definition: json_value.h:145
Json::ValueIteratorBase::memberName
const char * memberName() const
Return the member name of the referenced Value.
Definition: json_valueiterator.cpp:135
Json::Value::asString
std::string asString() const
Returns the unquoted string value.
Definition: json_value.cpp:469
Generated by   doxygen 1.8.17