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