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