1 // Copyright 2014 BitPay, Inc.
2 // Copyright (c) 2014-2015 The Bitcoin Core developers
3 // Distributed under the MIT software license, see the accompanying
4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
5
6 #include <stdint.h>
7 #include <vector>
8 #include <string>
9 #include <map>
10 #include <univalue.h>
11 #include "test/test_bitcoin.h"
12
13 #include <boost/test/unit_test.hpp>
14
15 using namespace std;
16
BOOST_FIXTURE_TEST_SUITE(univalue_tests,BasicTestingSetup)17 BOOST_FIXTURE_TEST_SUITE(univalue_tests, BasicTestingSetup)
18
19 BOOST_AUTO_TEST_CASE(univalue_constructor)
20 {
21 UniValue v1;
22 BOOST_CHECK(v1.isNull());
23
24 UniValue v2(UniValue::VSTR);
25 BOOST_CHECK(v2.isStr());
26
27 UniValue v3(UniValue::VSTR, "foo");
28 BOOST_CHECK(v3.isStr());
29 BOOST_CHECK_EQUAL(v3.getValStr(), "foo");
30
31 UniValue numTest;
32 BOOST_CHECK(numTest.setNumStr("82"));
33 BOOST_CHECK(numTest.isNum());
34 BOOST_CHECK_EQUAL(numTest.getValStr(), "82");
35
36 uint64_t vu64 = 82;
37 UniValue v4(vu64);
38 BOOST_CHECK(v4.isNum());
39 BOOST_CHECK_EQUAL(v4.getValStr(), "82");
40
41 int64_t vi64 = -82;
42 UniValue v5(vi64);
43 BOOST_CHECK(v5.isNum());
44 BOOST_CHECK_EQUAL(v5.getValStr(), "-82");
45
46 int vi = -688;
47 UniValue v6(vi);
48 BOOST_CHECK(v6.isNum());
49 BOOST_CHECK_EQUAL(v6.getValStr(), "-688");
50
51 double vd = -7.21;
52 UniValue v7(vd);
53 BOOST_CHECK(v7.isNum());
54 BOOST_CHECK_EQUAL(v7.getValStr(), "-7.21");
55
56 string vs("yawn");
57 UniValue v8(vs);
58 BOOST_CHECK(v8.isStr());
59 BOOST_CHECK_EQUAL(v8.getValStr(), "yawn");
60
61 const char *vcs = "zappa";
62 UniValue v9(vcs);
63 BOOST_CHECK(v9.isStr());
64 BOOST_CHECK_EQUAL(v9.getValStr(), "zappa");
65 }
66
BOOST_AUTO_TEST_CASE(univalue_typecheck)67 BOOST_AUTO_TEST_CASE(univalue_typecheck)
68 {
69 UniValue v1;
70 BOOST_CHECK(v1.setNumStr("1"));
71 BOOST_CHECK(v1.isNum());
72 BOOST_CHECK_THROW(v1.get_bool(), runtime_error);
73
74 UniValue v2;
75 BOOST_CHECK(v2.setBool(true));
76 BOOST_CHECK_EQUAL(v2.get_bool(), true);
77 BOOST_CHECK_THROW(v2.get_int(), runtime_error);
78
79 UniValue v3;
80 BOOST_CHECK(v3.setNumStr("32482348723847471234"));
81 BOOST_CHECK_THROW(v3.get_int64(), runtime_error);
82 BOOST_CHECK(v3.setNumStr("1000"));
83 BOOST_CHECK_EQUAL(v3.get_int64(), 1000);
84
85 UniValue v4;
86 BOOST_CHECK(v4.setNumStr("2147483648"));
87 BOOST_CHECK_EQUAL(v4.get_int64(), 2147483648);
88 BOOST_CHECK_THROW(v4.get_int(), runtime_error);
89 BOOST_CHECK(v4.setNumStr("1000"));
90 BOOST_CHECK_EQUAL(v4.get_int(), 1000);
91 BOOST_CHECK_THROW(v4.get_str(), runtime_error);
92 BOOST_CHECK_EQUAL(v4.get_real(), 1000);
93 BOOST_CHECK_THROW(v4.get_array(), runtime_error);
94 BOOST_CHECK_THROW(v4.getKeys(), runtime_error);
95 BOOST_CHECK_THROW(v4.getValues(), runtime_error);
96 BOOST_CHECK_THROW(v4.get_obj(), runtime_error);
97
98 UniValue v5;
99 BOOST_CHECK(v5.read("[true, 10]"));
100 BOOST_CHECK_NO_THROW(v5.get_array());
101 std::vector<UniValue> vals = v5.getValues();
102 BOOST_CHECK_THROW(vals[0].get_int(), runtime_error);
103 BOOST_CHECK_EQUAL(vals[0].get_bool(), true);
104
105 BOOST_CHECK_EQUAL(vals[1].get_int(), 10);
106 BOOST_CHECK_THROW(vals[1].get_bool(), runtime_error);
107 }
108
BOOST_AUTO_TEST_CASE(univalue_set)109 BOOST_AUTO_TEST_CASE(univalue_set)
110 {
111 UniValue v(UniValue::VSTR, "foo");
112 v.clear();
113 BOOST_CHECK(v.isNull());
114 BOOST_CHECK_EQUAL(v.getValStr(), "");
115
116 BOOST_CHECK(v.setObject());
117 BOOST_CHECK(v.isObject());
118 BOOST_CHECK_EQUAL(v.size(), 0);
119 BOOST_CHECK_EQUAL(v.getType(), UniValue::VOBJ);
120 BOOST_CHECK(v.empty());
121
122 BOOST_CHECK(v.setArray());
123 BOOST_CHECK(v.isArray());
124 BOOST_CHECK_EQUAL(v.size(), 0);
125
126 BOOST_CHECK(v.setStr("zum"));
127 BOOST_CHECK(v.isStr());
128 BOOST_CHECK_EQUAL(v.getValStr(), "zum");
129
130 BOOST_CHECK(v.setFloat(-1.01));
131 BOOST_CHECK(v.isNum());
132 BOOST_CHECK_EQUAL(v.getValStr(), "-1.01");
133
134 BOOST_CHECK(v.setInt((int)1023));
135 BOOST_CHECK(v.isNum());
136 BOOST_CHECK_EQUAL(v.getValStr(), "1023");
137
138 BOOST_CHECK(v.setInt((int64_t)-1023LL));
139 BOOST_CHECK(v.isNum());
140 BOOST_CHECK_EQUAL(v.getValStr(), "-1023");
141
142 BOOST_CHECK(v.setInt((uint64_t)1023ULL));
143 BOOST_CHECK(v.isNum());
144 BOOST_CHECK_EQUAL(v.getValStr(), "1023");
145
146 BOOST_CHECK(v.setNumStr("-688"));
147 BOOST_CHECK(v.isNum());
148 BOOST_CHECK_EQUAL(v.getValStr(), "-688");
149
150 BOOST_CHECK(v.setBool(false));
151 BOOST_CHECK_EQUAL(v.isBool(), true);
152 BOOST_CHECK_EQUAL(v.isTrue(), false);
153 BOOST_CHECK_EQUAL(v.isFalse(), true);
154 BOOST_CHECK_EQUAL(v.getBool(), false);
155
156 BOOST_CHECK(v.setBool(true));
157 BOOST_CHECK_EQUAL(v.isBool(), true);
158 BOOST_CHECK_EQUAL(v.isTrue(), true);
159 BOOST_CHECK_EQUAL(v.isFalse(), false);
160 BOOST_CHECK_EQUAL(v.getBool(), true);
161
162 BOOST_CHECK(!v.setNumStr("zombocom"));
163
164 BOOST_CHECK(v.setNull());
165 BOOST_CHECK(v.isNull());
166 }
167
BOOST_AUTO_TEST_CASE(univalue_array)168 BOOST_AUTO_TEST_CASE(univalue_array)
169 {
170 UniValue arr(UniValue::VARR);
171
172 UniValue v((int64_t)1023LL);
173 BOOST_CHECK(arr.push_back(v));
174
175 string vStr("zippy");
176 BOOST_CHECK(arr.push_back(vStr));
177
178 const char *s = "pippy";
179 BOOST_CHECK(arr.push_back(s));
180
181 vector<UniValue> vec;
182 v.setStr("boing");
183 vec.push_back(v);
184
185 v.setStr("going");
186 vec.push_back(v);
187
188 BOOST_CHECK(arr.push_backV(vec));
189
190 BOOST_CHECK_EQUAL(arr.empty(), false);
191 BOOST_CHECK_EQUAL(arr.size(), 5);
192
193 BOOST_CHECK_EQUAL(arr[0].getValStr(), "1023");
194 BOOST_CHECK_EQUAL(arr[1].getValStr(), "zippy");
195 BOOST_CHECK_EQUAL(arr[2].getValStr(), "pippy");
196 BOOST_CHECK_EQUAL(arr[3].getValStr(), "boing");
197 BOOST_CHECK_EQUAL(arr[4].getValStr(), "going");
198
199 BOOST_CHECK_EQUAL(arr[999].getValStr(), "");
200
201 arr.clear();
202 BOOST_CHECK(arr.empty());
203 BOOST_CHECK_EQUAL(arr.size(), 0);
204 }
205
BOOST_AUTO_TEST_CASE(univalue_object)206 BOOST_AUTO_TEST_CASE(univalue_object)
207 {
208 UniValue obj(UniValue::VOBJ);
209 string strKey, strVal;
210 UniValue v;
211
212 strKey = "age";
213 v.setInt(100);
214 BOOST_CHECK(obj.pushKV(strKey, v));
215
216 strKey = "first";
217 strVal = "John";
218 BOOST_CHECK(obj.pushKV(strKey, strVal));
219
220 strKey = "last";
221 const char *cVal = "Smith";
222 BOOST_CHECK(obj.pushKV(strKey, cVal));
223
224 strKey = "distance";
225 BOOST_CHECK(obj.pushKV(strKey, (int64_t) 25));
226
227 strKey = "time";
228 BOOST_CHECK(obj.pushKV(strKey, (uint64_t) 3600));
229
230 strKey = "calories";
231 BOOST_CHECK(obj.pushKV(strKey, (int) 12));
232
233 strKey = "temperature";
234 BOOST_CHECK(obj.pushKV(strKey, (double) 90.012));
235
236 UniValue obj2(UniValue::VOBJ);
237 BOOST_CHECK(obj2.pushKV("cat1", 9000));
238 BOOST_CHECK(obj2.pushKV("cat2", 12345));
239
240 BOOST_CHECK(obj.pushKVs(obj2));
241
242 BOOST_CHECK_EQUAL(obj.empty(), false);
243 BOOST_CHECK_EQUAL(obj.size(), 9);
244
245 BOOST_CHECK_EQUAL(obj["age"].getValStr(), "100");
246 BOOST_CHECK_EQUAL(obj["first"].getValStr(), "John");
247 BOOST_CHECK_EQUAL(obj["last"].getValStr(), "Smith");
248 BOOST_CHECK_EQUAL(obj["distance"].getValStr(), "25");
249 BOOST_CHECK_EQUAL(obj["time"].getValStr(), "3600");
250 BOOST_CHECK_EQUAL(obj["calories"].getValStr(), "12");
251 BOOST_CHECK_EQUAL(obj["temperature"].getValStr(), "90.012");
252 BOOST_CHECK_EQUAL(obj["cat1"].getValStr(), "9000");
253 BOOST_CHECK_EQUAL(obj["cat2"].getValStr(), "12345");
254
255 BOOST_CHECK_EQUAL(obj["nyuknyuknyuk"].getValStr(), "");
256
257 BOOST_CHECK(obj.exists("age"));
258 BOOST_CHECK(obj.exists("first"));
259 BOOST_CHECK(obj.exists("last"));
260 BOOST_CHECK(obj.exists("distance"));
261 BOOST_CHECK(obj.exists("time"));
262 BOOST_CHECK(obj.exists("calories"));
263 BOOST_CHECK(obj.exists("temperature"));
264 BOOST_CHECK(obj.exists("cat1"));
265 BOOST_CHECK(obj.exists("cat2"));
266
267 BOOST_CHECK(!obj.exists("nyuknyuknyuk"));
268
269 map<string, UniValue::VType> objTypes;
270 objTypes["age"] = UniValue::VNUM;
271 objTypes["first"] = UniValue::VSTR;
272 objTypes["last"] = UniValue::VSTR;
273 objTypes["distance"] = UniValue::VNUM;
274 objTypes["time"] = UniValue::VNUM;
275 objTypes["calories"] = UniValue::VNUM;
276 objTypes["temperature"] = UniValue::VNUM;
277 objTypes["cat1"] = UniValue::VNUM;
278 objTypes["cat2"] = UniValue::VNUM;
279 BOOST_CHECK(obj.checkObject(objTypes));
280
281 objTypes["cat2"] = UniValue::VSTR;
282 BOOST_CHECK(!obj.checkObject(objTypes));
283
284 obj.clear();
285 BOOST_CHECK(obj.empty());
286 BOOST_CHECK_EQUAL(obj.size(), 0);
287 }
288
289 static const char *json1 =
290 "[1.10000000,{\"key1\":\"str\\u0000\",\"key2\":800,\"key3\":{\"name\":\"martian http://test.com\"}}]";
291
BOOST_AUTO_TEST_CASE(univalue_readwrite)292 BOOST_AUTO_TEST_CASE(univalue_readwrite)
293 {
294 UniValue v;
295 BOOST_CHECK(v.read(json1));
296
297 string strJson1(json1);
298 BOOST_CHECK(v.read(strJson1));
299
300 BOOST_CHECK(v.isArray());
301 BOOST_CHECK_EQUAL(v.size(), 2);
302
303 BOOST_CHECK_EQUAL(v[0].getValStr(), "1.10000000");
304
305 UniValue obj = v[1];
306 BOOST_CHECK(obj.isObject());
307 BOOST_CHECK_EQUAL(obj.size(), 3);
308
309 BOOST_CHECK(obj["key1"].isStr());
310 std::string correctValue("str");
311 correctValue.push_back('\0');
312 BOOST_CHECK_EQUAL(obj["key1"].getValStr(), correctValue);
313 BOOST_CHECK(obj["key2"].isNum());
314 BOOST_CHECK_EQUAL(obj["key2"].getValStr(), "800");
315 BOOST_CHECK(obj["key3"].isObject());
316
317 BOOST_CHECK_EQUAL(strJson1, v.write());
318
319 /* Check for (correctly reporting) a parsing error if the initial
320 JSON construct is followed by more stuff. Note that whitespace
321 is, of course, exempt. */
322
323 BOOST_CHECK(v.read(" {}\n "));
324 BOOST_CHECK(v.isObject());
325 BOOST_CHECK(v.read(" []\n "));
326 BOOST_CHECK(v.isArray());
327
328 BOOST_CHECK(!v.read("@{}"));
329 BOOST_CHECK(!v.read("{} garbage"));
330 BOOST_CHECK(!v.read("[]{}"));
331 BOOST_CHECK(!v.read("{}[]"));
332 BOOST_CHECK(!v.read("{} 42"));
333 }
334
335 BOOST_AUTO_TEST_SUITE_END()
336
337