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/json/json_reader.h>
21 #include <ripple/json/json_value.h>
22 #include <ripple/json/json_writer.h>
23 #include <ripple/beast/core/LexicalCast.h>
24 #include <ripple/beast/type_name.h>
25 #include <ripple/beast/unit_test.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 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 test_types()
59  {
60  // Exercise ValueType constructor
61  static constexpr Json::StaticString staticStr {"staticStr"};
62 
63  auto testCopy = [this] (Json::ValueType typ)
64  {
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 test_compare()
214  {
215  auto doCompare = [this] (
216  Json::Value const& lhs,
217  Json::Value const& rhs,
218  bool lhsEqRhs,
219  bool lhsLtRhs,
220  int line)
221  {
222  auto fmt = [this] (bool cond, char const* text, int line)
223  {
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  []()
253  {
254  Json::Value array1;
255  array1[0u] = 1;
256  return array1;
257  }()
258  };
259  Json::Value const obj0 {Json::objectValue};
260  Json::Value const obj1 {
261  []()
262  {
263  Json::Value obj1;
264  obj1["one"] = 1;
265  return obj1;
266  }()
267  };
268  // lhs == rhs lhs < rhs
269  doCompare (null0, Json::Value{}, true, false, __LINE__);
270  doCompare (null0, intNeg1, false, true, __LINE__);
271  doCompare (null0, int0, false, true, __LINE__);
272  doCompare (null0, intPos1, false, true, __LINE__);
273  doCompare (null0, uint0, false, true, __LINE__);
274  doCompare (null0, uint1, false, true, __LINE__);
275  doCompare (null0, realNeg1, false, true, __LINE__);
276  doCompare (null0, real0, false, true, __LINE__);
277  doCompare (null0, realPos1, false, true, __LINE__);
278  doCompare (null0, str0, false, true, __LINE__);
279  doCompare (null0, str1, false, true, __LINE__);
280  doCompare (null0, boolF, false, true, __LINE__);
281  doCompare (null0, boolT, false, true, __LINE__);
282  doCompare (null0, array0, false, true, __LINE__);
283  doCompare (null0, array1, false, true, __LINE__);
284  doCompare (null0, obj0, false, true, __LINE__);
285  doCompare (null0, obj1, false, true, __LINE__);
286  // lhs == rhs lhs < rhs
287  doCompare (intNeg1, null0, false, false, __LINE__);
288  doCompare (intNeg1, intNeg1, true, false, __LINE__);
289  doCompare (intNeg1, int0, false, true, __LINE__);
290  doCompare (intNeg1, intPos1, false, true, __LINE__);
291  doCompare (intNeg1, uint0, false, true, __LINE__);
292  doCompare (intNeg1, uint1, false, true, __LINE__);
293  doCompare (intNeg1, realNeg1, false, true, __LINE__);
294  doCompare (intNeg1, real0, false, true, __LINE__);
295  doCompare (intNeg1, realPos1, false, true, __LINE__);
296  doCompare (intNeg1, str0, false, true, __LINE__);
297  doCompare (intNeg1, str1, false, true, __LINE__);
298  doCompare (intNeg1, boolF, false, true, __LINE__);
299  doCompare (intNeg1, boolT, false, true, __LINE__);
300  doCompare (intNeg1, array0, false, true, __LINE__);
301  doCompare (intNeg1, array1, false, true, __LINE__);
302  doCompare (intNeg1, obj0, false, true, __LINE__);
303  doCompare (intNeg1, obj1, false, true, __LINE__);
304  // lhs == rhs lhs < rhs
305  doCompare (int0, null0, false, false, __LINE__);
306  doCompare (int0, intNeg1, false, false, __LINE__);
307  doCompare (int0, int0, true, false, __LINE__);
308  doCompare (int0, intPos1, false, true, __LINE__);
309  doCompare (int0, uint0, true, false, __LINE__);
310  doCompare (int0, uint1, false, true, __LINE__);
311  doCompare (int0, realNeg1, false, true, __LINE__);
312  doCompare (int0, real0, false, true, __LINE__);
313  doCompare (int0, realPos1, false, true, __LINE__);
314  doCompare (int0, str0, false, true, __LINE__);
315  doCompare (int0, str1, false, true, __LINE__);
316  doCompare (int0, boolF, false, true, __LINE__);
317  doCompare (int0, boolT, false, true, __LINE__);
318  doCompare (int0, array0, false, true, __LINE__);
319  doCompare (int0, array1, false, true, __LINE__);
320  doCompare (int0, obj0, false, true, __LINE__);
321  doCompare (int0, obj1, false, true, __LINE__);
322  // lhs == rhs lhs < rhs
323  doCompare (intPos1, null0, false, false, __LINE__);
324  doCompare (intPos1, intNeg1, false, false, __LINE__);
325  doCompare (intPos1, int0, false, false, __LINE__);
326  doCompare (intPos1, intPos1, true, false, __LINE__);
327  doCompare (intPos1, uint0, false, false, __LINE__);
328  doCompare (intPos1, uint1, true, false, __LINE__);
329  doCompare (intPos1, realNeg1, false, true, __LINE__);
330  doCompare (intPos1, real0, false, true, __LINE__);
331  doCompare (intPos1, realPos1, false, true, __LINE__);
332  doCompare (intPos1, str0, false, true, __LINE__);
333  doCompare (intPos1, str1, false, true, __LINE__);
334  doCompare (intPos1, boolF, false, true, __LINE__);
335  doCompare (intPos1, boolT, false, true, __LINE__);
336  doCompare (intPos1, array0, false, true, __LINE__);
337  doCompare (intPos1, array1, false, true, __LINE__);
338  doCompare (intPos1, obj0, false, true, __LINE__);
339  doCompare (intPos1, obj1, false, true, __LINE__);
340  // lhs == rhs lhs < rhs
341  doCompare (uint0, null0, false, false, __LINE__);
342  doCompare (uint0, intNeg1, false, false, __LINE__);
343  doCompare (uint0, int0, true, false, __LINE__);
344  doCompare (uint0, intPos1, false, true, __LINE__);
345  doCompare (uint0, uint0, true, false, __LINE__);
346  doCompare (uint0, uint1, false, true, __LINE__);
347  doCompare (uint0, realNeg1, false, true, __LINE__);
348  doCompare (uint0, real0, false, true, __LINE__);
349  doCompare (uint0, realPos1, false, true, __LINE__);
350  doCompare (uint0, str0, false, true, __LINE__);
351  doCompare (uint0, str1, false, true, __LINE__);
352  doCompare (uint0, boolF, false, true, __LINE__);
353  doCompare (uint0, boolT, false, true, __LINE__);
354  doCompare (uint0, array0, false, true, __LINE__);
355  doCompare (uint0, array1, false, true, __LINE__);
356  doCompare (uint0, obj0, false, true, __LINE__);
357  doCompare (uint0, obj1, false, true, __LINE__);
358  // lhs == rhs lhs < rhs
359  doCompare (uint1, null0, false, false, __LINE__);
360  doCompare (uint1, intNeg1, false, false, __LINE__);
361  doCompare (uint1, int0, false, false, __LINE__);
362  doCompare (uint1, intPos1, true, false, __LINE__);
363  doCompare (uint1, uint0, false, false, __LINE__);
364  doCompare (uint1, uint1, true, false, __LINE__);
365  doCompare (uint1, realNeg1, false, true, __LINE__);
366  doCompare (uint1, real0, false, true, __LINE__);
367  doCompare (uint1, realPos1, false, true, __LINE__);
368  doCompare (uint1, str0, false, true, __LINE__);
369  doCompare (uint1, str1, false, true, __LINE__);
370  doCompare (uint1, boolF, false, true, __LINE__);
371  doCompare (uint1, boolT, false, true, __LINE__);
372  doCompare (uint1, array0, false, true, __LINE__);
373  doCompare (uint1, array1, false, true, __LINE__);
374  doCompare (uint1, obj0, false, true, __LINE__);
375  doCompare (uint1, obj1, false, true, __LINE__);
376  // lhs == rhs lhs < rhs
377  doCompare (realNeg1, null0, false, false, __LINE__);
378  doCompare (realNeg1, intNeg1, false, false, __LINE__);
379  doCompare (realNeg1, int0, false, false, __LINE__);
380  doCompare (realNeg1, intPos1, false, false, __LINE__);
381  doCompare (realNeg1, uint0, false, false, __LINE__);
382  doCompare (realNeg1, uint1, false, false, __LINE__);
383  doCompare (realNeg1, realNeg1, true, false, __LINE__);
384  doCompare (realNeg1, real0, false, true, __LINE__);
385  doCompare (realNeg1, realPos1, false, true, __LINE__);
386  doCompare (realNeg1, str0, false, true, __LINE__);
387  doCompare (realNeg1, str1, false, true, __LINE__);
388  doCompare (realNeg1, boolF, false, true, __LINE__);
389  doCompare (realNeg1, boolT, false, true, __LINE__);
390  doCompare (realNeg1, array0, false, true, __LINE__);
391  doCompare (realNeg1, array1, false, true, __LINE__);
392  doCompare (realNeg1, obj0, false, true, __LINE__);
393  doCompare (realNeg1, obj1, false, true, __LINE__);
394  // lhs == rhs lhs < rhs
395  doCompare (real0, null0, false, false, __LINE__);
396  doCompare (real0, intNeg1, false, false, __LINE__);
397  doCompare (real0, int0, false, false, __LINE__);
398  doCompare (real0, intPos1, false, false, __LINE__);
399  doCompare (real0, uint0, false, false, __LINE__);
400  doCompare (real0, uint1, false, false, __LINE__);
401  doCompare (real0, realNeg1, false, false, __LINE__);
402  doCompare (real0, real0, true, false, __LINE__);
403  doCompare (real0, realPos1, false, true, __LINE__);
404  doCompare (real0, str0, false, true, __LINE__);
405  doCompare (real0, str1, false, true, __LINE__);
406  doCompare (real0, boolF, false, true, __LINE__);
407  doCompare (real0, boolT, false, true, __LINE__);
408  doCompare (real0, array0, false, true, __LINE__);
409  doCompare (real0, array1, false, true, __LINE__);
410  doCompare (real0, obj0, false, true, __LINE__);
411  doCompare (real0, obj1, false, true, __LINE__);
412  // lhs == rhs lhs < rhs
413  doCompare (realPos1, null0, false, false, __LINE__);
414  doCompare (realPos1, intNeg1, false, false, __LINE__);
415  doCompare (realPos1, int0, false, false, __LINE__);
416  doCompare (realPos1, intPos1, false, false, __LINE__);
417  doCompare (realPos1, uint0, false, false, __LINE__);
418  doCompare (realPos1, uint1, false, false, __LINE__);
419  doCompare (realPos1, realNeg1, false, false, __LINE__);
420  doCompare (realPos1, real0, false, false, __LINE__);
421  doCompare (realPos1, realPos1, true, false, __LINE__);
422  doCompare (realPos1, str0, false, true, __LINE__);
423  doCompare (realPos1, str1, false, true, __LINE__);
424  doCompare (realPos1, boolF, false, true, __LINE__);
425  doCompare (realPos1, boolT, false, true, __LINE__);
426  doCompare (realPos1, array0, false, true, __LINE__);
427  doCompare (realPos1, array1, false, true, __LINE__);
428  doCompare (realPos1, obj0, false, true, __LINE__);
429  doCompare (realPos1, obj1, false, true, __LINE__);
430  // lhs == rhs lhs < rhs
431  doCompare (str0, null0, false, false, __LINE__);
432  doCompare (str0, intNeg1, false, false, __LINE__);
433  doCompare (str0, int0, false, false, __LINE__);
434  doCompare (str0, intPos1, false, false, __LINE__);
435  doCompare (str0, uint0, false, false, __LINE__);
436  doCompare (str0, uint1, false, false, __LINE__);
437  doCompare (str0, realNeg1, false, false, __LINE__);
438  doCompare (str0, real0, false, false, __LINE__);
439  doCompare (str0, realPos1, false, false, __LINE__);
440  doCompare (str0, str0, true, false, __LINE__);
441  doCompare (str0, str1, false, true, __LINE__);
442  doCompare (str0, boolF, false, true, __LINE__);
443  doCompare (str0, boolT, false, true, __LINE__);
444  doCompare (str0, array0, false, true, __LINE__);
445  doCompare (str0, array1, false, true, __LINE__);
446  doCompare (str0, obj0, false, true, __LINE__);
447  doCompare (str0, obj1, false, true, __LINE__);
448  // lhs == rhs lhs < rhs
449  doCompare (str1, null0, false, false, __LINE__);
450  doCompare (str1, intNeg1, false, false, __LINE__);
451  doCompare (str1, int0, false, false, __LINE__);
452  doCompare (str1, intPos1, false, false, __LINE__);
453  doCompare (str1, uint0, false, false, __LINE__);
454  doCompare (str1, uint1, false, false, __LINE__);
455  doCompare (str1, realNeg1, false, false, __LINE__);
456  doCompare (str1, real0, false, false, __LINE__);
457  doCompare (str1, realPos1, false, false, __LINE__);
458  doCompare (str1, str0, false, false, __LINE__);
459  doCompare (str1, str1, true, false, __LINE__);
460  doCompare (str1, boolF, false, true, __LINE__);
461  doCompare (str1, boolT, false, true, __LINE__);
462  doCompare (str1, array0, false, true, __LINE__);
463  doCompare (str1, array1, false, true, __LINE__);
464  doCompare (str1, obj0, false, true, __LINE__);
465  doCompare (str1, obj1, false, true, __LINE__);
466  // lhs == rhs lhs < rhs
467  doCompare (boolF, null0, false, false, __LINE__);
468  doCompare (boolF, intNeg1, false, false, __LINE__);
469  doCompare (boolF, int0, false, false, __LINE__);
470  doCompare (boolF, intPos1, false, false, __LINE__);
471  doCompare (boolF, uint0, false, false, __LINE__);
472  doCompare (boolF, uint1, false, false, __LINE__);
473  doCompare (boolF, realNeg1, false, false, __LINE__);
474  doCompare (boolF, real0, false, false, __LINE__);
475  doCompare (boolF, realPos1, false, false, __LINE__);
476  doCompare (boolF, str0, false, false, __LINE__);
477  doCompare (boolF, str1, false, false, __LINE__);
478  doCompare (boolF, boolF, true, false, __LINE__);
479  doCompare (boolF, boolT, false, true, __LINE__);
480  doCompare (boolF, array0, false, true, __LINE__);
481  doCompare (boolF, array1, false, true, __LINE__);
482  doCompare (boolF, obj0, false, true, __LINE__);
483  doCompare (boolF, obj1, false, true, __LINE__);
484  // lhs == rhs lhs < rhs
485  doCompare (boolT, null0, false, false, __LINE__);
486  doCompare (boolT, intNeg1, false, false, __LINE__);
487  doCompare (boolT, int0, false, false, __LINE__);
488  doCompare (boolT, intPos1, false, false, __LINE__);
489  doCompare (boolT, uint0, false, false, __LINE__);
490  doCompare (boolT, uint1, false, false, __LINE__);
491  doCompare (boolT, realNeg1, false, false, __LINE__);
492  doCompare (boolT, real0, false, false, __LINE__);
493  doCompare (boolT, realPos1, false, false, __LINE__);
494  doCompare (boolT, str0, false, false, __LINE__);
495  doCompare (boolT, str1, false, false, __LINE__);
496  doCompare (boolT, boolF, false, false, __LINE__);
497  doCompare (boolT, boolT, true, false, __LINE__);
498  doCompare (boolT, array0, false, true, __LINE__);
499  doCompare (boolT, array1, false, true, __LINE__);
500  doCompare (boolT, obj0, false, true, __LINE__);
501  doCompare (boolT, obj1, false, true, __LINE__);
502  // lhs == rhs lhs < rhs
503  doCompare (array0, null0, false, false, __LINE__);
504  doCompare (array0, intNeg1, false, false, __LINE__);
505  doCompare (array0, int0, false, false, __LINE__);
506  doCompare (array0, intPos1, false, false, __LINE__);
507  doCompare (array0, uint0, false, false, __LINE__);
508  doCompare (array0, uint1, false, false, __LINE__);
509  doCompare (array0, realNeg1, false, false, __LINE__);
510  doCompare (array0, real0, false, false, __LINE__);
511  doCompare (array0, realPos1, false, false, __LINE__);
512  doCompare (array0, str0, false, false, __LINE__);
513  doCompare (array0, str1, false, false, __LINE__);
514  doCompare (array0, boolF, false, false, __LINE__);
515  doCompare (array0, boolT, false, false, __LINE__);
516  doCompare (array0, array0, true, false, __LINE__);
517  doCompare (array0, array1, false, true, __LINE__);
518  doCompare (array0, obj0, false, true, __LINE__);
519  doCompare (array0, obj1, false, true, __LINE__);
520  // lhs == rhs lhs < rhs
521  doCompare (array1, null0, false, false, __LINE__);
522  doCompare (array1, intNeg1, false, false, __LINE__);
523  doCompare (array1, int0, false, false, __LINE__);
524  doCompare (array1, intPos1, false, false, __LINE__);
525  doCompare (array1, uint0, false, false, __LINE__);
526  doCompare (array1, uint1, false, false, __LINE__);
527  doCompare (array1, realNeg1, false, false, __LINE__);
528  doCompare (array1, real0, false, false, __LINE__);
529  doCompare (array1, realPos1, false, false, __LINE__);
530  doCompare (array1, str0, false, false, __LINE__);
531  doCompare (array1, str1, false, false, __LINE__);
532  doCompare (array1, boolF, false, false, __LINE__);
533  doCompare (array1, boolT, false, false, __LINE__);
534  doCompare (array1, array0, false, false, __LINE__);
535  doCompare (array1, array1, true, false, __LINE__);
536  doCompare (array1, obj0, false, true, __LINE__);
537  doCompare (array1, obj1, false, true, __LINE__);
538  // lhs == rhs lhs < rhs
539  doCompare (obj0, null0, false, false, __LINE__);
540  doCompare (obj0, intNeg1, false, false, __LINE__);
541  doCompare (obj0, int0, false, false, __LINE__);
542  doCompare (obj0, intPos1, false, false, __LINE__);
543  doCompare (obj0, uint0, false, false, __LINE__);
544  doCompare (obj0, uint1, false, false, __LINE__);
545  doCompare (obj0, realNeg1, false, false, __LINE__);
546  doCompare (obj0, real0, false, false, __LINE__);
547  doCompare (obj0, realPos1, false, false, __LINE__);
548  doCompare (obj0, str0, false, false, __LINE__);
549  doCompare (obj0, str1, false, false, __LINE__);
550  doCompare (obj0, boolF, false, false, __LINE__);
551  doCompare (obj0, boolT, false, false, __LINE__);
552  doCompare (obj0, array0, false, false, __LINE__);
553  doCompare (obj0, array1, false, false, __LINE__);
554  doCompare (obj0, obj0, true, false, __LINE__);
555  doCompare (obj0, obj1, false, true, __LINE__);
556  // lhs == rhs lhs < rhs
557  doCompare (obj1, null0, false, false, __LINE__);
558  doCompare (obj1, intNeg1, false, false, __LINE__);
559  doCompare (obj1, int0, false, false, __LINE__);
560  doCompare (obj1, intPos1, false, false, __LINE__);
561  doCompare (obj1, uint0, false, false, __LINE__);
562  doCompare (obj1, uint1, false, false, __LINE__);
563  doCompare (obj1, realNeg1, false, false, __LINE__);
564  doCompare (obj1, real0, false, false, __LINE__);
565  doCompare (obj1, realPos1, false, false, __LINE__);
566  doCompare (obj1, str0, false, false, __LINE__);
567  doCompare (obj1, str1, false, false, __LINE__);
568  doCompare (obj1, boolF, false, false, __LINE__);
569  doCompare (obj1, boolT, false, false, __LINE__);
570  doCompare (obj1, array0, false, false, __LINE__);
571  doCompare (obj1, array1, false, false, __LINE__);
572  doCompare (obj1, obj0, false, false, __LINE__);
573  doCompare (obj1, obj1, true, false, __LINE__);
574  }
575 
576  void test_bool()
577  {
578  BEAST_EXPECT(! Json::Value());
579 
580  BEAST_EXPECT(! Json::Value(""));
581 
582  BEAST_EXPECT(bool (Json::Value("empty")));
583  BEAST_EXPECT(bool (Json::Value(false)));
584  BEAST_EXPECT(bool (Json::Value(true)));
585  BEAST_EXPECT(bool (Json::Value(0)));
586  BEAST_EXPECT(bool (Json::Value(1)));
587 
588  Json::Value array (Json::arrayValue);
589  BEAST_EXPECT(! array);
590  array.append(0);
591  BEAST_EXPECT(bool (array));
592 
593  Json::Value object (Json::objectValue);
594  BEAST_EXPECT(! object);
595  object[""] = false;
596  BEAST_EXPECT(bool (object));
597  }
598 
599  void test_bad_json ()
600  {
601  char const* s (
602  "{\"method\":\"ledger\",\"params\":[{\"ledger_index\":1e300}]}"
603  );
604 
605  Json::Value j;
606  Json::Reader r;
607 
608  r.parse (s, j);
609  pass ();
610  }
611 
612  void test_edge_cases ()
613  {
614  std::string json;
615 
616  std::uint32_t max_uint = std::numeric_limits<std::uint32_t>::max ();
617  std::int32_t max_int = std::numeric_limits<std::int32_t>::max ();
618  std::int32_t min_int = std::numeric_limits<std::int32_t>::min ();
619 
620  std::uint32_t a_uint = max_uint - 1978;
621  std::int32_t a_large_int = max_int - 1978;
622  std::int32_t a_small_int = min_int + 1978;
623 
624  json = "{\"max_uint\":" + std::to_string (max_uint);
625  json += ",\"max_int\":" + std::to_string (max_int);
626  json += ",\"min_int\":" + std::to_string (min_int);
627  json += ",\"a_uint\":" + std::to_string (a_uint);
628  json += ",\"a_large_int\":" + std::to_string (a_large_int);
629  json += ",\"a_small_int\":" + std::to_string (a_small_int);
630  json += "}";
631 
632  Json::Value j1;
633  Json::Reader r1;
634 
635  BEAST_EXPECT(r1.parse (json, j1));
636  BEAST_EXPECT(j1["max_uint"].asUInt() == max_uint);
637  BEAST_EXPECT(j1["max_int"].asInt() == max_int);
638  BEAST_EXPECT(j1["min_int"].asInt() == min_int);
639  BEAST_EXPECT(j1["a_uint"].asUInt() == a_uint);
640  BEAST_EXPECT(j1["a_uint"] > a_large_int);
641  BEAST_EXPECT(j1["a_uint"] > a_small_int);
642  BEAST_EXPECT(j1["a_large_int"].asInt() == a_large_int);
643  BEAST_EXPECT(j1["a_large_int"].asUInt() == a_large_int);
644  BEAST_EXPECT(j1["a_large_int"] < a_uint);
645  BEAST_EXPECT(j1["a_small_int"].asInt() == a_small_int);
646  BEAST_EXPECT(j1["a_small_int"] < a_uint);
647 
648  json = "{\"overflow\":";
649  json += std::to_string(std::uint64_t(max_uint) + 1);
650  json += "}";
651 
652  Json::Value j2;
653  Json::Reader r2;
654 
655  BEAST_EXPECT(!r2.parse (json, j2));
656 
657  json = "{\"underflow\":";
658  json += std::to_string(std::int64_t(min_int) - 1);
659  json += "}";
660 
661  Json::Value j3;
662  Json::Reader r3;
663 
664  BEAST_EXPECT(!r3.parse (json, j3));
665 
666  Json::Value intString {"4294967296"};
667  try
668  {
669  [[maybe_unused]] std::uint32_t const uTooBig {intString.asUInt()};
670  fail("4294967296", __FILE__, __LINE__);
671  } catch (beast::BadLexicalCast const&)
672  {
673  pass();
674  }
675 
676  intString = "4294967295";
677  BEAST_EXPECT (intString.asUInt() == 4294967295u);
678 
679  intString = "0";
680  BEAST_EXPECT (intString.asUInt() == 0);
681 
682  intString = "-1";
683  try
684  {
685  [[maybe_unused]] std::uint32_t const uTooSmall {intString.asUInt()};
686  fail("-1", __FILE__, __LINE__);
687  } catch (beast::BadLexicalCast const&)
688  {
689  pass();
690  }
691 
692  intString = "2147483648";
693  try
694  {
695  [[maybe_unused]] std::int32_t tooPos {intString.asInt()};
696  fail("2147483648", __FILE__, __LINE__);
697  } catch (beast::BadLexicalCast const&)
698  {
699  pass();
700  }
701 
702  intString = "2147483647";
703  BEAST_EXPECT (intString.asInt() == 2147483647);
704 
705  intString = "-2147483648";
706  BEAST_EXPECT (intString.asInt() == -2147483648LL); // MSVC wants the LL
707 
708  intString = "-2147483649";
709  try
710  {
711  [[maybe_unused]] std::int32_t tooNeg {intString.asInt()};
712  fail("-2147483649", __FILE__, __LINE__);
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 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  {
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 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); // asserts
858  BEAST_EXPECT(val.asString() == "");
859  BEAST_EXPECT(val.asInt() == 0);
860  BEAST_EXPECT(val.asUInt() == 0);
861  BEAST_EXPECT(val.asDouble() == 0.0);
862  BEAST_EXPECT(val.asBool() == false);
863 
864  BEAST_EXPECT( val.isConvertibleTo (Json::nullValue));
865  BEAST_EXPECT( val.isConvertibleTo (Json::intValue));
866  BEAST_EXPECT( val.isConvertibleTo (Json::uintValue));
867  BEAST_EXPECT( val.isConvertibleTo (Json::realValue));
868  BEAST_EXPECT( val.isConvertibleTo (Json::stringValue));
869  BEAST_EXPECT( val.isConvertibleTo (Json::booleanValue));
870  BEAST_EXPECT( val.isConvertibleTo (Json::arrayValue));
871  BEAST_EXPECT( val.isConvertibleTo (Json::objectValue));
872  }
873  {
874  // int
875  Json::Value val = -1234;
876  BEAST_EXPECT(val.isInt());
877 // BEAST_EXPECT(strcmp (val.asCString(), ?) == 0); // asserts
878  BEAST_EXPECT(val.asString() == "-1234");
879  BEAST_EXPECT(val.asInt() == -1234);
880 // BEAST_EXPECT(val.asUInt() == ?); // asserts or throws
881  BEAST_EXPECT(val.asDouble() == -1234.0);
882  BEAST_EXPECT(val.asBool() == true);
883 
884  BEAST_EXPECT(! val.isConvertibleTo (Json::nullValue));
885  BEAST_EXPECT( val.isConvertibleTo (Json::intValue));
886  BEAST_EXPECT(! val.isConvertibleTo (Json::uintValue));
887  BEAST_EXPECT( val.isConvertibleTo (Json::realValue));
888  BEAST_EXPECT( val.isConvertibleTo (Json::stringValue));
889  BEAST_EXPECT( val.isConvertibleTo (Json::booleanValue));
890  BEAST_EXPECT(! val.isConvertibleTo (Json::arrayValue));
891  BEAST_EXPECT(! val.isConvertibleTo (Json::objectValue));
892  }
893  {
894  // uint
895  Json::Value val = 1234U;
896  BEAST_EXPECT(val.isUInt());
897 // BEAST_EXPECT(strcmp (val.asCString(), ?) == 0); // asserts
898  BEAST_EXPECT(val.asString() == "1234");
899  BEAST_EXPECT(val.asInt() == 1234);
900  BEAST_EXPECT(val.asUInt() == 1234u);
901  BEAST_EXPECT(val.asDouble() == 1234.0);
902  BEAST_EXPECT(val.asBool() == true);
903 
904  BEAST_EXPECT(! val.isConvertibleTo (Json::nullValue));
905  BEAST_EXPECT( val.isConvertibleTo (Json::intValue));
906  BEAST_EXPECT( val.isConvertibleTo (Json::uintValue));
907  BEAST_EXPECT( val.isConvertibleTo (Json::realValue));
908  BEAST_EXPECT( val.isConvertibleTo (Json::stringValue));
909  BEAST_EXPECT( val.isConvertibleTo (Json::booleanValue));
910  BEAST_EXPECT(! val.isConvertibleTo (Json::arrayValue));
911  BEAST_EXPECT(! val.isConvertibleTo (Json::objectValue));
912  }
913  {
914  // real
915  Json::Value val = 2.0;
916  BEAST_EXPECT(val.isDouble());
917 // BEAST_EXPECT(strcmp (val.asCString(), ?) == 0); // asserts
918  BEAST_EXPECT(std::regex_match(
919  val.asString(), std::regex("^2\\.0*$")));
920  BEAST_EXPECT(val.asInt() == 2);
921  BEAST_EXPECT(val.asUInt() == 2u);
922  BEAST_EXPECT(val.asDouble() == 2.0);
923  BEAST_EXPECT(val.asBool() == true);
924 
925  BEAST_EXPECT(! val.isConvertibleTo (Json::nullValue));
926  BEAST_EXPECT( val.isConvertibleTo (Json::intValue));
927  BEAST_EXPECT( val.isConvertibleTo (Json::uintValue));
928  BEAST_EXPECT( val.isConvertibleTo (Json::realValue));
929  BEAST_EXPECT( val.isConvertibleTo (Json::stringValue));
930  BEAST_EXPECT( val.isConvertibleTo (Json::booleanValue));
931  BEAST_EXPECT(! val.isConvertibleTo (Json::arrayValue));
932  BEAST_EXPECT(! val.isConvertibleTo (Json::objectValue));
933  }
934  {
935  // numeric string
936  Json::Value val = "54321";
937  BEAST_EXPECT(val.isString());
938  BEAST_EXPECT(strcmp (val.asCString(), "54321") == 0);
939  BEAST_EXPECT(val.asString() == "54321");
940  BEAST_EXPECT(val.asInt() == 54321);
941  BEAST_EXPECT(val.asUInt() == 54321u);
942 // BEAST_EXPECT(val.asDouble() == 54321.0); // asserts or throws
943  BEAST_EXPECT(val.asBool() == true);
944 
945  BEAST_EXPECT(! val.isConvertibleTo (Json::nullValue));
946  BEAST_EXPECT(! val.isConvertibleTo (Json::intValue));
947  BEAST_EXPECT(! val.isConvertibleTo (Json::uintValue));
948  BEAST_EXPECT(! val.isConvertibleTo (Json::realValue));
949  BEAST_EXPECT( val.isConvertibleTo (Json::stringValue));
950  BEAST_EXPECT(! val.isConvertibleTo (Json::booleanValue));
951  BEAST_EXPECT(! val.isConvertibleTo (Json::arrayValue));
952  BEAST_EXPECT(! val.isConvertibleTo (Json::objectValue));
953  }
954  {
955  // non-numeric string
956  Json::Value val (Json::stringValue);
957  BEAST_EXPECT(val.isString());
958  BEAST_EXPECT(val.asCString() == nullptr);
959  BEAST_EXPECT(val.asString() == "");
960  try {
961  BEAST_EXPECT(val.asInt() == 0);
962  fail("expected exception", __FILE__, __LINE__);
963  } catch (std::exception const&) {
964  pass();
965  }
966  try {
967  BEAST_EXPECT(val.asUInt() == 0);
968  fail("expected exception", __FILE__, __LINE__);
969  } catch (std::exception const&) {
970  pass();
971  }
972 // BEAST_EXPECT(val.asDouble() == ?); // asserts or throws
973  BEAST_EXPECT(val.asBool() == false);
974 
975  BEAST_EXPECT( val.isConvertibleTo (Json::nullValue));
976  BEAST_EXPECT(! val.isConvertibleTo (Json::intValue));
977  BEAST_EXPECT(! val.isConvertibleTo (Json::uintValue));
978  BEAST_EXPECT(! val.isConvertibleTo (Json::realValue));
979  BEAST_EXPECT(val.isConvertibleTo (Json::stringValue));
980  BEAST_EXPECT(! val.isConvertibleTo (Json::booleanValue));
981  BEAST_EXPECT(! val.isConvertibleTo (Json::arrayValue));
982  BEAST_EXPECT(! val.isConvertibleTo (Json::objectValue));
983  }
984  {
985  // bool false
986  Json::Value val = false;
987  BEAST_EXPECT(val.isBool());
988 // BEAST_EXPECT(strcmp (val.asCString(), ?) == 0); // asserts
989  BEAST_EXPECT(val.asString() == "false");
990  BEAST_EXPECT(val.asInt() == 0);
991  BEAST_EXPECT(val.asUInt() == 0);
992  BEAST_EXPECT(val.asDouble() == 0.0);
993  BEAST_EXPECT(val.asBool() == false);
994 
995  BEAST_EXPECT( val.isConvertibleTo (Json::nullValue));
996  BEAST_EXPECT( val.isConvertibleTo (Json::intValue));
997  BEAST_EXPECT( val.isConvertibleTo (Json::uintValue));
998  BEAST_EXPECT( val.isConvertibleTo (Json::realValue));
999  BEAST_EXPECT( val.isConvertibleTo (Json::stringValue));
1000  BEAST_EXPECT( val.isConvertibleTo (Json::booleanValue));
1001  BEAST_EXPECT(! val.isConvertibleTo (Json::arrayValue));
1002  BEAST_EXPECT(! val.isConvertibleTo (Json::objectValue));
1003  }
1004  {
1005  // bool true
1006  Json::Value val = true;
1007  BEAST_EXPECT(val.isBool());
1008 // BEAST_EXPECT(strcmp (val.asCString(), ?) == 0); // asserts
1009  BEAST_EXPECT(val.asString() == "true");
1010  BEAST_EXPECT(val.asInt() == 1);
1011  BEAST_EXPECT(val.asUInt() == 1);
1012  BEAST_EXPECT(val.asDouble() == 1.0);
1013  BEAST_EXPECT(val.asBool() == true);
1014 
1015  BEAST_EXPECT(! val.isConvertibleTo (Json::nullValue));
1016  BEAST_EXPECT( val.isConvertibleTo (Json::intValue));
1017  BEAST_EXPECT( val.isConvertibleTo (Json::uintValue));
1018  BEAST_EXPECT( val.isConvertibleTo (Json::realValue));
1019  BEAST_EXPECT( val.isConvertibleTo (Json::stringValue));
1020  BEAST_EXPECT( val.isConvertibleTo (Json::booleanValue));
1021  BEAST_EXPECT(! val.isConvertibleTo (Json::arrayValue));
1022  BEAST_EXPECT(! val.isConvertibleTo (Json::objectValue));
1023  }
1024  {
1025  // array type
1026  Json::Value val (Json::arrayValue);
1027  BEAST_EXPECT (val.isArray());
1028 // BEAST_EXPECT(strcmp (val.asCString(), ?) == 0); // asserts
1029 // BEAST_EXPECT(val.asString() == ?); // asserts or throws
1030 // BEAST_EXPECT(val.asInt() == ?); // asserts or throws
1031 // BEAST_EXPECT(val.asUInt() == ?); // asserts or throws
1032 // BEAST_EXPECT(val.asDouble() == ?); // asserts or throws
1033  BEAST_EXPECT(val.asBool() == false); // empty or not
1034 
1035  BEAST_EXPECT( val.isConvertibleTo (Json::nullValue));
1036  BEAST_EXPECT(! val.isConvertibleTo (Json::intValue));
1037  BEAST_EXPECT(! val.isConvertibleTo (Json::uintValue));
1038  BEAST_EXPECT(! val.isConvertibleTo (Json::realValue));
1039  BEAST_EXPECT(! val.isConvertibleTo (Json::stringValue));
1040  BEAST_EXPECT(! val.isConvertibleTo (Json::booleanValue));
1041  BEAST_EXPECT( val.isConvertibleTo (Json::arrayValue));
1042  BEAST_EXPECT(! val.isConvertibleTo (Json::objectValue));
1043  }
1044  {
1045  // object type
1046  Json::Value val (Json::objectValue);
1047  BEAST_EXPECT (val.isObject());
1048 // BEAST_EXPECT(strcmp (val.asCString(), ?) == 0); // asserts
1049 // BEAST_EXPECT(strcmp (val.asCString(), ?) == 0); // asserts
1050 // BEAST_EXPECT(val.asString() == ?); // asserts or throws
1051 // BEAST_EXPECT(val.asInt() == ?); // asserts or throws
1052 // BEAST_EXPECT(val.asUInt() == ?); // asserts or throws
1053  BEAST_EXPECT(val.asBool() == false); // empty or not
1054 
1055  BEAST_EXPECT( val.isConvertibleTo (Json::nullValue));
1056  BEAST_EXPECT(! val.isConvertibleTo (Json::intValue));
1057  BEAST_EXPECT(! val.isConvertibleTo (Json::uintValue));
1058  BEAST_EXPECT(! val.isConvertibleTo (Json::realValue));
1059  BEAST_EXPECT(! val.isConvertibleTo (Json::stringValue));
1060  BEAST_EXPECT(! val.isConvertibleTo (Json::booleanValue));
1061  BEAST_EXPECT(! val.isConvertibleTo (Json::arrayValue));
1062  BEAST_EXPECT( val.isConvertibleTo (Json::objectValue));
1063  }
1064  }
1065 
1066  void
1067  test_access()
1068  {
1069  Json::Value val;
1070  BEAST_EXPECT (val.type() == Json::nullValue);
1071  BEAST_EXPECT (val.size() == 0);
1072  BEAST_EXPECT (! val.isValidIndex(0));
1073  BEAST_EXPECT (! val.isMember("key"));
1074  {
1075  Json::Value const constVal = val;
1076  BEAST_EXPECT (constVal[7u].type() == Json::nullValue);
1077  BEAST_EXPECT (! constVal.isMember("key"));
1078  BEAST_EXPECT (constVal["key"].type() == Json::nullValue);
1079  BEAST_EXPECT (constVal.getMemberNames().empty());
1080  BEAST_EXPECT (constVal.get (1u, "default0") == "default0");
1081  BEAST_EXPECT (constVal.get (std::string ("not"), "oh") == "oh");
1082  BEAST_EXPECT (constVal.get ("missing", "default2") == "default2");
1083  }
1084 
1085  val = -7;
1086  BEAST_EXPECT (val.type() == Json::intValue);
1087  BEAST_EXPECT (val.size() == 0);
1088  BEAST_EXPECT (! val.isValidIndex(0));
1089  BEAST_EXPECT (! val.isMember("key"));
1090 
1091  val = 42u;
1092  BEAST_EXPECT (val.type() == Json::uintValue);
1093  BEAST_EXPECT (val.size() == 0);
1094  BEAST_EXPECT (! val.isValidIndex(0));
1095  BEAST_EXPECT (! val.isMember("key"));
1096 
1097  val = 3.14159;
1098  BEAST_EXPECT (val.type() == Json::realValue);
1099  BEAST_EXPECT (val.size() == 0);
1100  BEAST_EXPECT (! val.isValidIndex(0));
1101  BEAST_EXPECT (! val.isMember("key"));
1102 
1103  val = true;
1104  BEAST_EXPECT (val.type() == Json::booleanValue);
1105  BEAST_EXPECT (val.size() == 0);
1106  BEAST_EXPECT (! val.isValidIndex(0));
1107  BEAST_EXPECT (! val.isMember("key"));
1108 
1109  val = "string";
1110  BEAST_EXPECT (val.type() == Json::stringValue);
1111  BEAST_EXPECT (val.size() == 0);
1112  BEAST_EXPECT (! val.isValidIndex(0));
1113  BEAST_EXPECT (! val.isMember("key"));
1114 
1115  val = Json::Value (Json::objectValue);
1116  BEAST_EXPECT (val.type() == Json::objectValue);
1117  BEAST_EXPECT (val.size() == 0);
1118  static Json::StaticString const staticThree ("three");
1119  val[staticThree] = 3;
1120  val["two"] = 2;
1121  BEAST_EXPECT (val.size() == 2);
1122  BEAST_EXPECT (val.isValidIndex(1));
1123  BEAST_EXPECT (! val.isValidIndex(2));
1124  BEAST_EXPECT (val[staticThree] == 3);
1125  BEAST_EXPECT (val.isMember("two"));
1126  BEAST_EXPECT (val.isMember(staticThree));
1127  BEAST_EXPECT (! val.isMember("key"));
1128  {
1129  Json::Value const constVal = val;
1130  BEAST_EXPECT (constVal["two"] == 2);
1131  BEAST_EXPECT (constVal["four"].type() == Json::nullValue);
1132  BEAST_EXPECT (constVal[staticThree] == 3);
1133  BEAST_EXPECT (constVal.isMember("two"));
1134  BEAST_EXPECT (constVal.isMember(staticThree));
1135  BEAST_EXPECT (! constVal.isMember("key"));
1136  BEAST_EXPECT (val.get (std::string("two"), "backup") == 2);
1137  BEAST_EXPECT (val.get ("missing", "default2") == "default2");
1138  }
1139 
1140  val = Json::Value (Json::arrayValue);
1141  BEAST_EXPECT (val.type() == Json::arrayValue);
1142  BEAST_EXPECT (val.size() == 0);
1143  val[0u] = "zero";
1144  val[1u] = "one";
1145  BEAST_EXPECT (val.size() == 2);
1146  BEAST_EXPECT (val.isValidIndex(1));
1147  BEAST_EXPECT (! val.isValidIndex(2));
1148  BEAST_EXPECT (val[20u].type() == Json::nullValue);
1149  BEAST_EXPECT (! val.isMember("key"));
1150  {
1151  Json::Value const constVal = val;
1152  BEAST_EXPECT (constVal[0u] == "zero");
1153  BEAST_EXPECT (constVal[2u].type() == Json::nullValue);
1154  BEAST_EXPECT (! constVal.isMember("key"));
1155  BEAST_EXPECT (val.get (1u, "default0") == "one");
1156  BEAST_EXPECT (val.get (3u, "default1") == "default1");
1157  }
1158  }
1159 
1160  void
1161  test_removeMember()
1162  {
1163  Json::Value val;
1164  BEAST_EXPECT (
1165  val.removeMember (std::string("member")).type() == Json::nullValue);
1166 
1167  val = Json::Value (Json::objectValue);
1168  static Json::StaticString const staticThree ("three");
1169  val[staticThree] = 3;
1170  val["two"] = 2;
1171  BEAST_EXPECT (val.size() == 2);
1172 
1173  BEAST_EXPECT (
1174  val.removeMember (std::string("six")).type() == Json::nullValue);
1175  BEAST_EXPECT (val.size() == 2);
1176 
1177  BEAST_EXPECT (val.removeMember (staticThree) == 3);
1178  BEAST_EXPECT (val.size() == 1);
1179 
1180  BEAST_EXPECT (val.removeMember (staticThree).type() == Json::nullValue);
1181  BEAST_EXPECT (val.size() == 1);
1182 
1183  BEAST_EXPECT (val.removeMember (std::string ("two")) == 2);
1184  BEAST_EXPECT (val.size() == 0);
1185 
1186  BEAST_EXPECT (
1187  val.removeMember (std::string ("two")).type() == Json::nullValue);
1188  BEAST_EXPECT (val.size() == 0);
1189  }
1190 
1191  void
1192  test_iterator()
1193  {
1194  {
1195  // Iterating an array.
1196  Json::Value arr {Json::arrayValue};
1197  arr[0u] = "zero";
1198  arr[1u] = "one";
1199  arr[2u] = "two";
1200  arr[3u] = "three";
1201 
1202  Json::ValueIterator const b {arr.begin()};
1203  Json::ValueIterator const e {arr.end()};
1204 
1205  Json::ValueIterator i1 = b;
1206  Json::ValueIterator i2 = e;
1207  --i2;
1208 
1209  // key(), index(), and memberName() on an object iterator.
1210  BEAST_EXPECT (b != e);
1211  BEAST_EXPECT (! (b == e));
1212  BEAST_EXPECT (i1.key() == 0);
1213  BEAST_EXPECT (i2.key() == 3);
1214  BEAST_EXPECT (i1.index() == 0);
1215  BEAST_EXPECT (i2.index() == 3);
1216  BEAST_EXPECT (std::strcmp (i1.memberName(), "") == 0);
1217  BEAST_EXPECT (std::strcmp (i2.memberName(), "") == 0);
1218 
1219  // Pre and post increment and decrement.
1220  *i1++ = "0";
1221  BEAST_EXPECT (*i1 == "one");
1222  *i1 = "1";
1223  ++i1;
1224 
1225  *i2-- = "3";
1226  BEAST_EXPECT (*i2 == "two");
1227  BEAST_EXPECT (i1 == i2);
1228  *i2 = "2";
1229  BEAST_EXPECT (*i1 == "2");
1230  }
1231  {
1232  // Iterating a const object.
1233  Json::Value const obj {[] ()
1234  {
1235  Json::Value obj {Json::objectValue};
1236  obj["0"] = 0;
1237  obj["1"] = 1;
1238  obj["2"] = 2;
1239  obj["3"] = 3;
1240  return obj;
1241  }()
1242  };
1243 
1244  Json::ValueConstIterator i1 {obj.begin()};
1245  Json::ValueConstIterator i2 {obj.end()};
1246  --i2;
1247 
1248  // key(), index(), and memberName() on an object iterator.
1249  BEAST_EXPECT (i1 != i2);
1250  BEAST_EXPECT (! (i1 == i2));
1251  BEAST_EXPECT (i1.key() == "0");
1252  BEAST_EXPECT (i2.key() == "3");
1253  BEAST_EXPECT (i1.index() == -1);
1254  BEAST_EXPECT (i2.index() == -1);
1255  BEAST_EXPECT (std::strcmp (i1.memberName(), "0") == 0);
1256  BEAST_EXPECT (std::strcmp (i2.memberName(), "3") == 0);
1257 
1258  // Pre and post increment and decrement.
1259  BEAST_EXPECT (*i1++ == 0);
1260  BEAST_EXPECT (*i1 == 1);
1261  ++i1;
1262 
1263  BEAST_EXPECT (*i2-- == 3);
1264  BEAST_EXPECT (*i2 == 2);
1265  BEAST_EXPECT (i1 == i2);
1266  BEAST_EXPECT (*i1 == 2);
1267  }
1268  {
1269  // Iterating a non-const null object.
1270  Json::Value nul {};
1271  BEAST_EXPECT (nul.begin() == nul.end());
1272  }
1273  {
1274  // Iterating a const Int.
1275  Json::Value const i {-3};
1276  BEAST_EXPECT (i.begin() == i.end());
1277  }
1278  }
1279 
1280  void test_nest_limits ()
1281  {
1282  Json::Reader r;
1283  {
1284  auto nest = [](std::uint32_t depth)->std::string {
1285  std::string s = "{";
1286  for (std::uint32_t i{1}; i <= depth; ++i)
1287  s += "\"obj\":{";
1288  for (std::uint32_t i{1}; i <= depth; ++i)
1289  s += "}";
1290  s += "}";
1291  return s;
1292  };
1293 
1294  {
1295  // Within object nest limit
1296  auto json{nest(std::min(10u, Json::Reader::nest_limit))};
1297  Json::Value j;
1298  BEAST_EXPECT(r.parse(json, j));
1299  }
1300 
1301  {
1302  // Exceed object nest limit
1303  auto json{nest(Json::Reader::nest_limit + 1)};
1304  Json::Value j;
1305  BEAST_EXPECT(!r.parse(json, j));
1306  }
1307  }
1308 
1309  auto nest = [](std::uint32_t depth)->std::string {
1310  std::string s = "{";
1311  for (std::uint32_t i{1}; i <= depth; ++i)
1312  s += "\"array\":[{";
1313  for (std::uint32_t i{1}; i <= depth; ++i)
1314  s += "]}";
1315  s += "}";
1316  return s;
1317  };
1318  {
1319  // Exceed array 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  void
1327  test_leak()
1328  {
1329  // When run with the address sanitizer, this test confirms there is no
1330  // memory leak with the scenarios below.
1331  {
1332  Json::Value a;
1333  a[0u] = 1;
1334  BEAST_EXPECT (a.type() == Json::arrayValue);
1335  BEAST_EXPECT (a[0u].type() == Json::intValue);
1336  a = std::move(a[0u]);
1337  BEAST_EXPECT (a.type() == Json::intValue);
1338  }
1339  {
1340  Json::Value b;
1341  Json::Value temp;
1342  temp["a"] = "Probably avoids the small string optimization";
1343  temp["b"] = "Also probably avoids the small string optimization";
1344  BEAST_EXPECT (temp.type() == Json::objectValue);
1345  b.append (temp);
1346  BEAST_EXPECT (temp.type() == Json::objectValue);
1347  BEAST_EXPECT (b.size() == 1);
1348 
1349  b.append (std::move (temp));
1350  BEAST_EXPECT (b.size() == 2);
1351 
1352  // Note that the type() == nullValue check is implementation
1353  // specific and not guaranteed to be valid in the future.
1354  BEAST_EXPECT (temp.type() == Json::nullValue);
1355  }
1356  }
1357 
1358  void run () override
1359  {
1360  test_StaticString ();
1361  test_types ();
1362  test_compare ();
1363  test_bool ();
1364  test_bad_json ();
1365  test_edge_cases ();
1366  test_copy ();
1367  test_move ();
1368  test_comparisons ();
1369  test_compact ();
1370  test_conversions ();
1371  test_access ();
1372  test_removeMember ();
1373  test_iterator ();
1374  test_nest_limits ();
1375  test_leak ();
1376  }
1377 };
1378 
1379 BEAST_DEFINE_TESTSUITE(json_value, json, ripple);
1380 
1381 } // ripple
Json::Value::isInt
bool isInt() const
Definition: json_value.cpp:1012
ripple::json_value_test
Definition: json_value_test.cpp:32
Json::ValueIterator
Iterator for object and array value.
Definition: json_value.h:530
std::strcmp
T strcmp(T... args)
regex
Json::Value::isObject
bool isObject() const
Definition: json_value.cpp:1069
std::string
STL class.
Json::Value::isString
bool isString() const
Definition: json_value.cpp:1049
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:862
std::exception
STL class.
Json::arrayValue
@ arrayValue
array value (ordered list)
Definition: json_value.h:44
Json::booleanValue
@ booleanValue
bool value
Definition: json_value.h:43
Json::UInt
unsigned int UInt
Definition: json_forwards.h:28
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:853
Json::Compact
Decorator for streaming out compact json.
Definition: json_writer.h:277
ripple::json_value_test::test_bool
void test_bool()
Definition: json_value_test.cpp:576
Json::Value::isDouble
bool isDouble() const
Definition: json_value.cpp:1035
std::stringstream
STL class.
Json::realValue
@ realValue
double value
Definition: json_value.h:41
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:133
Json::Value::isNull
bool isNull() const
isNull() tests to see if this field is null.
Definition: json_value.cpp:998
beast::BadLexicalCast
Thrown when a conversion is not possible with LexicalCast.
Definition: LexicalCast.h:253
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:1280
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:116
Json::Value::asBool
bool asBool() const
Definition: json_value.cpp:626
ripple::json_value_test::test_StaticString
void test_StaticString()
Definition: json_value_test.cpp:34
Json::uintValue
@ uintValue
unsigned integer value
Definition: json_value.h:40
Json::Value::append
Value & append(const Value &value)
Append value to array at the end.
Definition: json_value.cpp:907
Json::objectValue
@ objectValue
object value (collection of name/value pairs).
Definition: json_value.h:45
ripple::json_value_test::test_edge_cases
void test_edge_cases()
Definition: json_value_test.cpp:612
ripple::json_value_test::test_compare
void test_compare()
Definition: json_value_test.cpp:213
Json::Value::isConvertibleTo
bool isConvertibleTo(ValueType other) const
Definition: json_value.cpp:659
Json::ValueConstIterator
const iterator for object and array value.
Definition: json_value.h:477
std::to_string
T to_string(T... args)
ripple::json_value_test::test_iterator
void test_iterator()
Definition: json_value_test.cpp:1192
ripple::json_value_test::test_leak
void test_leak()
Definition: json_value_test.cpp:1327
Json::Value::size
UInt size() const
Number of values in array or object.
Definition: json_value.cpp:720
Json::Value::isMember
bool isMember(const char *key) const
Return true if the object has a member named key.
Definition: json_value.cpp:961
Json::stringValue
@ stringValue
UTF-8 string value.
Definition: json_value.h:42
std::uint32_t
Json::ValueType
ValueType
Type of the value held by a Value object.
Definition: json_value.h:36
Json::Value::asCString
const char * asCString() const
Definition: json_value.cpp:474
ripple::json_value_test::test_removeMember
void test_removeMember()
Definition: json_value_test.cpp:1161
std::regex
Json::Int
int Int
Definition: json_forwards.h:27
ripple::json_value_test::test_bad_json
void test_bad_json()
Definition: json_value_test.cpp:599
ripple::json_value_test::test_compact
void test_compact()
Definition: json_value_test.cpp:821
ripple::json_value_test::test_types
void test_types()
Definition: json_value_test.cpp:58
Json::Value::isArray
bool isArray() const
Definition: json_value.cpp:1056
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:979
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:936
Json::StaticString
Lightweight wrapper to tag static string.
Definition: json_value.h:62
Json::Reader::nest_limit
static constexpr unsigned nest_limit
Definition: json_reader.h:84
Json::intValue
@ intValue
signed integer value
Definition: json_value.h:39
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:555
Json::Value::isUInt
bool isUInt() const
Definition: json_value.cpp:1019
ripple::json_value_test::test_access
void test_access()
Definition: json_value_test.cpp:1067
Json::Reader::parse
bool parse(std::string const &document, Value &root)
Read a Value from a JSON document.
Definition: json_reader.cpp:76
Json::nullValue
@ nullValue
'null' value
Definition: json_value.h:38
std::count_if
T count_if(T... args)
ripple::json_value_test::test_conversions
void test_conversions()
Definition: json_value_test.cpp:847
std::vector::empty
T empty(T... args)
Json::Value::isBool
bool isBool() const
Definition: json_value.cpp:1005
std::stringstream::str
T str(T... args)
Json::Value::asInt
Int asInt() const
Definition: json_value.cpp:516
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:594
Json::Value::type
ValueType type() const
Definition: json_value.cpp:363
ripple::json_value_test::run
void run() override
Definition: json_value_test.cpp:1358
Json::Value
Represents a JSON value.
Definition: json_value.h:141
Json::ValueIteratorBase::memberName
const char * memberName() const
Return the member name of the referenced Value. "" if it is not an objectValue.
Definition: json_valueiterator.cpp:145
Json::Value::asString
std::string asString() const
Returns the unquoted string value.
Definition: json_value.cpp:482
Generated by   doxygen 1.8.17