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