Branch data Line data Source code
1 : : // Copyright (c) 2014 BitPay Inc.
2 : : // Copyright (c) 2014-2022 The Bitcoin Core developers
3 : : // Distributed under the MIT software license, see the accompanying
4 : : // file COPYING or https://opensource.org/licenses/mit-license.php.
5 : :
6 : : #include <univalue.h>
7 : :
8 : : #include <cassert>
9 : : #include <cstdint>
10 : : #include <map>
11 : : #include <memory>
12 : : #include <stdexcept>
13 : : #include <string>
14 : : #include <string_view>
15 : : #include <vector>
16 : :
17 : : #define BOOST_CHECK(expr) assert(expr)
18 : : #define BOOST_CHECK_EQUAL(v1, v2) assert((v1) == (v2))
19 : : #define BOOST_CHECK_THROW(stmt, excMatch) { \
20 : : try { \
21 : : (stmt); \
22 : : assert(0 && "No exception caught"); \
23 : : } catch (excMatch&) { \
24 : : } catch (...) { \
25 : : assert(0 && "Wrong exception caught"); \
26 : : } \
27 : : }
28 : : #define BOOST_CHECK_NO_THROW(stmt) { \
29 : : try { \
30 : : (stmt); \
31 : : } catch (...) { \
32 : : assert(0); \
33 : : } \
34 : : }
35 : :
36 : 1 : void univalue_constructor()
37 : : {
38 : 1 : UniValue v1;
39 : 1 : BOOST_CHECK(v1.isNull());
40 : :
41 : 1 : UniValue v2(UniValue::VSTR);
42 [ - + ]: 1 : BOOST_CHECK(v2.isStr());
43 : :
44 [ + - ]: 2 : UniValue v3(UniValue::VSTR, "foo");
45 [ - + ]: 1 : BOOST_CHECK(v3.isStr());
46 [ - + ]: 1 : BOOST_CHECK_EQUAL(v3.getValStr(), "foo");
47 : :
48 [ + - ]: 1 : UniValue numTest;
49 [ + - + - ]: 1 : numTest.setNumStr("82");
50 [ - + ]: 1 : BOOST_CHECK(numTest.isNum());
51 [ - + ]: 1 : BOOST_CHECK_EQUAL(numTest.getValStr(), "82");
52 : :
53 : 1 : uint64_t vu64 = 82;
54 [ + - ]: 1 : UniValue v4(vu64);
55 [ - + ]: 1 : BOOST_CHECK(v4.isNum());
56 [ - + ]: 1 : BOOST_CHECK_EQUAL(v4.getValStr(), "82");
57 : :
58 : 1 : int64_t vi64 = -82;
59 [ + - ]: 1 : UniValue v5(vi64);
60 [ - + ]: 1 : BOOST_CHECK(v5.isNum());
61 [ - + ]: 1 : BOOST_CHECK_EQUAL(v5.getValStr(), "-82");
62 : :
63 : 1 : int vi = -688;
64 [ + - ]: 1 : UniValue v6(vi);
65 [ - + ]: 1 : BOOST_CHECK(v6.isNum());
66 [ - + ]: 1 : BOOST_CHECK_EQUAL(v6.getValStr(), "-688");
67 : :
68 : 1 : double vd = -7.21;
69 [ + - ]: 1 : UniValue v7(vd);
70 [ - + ]: 1 : BOOST_CHECK(v7.isNum());
71 [ - + ]: 1 : BOOST_CHECK_EQUAL(v7.getValStr(), "-7.21");
72 : :
73 [ + - ]: 1 : std::string vs("yawn");
74 [ + - ]: 1 : UniValue v8(vs);
75 [ - + ]: 1 : BOOST_CHECK(v8.isStr());
76 [ - + ]: 1 : BOOST_CHECK_EQUAL(v8.getValStr(), "yawn");
77 : :
78 : 1 : const char *vcs = "zappa";
79 [ + - ]: 1 : UniValue v9(vcs);
80 [ - + ]: 1 : BOOST_CHECK(v9.isStr());
81 [ - + ]: 1 : BOOST_CHECK_EQUAL(v9.getValStr(), "zappa");
82 : 1 : }
83 : :
84 : 1 : void univalue_push_throw()
85 : : {
86 [ + - ]: 1 : UniValue j;
87 [ + - - + : 2 : BOOST_CHECK_THROW(j.push_back(1), std::runtime_error);
+ - ]
88 [ - + + - : 2 : BOOST_CHECK_THROW(j.push_backV({1}), std::runtime_error);
+ - ]
89 [ + - - + : 3 : BOOST_CHECK_THROW(j.pushKVEnd("k", 1), std::runtime_error);
+ - + - ]
90 [ + - - + : 3 : BOOST_CHECK_THROW(j.pushKV("k", 1), std::runtime_error);
+ - + - ]
91 [ - + + - ]: 2 : BOOST_CHECK_THROW(j.pushKVs({}), std::runtime_error);
92 : 1 : }
93 : :
94 : 1 : void univalue_typecheck()
95 : : {
96 [ + - ]: 1 : UniValue v1;
97 [ + - + - ]: 1 : v1.setNumStr("1");
98 [ - + ]: 1 : BOOST_CHECK(v1.isNum());
99 [ - + + - ]: 1 : BOOST_CHECK_THROW(v1.get_bool(), std::runtime_error);
100 : :
101 : 1 : {
102 [ + - ]: 1 : UniValue v_negative;
103 [ + - + - ]: 1 : v_negative.setNumStr("-1");
104 [ - + + - ]: 1 : BOOST_CHECK_THROW(v_negative.getInt<uint8_t>(), std::runtime_error);
105 [ - + + - ]: 1 : BOOST_CHECK_EQUAL(v_negative.getInt<int8_t>(), -1);
106 : 1 : }
107 : :
108 [ + - ]: 1 : UniValue v2;
109 [ + - ]: 1 : v2.setBool(true);
110 [ + - - + ]: 1 : BOOST_CHECK_EQUAL(v2.get_bool(), true);
111 [ - + + - ]: 1 : BOOST_CHECK_THROW(v2.getInt<int>(), std::runtime_error);
112 : :
113 [ + - ]: 1 : UniValue v3;
114 [ + - + - ]: 1 : v3.setNumStr("32482348723847471234");
115 [ - + + - ]: 1 : BOOST_CHECK_THROW(v3.getInt<int64_t>(), std::runtime_error);
116 [ + - + - ]: 1 : v3.setNumStr("1000");
117 [ + - - + ]: 1 : BOOST_CHECK_EQUAL(v3.getInt<int64_t>(), 1000);
118 : :
119 [ + - ]: 1 : UniValue v4;
120 [ + - + - ]: 1 : v4.setNumStr("2147483648");
121 [ + - - + ]: 1 : BOOST_CHECK_EQUAL(v4.getInt<int64_t>(), 2147483648);
122 [ - + + - ]: 1 : BOOST_CHECK_THROW(v4.getInt<int>(), std::runtime_error);
123 [ + - + - ]: 1 : v4.setNumStr("1000");
124 [ + - - + ]: 1 : BOOST_CHECK_EQUAL(v4.getInt<int>(), 1000);
125 [ - + + - ]: 1 : BOOST_CHECK_THROW(v4.get_str(), std::runtime_error);
126 [ - + + - ]: 1 : BOOST_CHECK_EQUAL(v4.get_real(), 1000);
127 [ - + + - ]: 1 : BOOST_CHECK_THROW(v4.get_array(), std::runtime_error);
128 [ - + + - ]: 1 : BOOST_CHECK_THROW(v4.getKeys(), std::runtime_error);
129 [ - + + - ]: 1 : BOOST_CHECK_THROW(v4.getValues(), std::runtime_error);
130 [ - + + - ]: 1 : BOOST_CHECK_THROW(v4.get_obj(), std::runtime_error);
131 : :
132 [ + - ]: 1 : UniValue v5;
133 [ - + + - ]: 1 : BOOST_CHECK(v5.read("[true, 10]"));
134 [ + - ]: 1 : BOOST_CHECK_NO_THROW(v5.get_array());
135 [ + - + - ]: 1 : std::vector<UniValue> vals = v5.getValues();
136 [ - + + - ]: 1 : BOOST_CHECK_THROW(vals[0].getInt<int>(), std::runtime_error);
137 [ - + + - ]: 1 : BOOST_CHECK_EQUAL(vals[0].get_bool(), true);
138 : :
139 [ + - - + ]: 1 : BOOST_CHECK_EQUAL(vals[1].getInt<int>(), 10);
140 [ - + + - ]: 1 : BOOST_CHECK_THROW(vals[1].get_bool(), std::runtime_error);
141 : 1 : }
142 : :
143 : 1 : void univalue_set()
144 : : {
145 : 2 : UniValue v(UniValue::VSTR, "foo");
146 [ + - ]: 1 : v.clear();
147 [ - + ]: 1 : BOOST_CHECK(v.isNull());
148 [ - + ]: 1 : BOOST_CHECK_EQUAL(v.getValStr(), "");
149 : :
150 [ + - ]: 1 : v.setObject();
151 [ - + ]: 1 : BOOST_CHECK(v.isObject());
152 [ - + ]: 1 : BOOST_CHECK_EQUAL(v.size(), 0);
153 : 1 : BOOST_CHECK_EQUAL(v.getType(), UniValue::VOBJ);
154 [ + - ]: 1 : BOOST_CHECK(v.empty());
155 : :
156 [ + - ]: 1 : v.setArray();
157 [ - + ]: 1 : BOOST_CHECK(v.isArray());
158 [ - + ]: 1 : BOOST_CHECK_EQUAL(v.size(), 0);
159 : :
160 [ + - + - ]: 1 : v.setStr("zum");
161 [ - + ]: 1 : BOOST_CHECK(v.isStr());
162 [ - + ]: 1 : BOOST_CHECK_EQUAL(v.getValStr(), "zum");
163 : :
164 : 1 : {
165 : 1 : std::string_view sv{"ab\0c", 4};
166 [ + - ]: 1 : UniValue j{sv};
167 [ - + ]: 1 : BOOST_CHECK(j.isStr());
168 [ - + ]: 1 : BOOST_CHECK_EQUAL(j.getValStr(), sv);
169 [ + - - + ]: 1 : BOOST_CHECK_EQUAL(j.write(), "\"ab\\u0000c\"");
170 : 1 : }
171 : :
172 [ + - ]: 1 : v.setFloat(-1.01);
173 [ - + ]: 1 : BOOST_CHECK(v.isNum());
174 [ - + ]: 1 : BOOST_CHECK_EQUAL(v.getValStr(), "-1.01");
175 : :
176 [ + - ]: 1 : v.setInt(int{1023});
177 [ - + ]: 1 : BOOST_CHECK(v.isNum());
178 [ - + ]: 1 : BOOST_CHECK_EQUAL(v.getValStr(), "1023");
179 : :
180 [ + - ]: 1 : v.setInt(int64_t{-1023LL});
181 [ - + ]: 1 : BOOST_CHECK(v.isNum());
182 [ - + ]: 1 : BOOST_CHECK_EQUAL(v.getValStr(), "-1023");
183 : :
184 [ + - ]: 1 : v.setInt(uint64_t{1023ULL});
185 [ - + ]: 1 : BOOST_CHECK(v.isNum());
186 [ - + ]: 1 : BOOST_CHECK_EQUAL(v.getValStr(), "1023");
187 : :
188 [ + - + - ]: 1 : v.setNumStr("-688");
189 [ - + ]: 1 : BOOST_CHECK(v.isNum());
190 [ - + ]: 1 : BOOST_CHECK_EQUAL(v.getValStr(), "-688");
191 : :
192 [ + - ]: 1 : v.setBool(false);
193 [ - + ]: 1 : BOOST_CHECK_EQUAL(v.isBool(), true);
194 [ - + ]: 1 : BOOST_CHECK_EQUAL(v.isTrue(), false);
195 [ - + ]: 1 : BOOST_CHECK_EQUAL(v.isFalse(), true);
196 [ + - - + ]: 1 : BOOST_CHECK_EQUAL(v.get_bool(), false);
197 : :
198 [ + - ]: 1 : v.setBool(true);
199 [ - + ]: 1 : BOOST_CHECK_EQUAL(v.isBool(), true);
200 [ - + ]: 1 : BOOST_CHECK_EQUAL(v.isTrue(), true);
201 [ - + ]: 1 : BOOST_CHECK_EQUAL(v.isFalse(), false);
202 [ + - - + ]: 1 : BOOST_CHECK_EQUAL(v.get_bool(), true);
203 : :
204 [ + - - + : 2 : BOOST_CHECK_THROW(v.setNumStr("zombocom"), std::runtime_error);
+ - ]
205 : :
206 [ + - ]: 1 : v.setNull();
207 [ - + ]: 1 : BOOST_CHECK(v.isNull());
208 : 1 : }
209 : :
210 : 1 : void univalue_array()
211 : : {
212 : 1 : UniValue arr(UniValue::VARR);
213 : :
214 [ + - ]: 1 : UniValue v((int64_t)1023LL);
215 [ + - + - ]: 1 : arr.push_back(v);
216 : :
217 [ + - ]: 1 : std::string vStr("zippy");
218 [ + - + - ]: 1 : arr.push_back(vStr);
219 : :
220 : 1 : const char *s = "pippy";
221 [ + - + - ]: 1 : arr.push_back(s);
222 : :
223 : 1 : std::vector<UniValue> vec;
224 [ + - + - ]: 1 : v.setStr("boing");
225 [ + - ]: 1 : vec.push_back(v);
226 : :
227 [ + - + - ]: 1 : v.setStr("going");
228 [ + - ]: 1 : vec.push_back(v);
229 : :
230 [ + - ]: 1 : arr.push_backV(vec);
231 : :
232 [ + - + - ]: 1 : arr.push_back(uint64_t{400ULL});
233 [ + - + - ]: 1 : arr.push_back(int64_t{-400LL});
234 [ + - + - ]: 1 : arr.push_back(int{-401});
235 [ + - + - ]: 1 : arr.push_back(-40.1);
236 [ + - + - ]: 1 : arr.push_back(true);
237 : :
238 [ - + ]: 1 : BOOST_CHECK_EQUAL(arr.empty(), false);
239 [ - + ]: 1 : BOOST_CHECK_EQUAL(arr.size(), 10);
240 : :
241 [ + - - + ]: 1 : BOOST_CHECK_EQUAL(arr[0].getValStr(), "1023");
242 [ + - - + ]: 1 : BOOST_CHECK_EQUAL(arr[0].getType(), UniValue::VNUM);
243 [ + - - + ]: 1 : BOOST_CHECK_EQUAL(arr[1].getValStr(), "zippy");
244 [ + - - + ]: 1 : BOOST_CHECK_EQUAL(arr[1].getType(), UniValue::VSTR);
245 [ + - - + ]: 1 : BOOST_CHECK_EQUAL(arr[2].getValStr(), "pippy");
246 [ + - - + ]: 1 : BOOST_CHECK_EQUAL(arr[2].getType(), UniValue::VSTR);
247 [ + - - + ]: 1 : BOOST_CHECK_EQUAL(arr[3].getValStr(), "boing");
248 [ + - - + ]: 1 : BOOST_CHECK_EQUAL(arr[3].getType(), UniValue::VSTR);
249 [ + - - + ]: 1 : BOOST_CHECK_EQUAL(arr[4].getValStr(), "going");
250 [ + - - + ]: 1 : BOOST_CHECK_EQUAL(arr[4].getType(), UniValue::VSTR);
251 [ + - - + ]: 1 : BOOST_CHECK_EQUAL(arr[5].getValStr(), "400");
252 [ + - - + ]: 1 : BOOST_CHECK_EQUAL(arr[5].getType(), UniValue::VNUM);
253 [ + - - + ]: 1 : BOOST_CHECK_EQUAL(arr[6].getValStr(), "-400");
254 [ + - - + ]: 1 : BOOST_CHECK_EQUAL(arr[6].getType(), UniValue::VNUM);
255 [ + - - + ]: 1 : BOOST_CHECK_EQUAL(arr[7].getValStr(), "-401");
256 [ + - - + ]: 1 : BOOST_CHECK_EQUAL(arr[7].getType(), UniValue::VNUM);
257 [ + - - + ]: 1 : BOOST_CHECK_EQUAL(arr[8].getValStr(), "-40.1");
258 [ + - - + ]: 1 : BOOST_CHECK_EQUAL(arr[8].getType(), UniValue::VNUM);
259 [ + - - + ]: 1 : BOOST_CHECK_EQUAL(arr[9].getValStr(), "1");
260 [ + - - + ]: 1 : BOOST_CHECK_EQUAL(arr[9].getType(), UniValue::VBOOL);
261 : :
262 [ + - - + ]: 1 : BOOST_CHECK_EQUAL(arr[999].getValStr(), "");
263 : :
264 [ + - ]: 1 : arr.clear();
265 [ - + ]: 1 : BOOST_CHECK(arr.empty());
266 : 1 : BOOST_CHECK_EQUAL(arr.size(), 0);
267 : 1 : }
268 : :
269 : 1 : void univalue_object()
270 : : {
271 : 1 : UniValue obj(UniValue::VOBJ);
272 [ + - ]: 1 : std::string strKey, strVal;
273 [ + - ]: 1 : UniValue v;
274 : :
275 [ + - ]: 1 : strKey = "age";
276 [ + - ]: 1 : v.setInt(100);
277 [ + - + - : 2 : obj.pushKV(strKey, v);
+ - ]
278 : :
279 [ + - ]: 1 : strKey = "first";
280 [ + - ]: 1 : strVal = "John";
281 [ + - + - : 2 : obj.pushKV(strKey, strVal);
+ - ]
282 : :
283 [ + - ]: 1 : strKey = "last";
284 : 1 : const char* cVal = "Smith";
285 [ + - + - : 2 : obj.pushKV(strKey, cVal);
+ - ]
286 : :
287 [ + - ]: 1 : strKey = "distance";
288 [ + - + - : 2 : obj.pushKV(strKey, int64_t{25});
+ - ]
289 : :
290 [ + - ]: 1 : strKey = "time";
291 [ + - + - : 2 : obj.pushKV(strKey, uint64_t{3600});
+ - ]
292 : :
293 [ + - ]: 1 : strKey = "calories";
294 [ + - + - : 2 : obj.pushKV(strKey, int{12});
+ - ]
295 : :
296 [ + - ]: 1 : strKey = "temperature";
297 [ + - + - : 2 : obj.pushKV(strKey, double{90.012});
+ - ]
298 : :
299 [ + - ]: 1 : strKey = "moon";
300 [ + - + - : 2 : obj.pushKV(strKey, true);
+ - ]
301 : :
302 [ + - ]: 1 : strKey = "spoon";
303 [ + - + - : 2 : obj.pushKV(strKey, false);
+ - ]
304 : :
305 : 1 : UniValue obj2(UniValue::VOBJ);
306 [ + - + - : 2 : obj2.pushKV("cat1", 9000);
+ - ]
307 [ + - + - : 2 : obj2.pushKV("cat2", 12345);
+ - ]
308 : :
309 [ + - + - ]: 1 : obj.pushKVs(obj2);
310 : :
311 [ - + ]: 1 : BOOST_CHECK_EQUAL(obj.empty(), false);
312 [ - + ]: 1 : BOOST_CHECK_EQUAL(obj.size(), 11);
313 : :
314 [ + - + - : 1 : BOOST_CHECK_EQUAL(obj["age"].getValStr(), "100");
- + ]
315 [ + - + - : 1 : BOOST_CHECK_EQUAL(obj["first"].getValStr(), "John");
- + ]
316 [ + - + - : 1 : BOOST_CHECK_EQUAL(obj["last"].getValStr(), "Smith");
- + ]
317 [ + - + - : 1 : BOOST_CHECK_EQUAL(obj["distance"].getValStr(), "25");
- + ]
318 [ + - + - : 1 : BOOST_CHECK_EQUAL(obj["time"].getValStr(), "3600");
- + ]
319 [ + - + - : 1 : BOOST_CHECK_EQUAL(obj["calories"].getValStr(), "12");
- + ]
320 [ + - + - : 1 : BOOST_CHECK_EQUAL(obj["temperature"].getValStr(), "90.012");
- + ]
321 [ + - + - : 1 : BOOST_CHECK_EQUAL(obj["moon"].getValStr(), "1");
- + ]
322 [ + - + - : 1 : BOOST_CHECK_EQUAL(obj["spoon"].getValStr(), "");
- + ]
323 [ + - + - : 1 : BOOST_CHECK_EQUAL(obj["cat1"].getValStr(), "9000");
- + ]
324 [ + - + - : 1 : BOOST_CHECK_EQUAL(obj["cat2"].getValStr(), "12345");
- + ]
325 : :
326 [ + - + - : 1 : BOOST_CHECK_EQUAL(obj["nyuknyuknyuk"].getValStr(), "");
- + ]
327 : :
328 [ + - - + ]: 2 : BOOST_CHECK(obj.exists("age"));
329 [ + - - + ]: 2 : BOOST_CHECK(obj.exists("first"));
330 [ + - - + ]: 2 : BOOST_CHECK(obj.exists("last"));
331 [ + - - + ]: 2 : BOOST_CHECK(obj.exists("distance"));
332 [ + - - + ]: 2 : BOOST_CHECK(obj.exists("time"));
333 [ + - - + ]: 2 : BOOST_CHECK(obj.exists("calories"));
334 [ + - - + ]: 2 : BOOST_CHECK(obj.exists("temperature"));
335 [ + - - + ]: 2 : BOOST_CHECK(obj.exists("moon"));
336 [ + - - + ]: 2 : BOOST_CHECK(obj.exists("spoon"));
337 [ + - - + ]: 2 : BOOST_CHECK(obj.exists("cat1"));
338 [ + - - + ]: 2 : BOOST_CHECK(obj.exists("cat2"));
339 : :
340 [ + - - + ]: 2 : BOOST_CHECK(!obj.exists("nyuknyuknyuk"));
341 : :
342 [ + - ]: 1 : std::map<std::string, UniValue::VType> objTypes;
343 [ + - + - ]: 1 : objTypes["age"] = UniValue::VNUM;
344 [ + - + - ]: 1 : objTypes["first"] = UniValue::VSTR;
345 [ + - + - ]: 1 : objTypes["last"] = UniValue::VSTR;
346 [ + - + - ]: 1 : objTypes["distance"] = UniValue::VNUM;
347 [ + - + - ]: 1 : objTypes["time"] = UniValue::VNUM;
348 [ + - + - ]: 1 : objTypes["calories"] = UniValue::VNUM;
349 [ + - + - ]: 1 : objTypes["temperature"] = UniValue::VNUM;
350 [ + - + - ]: 1 : objTypes["moon"] = UniValue::VBOOL;
351 [ + - + - ]: 1 : objTypes["spoon"] = UniValue::VBOOL;
352 [ + - + - ]: 1 : objTypes["cat1"] = UniValue::VNUM;
353 [ + - + - ]: 1 : objTypes["cat2"] = UniValue::VNUM;
354 [ + - - + ]: 1 : BOOST_CHECK(obj.checkObject(objTypes));
355 : :
356 [ + - + - ]: 1 : objTypes["cat2"] = UniValue::VSTR;
357 [ + - - + ]: 1 : BOOST_CHECK(!obj.checkObject(objTypes));
358 : :
359 [ + - ]: 1 : obj.clear();
360 [ - + ]: 1 : BOOST_CHECK(obj.empty());
361 [ - + ]: 1 : BOOST_CHECK_EQUAL(obj.size(), 0);
362 [ - + ]: 1 : BOOST_CHECK_EQUAL(obj.getType(), UniValue::VNULL);
363 : :
364 [ + - ]: 1 : obj.setObject();
365 [ + - ]: 1 : UniValue uv;
366 [ + - ]: 1 : uv.setInt(42);
367 [ + - + - : 2 : obj.pushKVEnd("age", uv);
+ - ]
368 [ - + ]: 1 : BOOST_CHECK_EQUAL(obj.size(), 1);
369 [ + - + - : 1 : BOOST_CHECK_EQUAL(obj["age"].getValStr(), "42");
- + ]
370 : :
371 [ + - ]: 1 : uv.setInt(43);
372 [ + - + - : 2 : obj.pushKV("age", uv);
+ - ]
373 [ - + ]: 1 : BOOST_CHECK_EQUAL(obj.size(), 1);
374 [ + - + - : 1 : BOOST_CHECK_EQUAL(obj["age"].getValStr(), "43");
- + ]
375 : :
376 [ + - + - : 2 : obj.pushKV("name", "foo bar");
+ - ]
377 : :
378 [ + - ]: 1 : std::map<std::string,UniValue> kv;
379 [ + - ]: 1 : obj.getObjMap(kv);
380 [ + - + - : 1 : BOOST_CHECK_EQUAL(kv["age"].getValStr(), "43");
- + ]
381 [ + - + - : 2 : BOOST_CHECK_EQUAL(kv["name"].getValStr(), "foo bar");
- + ]
382 : :
383 : 1 : }
384 : :
385 : : static const char *json1 =
386 : : "[1.10000000,{\"key1\":\"str\\u0000\",\"key2\":800,\"key3\":{\"name\":\"martian http://test.com\"}}]";
387 : :
388 : 1 : void univalue_readwrite()
389 : : {
390 [ + - ]: 1 : UniValue v;
391 [ + - - + ]: 1 : BOOST_CHECK(v.read(json1));
392 : :
393 [ + - ]: 1 : std::string strJson1(json1);
394 [ + - - + ]: 1 : BOOST_CHECK(v.read(strJson1));
395 : :
396 [ - + ]: 1 : BOOST_CHECK(v.isArray());
397 [ - + ]: 1 : BOOST_CHECK_EQUAL(v.size(), 2);
398 : :
399 [ + - - + ]: 1 : BOOST_CHECK_EQUAL(v[0].getValStr(), "1.10000000");
400 : :
401 [ + - + - ]: 1 : UniValue obj = v[1];
402 [ - + ]: 1 : BOOST_CHECK(obj.isObject());
403 [ - + ]: 1 : BOOST_CHECK_EQUAL(obj.size(), 3);
404 : :
405 [ + - + - : 1 : BOOST_CHECK(obj["key1"].isStr());
- + ]
406 [ + - ]: 1 : std::string correctValue("str");
407 [ + - ]: 1 : correctValue.push_back('\0');
408 [ + - + - : 1 : BOOST_CHECK_EQUAL(obj["key1"].getValStr(), correctValue);
- + ]
409 [ + - + - : 1 : BOOST_CHECK(obj["key2"].isNum());
- + ]
410 [ + - + - : 1 : BOOST_CHECK_EQUAL(obj["key2"].getValStr(), "800");
- + ]
411 [ + - + - : 1 : BOOST_CHECK(obj["key3"].isObject());
- + ]
412 : :
413 [ + - - + ]: 1 : BOOST_CHECK_EQUAL(strJson1, v.write());
414 : :
415 : : // Valid
416 [ + - + - : 1 : BOOST_CHECK(v.read("1.0") && (v.get_real() == 1.0));
+ - - + ]
417 [ + - + - : 1 : BOOST_CHECK(v.read("true") && v.get_bool());
+ - - + ]
418 [ + - + - : 1 : BOOST_CHECK(v.read("[false]") && !v[0].get_bool());
+ - + - -
+ ]
419 [ + - + - : 1 : BOOST_CHECK(v.read("{\"a\": true}") && v["a"].get_bool());
+ - + - +
- - + ]
420 [ + - + - : 1 : BOOST_CHECK(v.read("{\"1\": \"true\"}") && (v["1"].get_str() == "true"));
+ - + - +
- - + ]
421 : : // Valid, with leading or trailing whitespace
422 [ + - + - : 1 : BOOST_CHECK(v.read(" 1.0") && (v.get_real() == 1.0));
+ - - + ]
423 [ + - + - : 1 : BOOST_CHECK(v.read("1.0 ") && (v.get_real() == 1.0));
+ - - + ]
424 [ + - - + ]: 1 : BOOST_CHECK(v.read("0.00000000000000000000000000000000000001e+30 "));
425 : :
426 [ + - - + ]: 1 : BOOST_CHECK(!v.read(".19e-6")); //should fail, missing leading 0, therefore invalid JSON
427 : : // Invalid, initial garbage
428 [ + - - + ]: 1 : BOOST_CHECK(!v.read("[1.0"));
429 [ + - - + ]: 1 : BOOST_CHECK(!v.read("a1.0"));
430 : : // Invalid, trailing garbage
431 [ + - - + ]: 1 : BOOST_CHECK(!v.read("1.0sds"));
432 [ + - - + ]: 1 : BOOST_CHECK(!v.read("1.0]"));
433 : : // Invalid, keys have to be names
434 [ + - - + ]: 1 : BOOST_CHECK(!v.read("{1: \"true\"}"));
435 [ + - - + ]: 1 : BOOST_CHECK(!v.read("{true: 1}"));
436 [ + - - + ]: 1 : BOOST_CHECK(!v.read("{[1]: 1}"));
437 [ + - - + ]: 1 : BOOST_CHECK(!v.read("{{\"a\": \"a\"}: 1}"));
438 : : // BTC addresses should fail parsing
439 [ + - - + ]: 1 : BOOST_CHECK(!v.read("175tWpb8K1S7NmH4Zx6rewF9WQrcZv245W"));
440 [ + - - + ]: 1 : BOOST_CHECK(!v.read("3J98t1WpEZ73CNmQviecrnyiWrnqRhWNL"));
441 : :
442 : : /* Check for (correctly reporting) a parsing error if the initial
443 : : JSON construct is followed by more stuff. Note that whitespace
444 : : is, of course, exempt. */
445 : :
446 [ + - - + ]: 1 : BOOST_CHECK(v.read(" {}\n "));
447 [ - + ]: 1 : BOOST_CHECK(v.isObject());
448 [ + - - + ]: 1 : BOOST_CHECK(v.read(" []\n "));
449 [ - + ]: 1 : BOOST_CHECK(v.isArray());
450 : :
451 [ + - - + ]: 1 : BOOST_CHECK(!v.read("@{}"));
452 [ + - - + ]: 1 : BOOST_CHECK(!v.read("{} garbage"));
453 [ + - - + ]: 1 : BOOST_CHECK(!v.read("[]{}"));
454 [ + - - + ]: 1 : BOOST_CHECK(!v.read("{}[]"));
455 [ + - - + ]: 1 : BOOST_CHECK(!v.read("{} 42"));
456 : 1 : }
457 : :
458 : 1 : int main(int argc, char* argv[])
459 : : {
460 : 1 : univalue_constructor();
461 : 1 : univalue_push_throw();
462 : 1 : univalue_typecheck();
463 : 1 : univalue_set();
464 : 1 : univalue_array();
465 : 1 : univalue_object();
466 : 1 : univalue_readwrite();
467 : 1 : return 0;
468 : : }
|
