Bitcoin Core 22.99.0
P2P Digital Currency
object.cpp
Go to the documentation of this file.
1// Copyright (c) 2014 BitPay Inc.
2// Copyright (c) 2014-2016 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 <stdint.h>
7#include <vector>
8#include <string>
9#include <map>
10#include <cassert>
11#include <stdexcept>
12#include <univalue.h>
13
14#define BOOST_FIXTURE_TEST_SUITE(a, b)
15#define BOOST_AUTO_TEST_CASE(funcName) void funcName()
16#define BOOST_AUTO_TEST_SUITE_END()
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 & e) { \
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
36BOOST_FIXTURE_TEST_SUITE(univalue_tests, BasicTestingSetup)
37
38BOOST_AUTO_TEST_CASE(univalue_constructor)
39{
40 UniValue v1;
41 BOOST_CHECK(v1.isNull());
42
43 UniValue v2(UniValue::VSTR);
44 BOOST_CHECK(v2.isStr());
45
46 UniValue v3(UniValue::VSTR, "foo");
47 BOOST_CHECK(v3.isStr());
48 BOOST_CHECK_EQUAL(v3.getValStr(), "foo");
49
50 UniValue numTest;
51 BOOST_CHECK(numTest.setNumStr("82"));
52 BOOST_CHECK(numTest.isNum());
53 BOOST_CHECK_EQUAL(numTest.getValStr(), "82");
54
55 uint64_t vu64 = 82;
56 UniValue v4(vu64);
57 BOOST_CHECK(v4.isNum());
58 BOOST_CHECK_EQUAL(v4.getValStr(), "82");
59
60 int64_t vi64 = -82;
61 UniValue v5(vi64);
62 BOOST_CHECK(v5.isNum());
63 BOOST_CHECK_EQUAL(v5.getValStr(), "-82");
64
65 int vi = -688;
66 UniValue v6(vi);
67 BOOST_CHECK(v6.isNum());
68 BOOST_CHECK_EQUAL(v6.getValStr(), "-688");
69
70 double vd = -7.21;
71 UniValue v7(vd);
72 BOOST_CHECK(v7.isNum());
73 BOOST_CHECK_EQUAL(v7.getValStr(), "-7.21");
74
75 std::string vs("yawn");
76 UniValue v8(vs);
77 BOOST_CHECK(v8.isStr());
78 BOOST_CHECK_EQUAL(v8.getValStr(), "yawn");
79
80 const char *vcs = "zappa";
81 UniValue v9(vcs);
82 BOOST_CHECK(v9.isStr());
83 BOOST_CHECK_EQUAL(v9.getValStr(), "zappa");
84}
85
86BOOST_AUTO_TEST_CASE(univalue_typecheck)
87{
88 UniValue v1;
89 BOOST_CHECK(v1.setNumStr("1"));
90 BOOST_CHECK(v1.isNum());
91 BOOST_CHECK_THROW(v1.get_bool(), std::runtime_error);
92
93 UniValue v2;
94 BOOST_CHECK(v2.setBool(true));
95 BOOST_CHECK_EQUAL(v2.get_bool(), true);
96 BOOST_CHECK_THROW(v2.get_int(), std::runtime_error);
97
98 UniValue v3;
99 BOOST_CHECK(v3.setNumStr("32482348723847471234"));
100 BOOST_CHECK_THROW(v3.get_int64(), std::runtime_error);
101 BOOST_CHECK(v3.setNumStr("1000"));
102 BOOST_CHECK_EQUAL(v3.get_int64(), 1000);
103
104 UniValue v4;
105 BOOST_CHECK(v4.setNumStr("2147483648"));
106 BOOST_CHECK_EQUAL(v4.get_int64(), 2147483648);
107 BOOST_CHECK_THROW(v4.get_int(), std::runtime_error);
108 BOOST_CHECK(v4.setNumStr("1000"));
109 BOOST_CHECK_EQUAL(v4.get_int(), 1000);
110 BOOST_CHECK_THROW(v4.get_str(), std::runtime_error);
111 BOOST_CHECK_EQUAL(v4.get_real(), 1000);
112 BOOST_CHECK_THROW(v4.get_array(), std::runtime_error);
113 BOOST_CHECK_THROW(v4.getKeys(), std::runtime_error);
114 BOOST_CHECK_THROW(v4.getValues(), std::runtime_error);
115 BOOST_CHECK_THROW(v4.get_obj(), std::runtime_error);
116
117 UniValue v5;
118 BOOST_CHECK(v5.read("[true, 10]"));
119 BOOST_CHECK_NO_THROW(v5.get_array());
120 std::vector<UniValue> vals = v5.getValues();
121 BOOST_CHECK_THROW(vals[0].get_int(), std::runtime_error);
122 BOOST_CHECK_EQUAL(vals[0].get_bool(), true);
123
124 BOOST_CHECK_EQUAL(vals[1].get_int(), 10);
125 BOOST_CHECK_THROW(vals[1].get_bool(), std::runtime_error);
126}
127
128BOOST_AUTO_TEST_CASE(univalue_set)
129{
130 UniValue v(UniValue::VSTR, "foo");
131 v.clear();
132 BOOST_CHECK(v.isNull());
133 BOOST_CHECK_EQUAL(v.getValStr(), "");
134
135 BOOST_CHECK(v.setObject());
136 BOOST_CHECK(v.isObject());
137 BOOST_CHECK_EQUAL(v.size(), 0);
138 BOOST_CHECK_EQUAL(v.getType(), UniValue::VOBJ);
139 BOOST_CHECK(v.empty());
140
141 BOOST_CHECK(v.setArray());
142 BOOST_CHECK(v.isArray());
143 BOOST_CHECK_EQUAL(v.size(), 0);
144
145 BOOST_CHECK(v.setStr("zum"));
146 BOOST_CHECK(v.isStr());
147 BOOST_CHECK_EQUAL(v.getValStr(), "zum");
148
149 BOOST_CHECK(v.setFloat(-1.01));
150 BOOST_CHECK(v.isNum());
151 BOOST_CHECK_EQUAL(v.getValStr(), "-1.01");
152
153 BOOST_CHECK(v.setInt((int)1023));
154 BOOST_CHECK(v.isNum());
155 BOOST_CHECK_EQUAL(v.getValStr(), "1023");
156
157 BOOST_CHECK(v.setInt((int64_t)-1023LL));
158 BOOST_CHECK(v.isNum());
159 BOOST_CHECK_EQUAL(v.getValStr(), "-1023");
160
161 BOOST_CHECK(v.setInt((uint64_t)1023ULL));
162 BOOST_CHECK(v.isNum());
163 BOOST_CHECK_EQUAL(v.getValStr(), "1023");
164
165 BOOST_CHECK(v.setNumStr("-688"));
166 BOOST_CHECK(v.isNum());
167 BOOST_CHECK_EQUAL(v.getValStr(), "-688");
168
169 BOOST_CHECK(v.setBool(false));
170 BOOST_CHECK_EQUAL(v.isBool(), true);
171 BOOST_CHECK_EQUAL(v.isTrue(), false);
172 BOOST_CHECK_EQUAL(v.isFalse(), true);
173 BOOST_CHECK_EQUAL(v.getBool(), false);
174
175 BOOST_CHECK(v.setBool(true));
176 BOOST_CHECK_EQUAL(v.isBool(), true);
177 BOOST_CHECK_EQUAL(v.isTrue(), true);
178 BOOST_CHECK_EQUAL(v.isFalse(), false);
179 BOOST_CHECK_EQUAL(v.getBool(), true);
180
181 BOOST_CHECK(!v.setNumStr("zombocom"));
182
183 BOOST_CHECK(v.setNull());
184 BOOST_CHECK(v.isNull());
185}
186
187BOOST_AUTO_TEST_CASE(univalue_array)
188{
189 UniValue arr(UniValue::VARR);
190
191 UniValue v((int64_t)1023LL);
192 BOOST_CHECK(arr.push_back(v));
193
194 std::string vStr("zippy");
195 BOOST_CHECK(arr.push_back(vStr));
196
197 const char *s = "pippy";
198 BOOST_CHECK(arr.push_back(s));
199
200 std::vector<UniValue> vec;
201 v.setStr("boing");
202 vec.push_back(v);
203
204 v.setStr("going");
205 vec.push_back(v);
206
207 BOOST_CHECK(arr.push_backV(vec));
208
209 BOOST_CHECK(arr.push_back((uint64_t) 400ULL));
210 BOOST_CHECK(arr.push_back((int64_t) -400LL));
211 BOOST_CHECK(arr.push_back((int) -401));
212 BOOST_CHECK(arr.push_back(-40.1));
213 BOOST_CHECK(arr.push_back(true));
214
215 BOOST_CHECK_EQUAL(arr.empty(), false);
216 BOOST_CHECK_EQUAL(arr.size(), 10);
217
218 BOOST_CHECK_EQUAL(arr[0].getValStr(), "1023");
219 BOOST_CHECK_EQUAL(arr[0].getType(), UniValue::VNUM);
220 BOOST_CHECK_EQUAL(arr[1].getValStr(), "zippy");
221 BOOST_CHECK_EQUAL(arr[1].getType(), UniValue::VSTR);
222 BOOST_CHECK_EQUAL(arr[2].getValStr(), "pippy");
223 BOOST_CHECK_EQUAL(arr[2].getType(), UniValue::VSTR);
224 BOOST_CHECK_EQUAL(arr[3].getValStr(), "boing");
225 BOOST_CHECK_EQUAL(arr[3].getType(), UniValue::VSTR);
226 BOOST_CHECK_EQUAL(arr[4].getValStr(), "going");
227 BOOST_CHECK_EQUAL(arr[4].getType(), UniValue::VSTR);
228 BOOST_CHECK_EQUAL(arr[5].getValStr(), "400");
229 BOOST_CHECK_EQUAL(arr[5].getType(), UniValue::VNUM);
230 BOOST_CHECK_EQUAL(arr[6].getValStr(), "-400");
231 BOOST_CHECK_EQUAL(arr[6].getType(), UniValue::VNUM);
232 BOOST_CHECK_EQUAL(arr[7].getValStr(), "-401");
233 BOOST_CHECK_EQUAL(arr[7].getType(), UniValue::VNUM);
234 BOOST_CHECK_EQUAL(arr[8].getValStr(), "-40.1");
235 BOOST_CHECK_EQUAL(arr[8].getType(), UniValue::VNUM);
236 BOOST_CHECK_EQUAL(arr[9].getValStr(), "1");
237 BOOST_CHECK_EQUAL(arr[9].getType(), UniValue::VBOOL);
238
239 BOOST_CHECK_EQUAL(arr[999].getValStr(), "");
240
241 arr.clear();
242 BOOST_CHECK(arr.empty());
243 BOOST_CHECK_EQUAL(arr.size(), 0);
244}
245
246BOOST_AUTO_TEST_CASE(univalue_object)
247{
248 UniValue obj(UniValue::VOBJ);
249 std::string strKey, strVal;
250 UniValue v;
251
252 strKey = "age";
253 v.setInt(100);
254 BOOST_CHECK(obj.pushKV(strKey, v));
255
256 strKey = "first";
257 strVal = "John";
258 BOOST_CHECK(obj.pushKV(strKey, strVal));
259
260 strKey = "last";
261 const char *cVal = "Smith";
262 BOOST_CHECK(obj.pushKV(strKey, cVal));
263
264 strKey = "distance";
265 BOOST_CHECK(obj.pushKV(strKey, (int64_t) 25));
266
267 strKey = "time";
268 BOOST_CHECK(obj.pushKV(strKey, (uint64_t) 3600));
269
270 strKey = "calories";
271 BOOST_CHECK(obj.pushKV(strKey, (int) 12));
272
273 strKey = "temperature";
274 BOOST_CHECK(obj.pushKV(strKey, (double) 90.012));
275
276 strKey = "moon";
277 BOOST_CHECK(obj.pushKV(strKey, true));
278
279 strKey = "spoon";
280 BOOST_CHECK(obj.pushKV(strKey, false));
281
282 UniValue obj2(UniValue::VOBJ);
283 BOOST_CHECK(obj2.pushKV("cat1", 9000));
284 BOOST_CHECK(obj2.pushKV("cat2", 12345));
285
286 BOOST_CHECK(obj.pushKVs(obj2));
287
288 BOOST_CHECK_EQUAL(obj.empty(), false);
289 BOOST_CHECK_EQUAL(obj.size(), 11);
290
291 BOOST_CHECK_EQUAL(obj["age"].getValStr(), "100");
292 BOOST_CHECK_EQUAL(obj["first"].getValStr(), "John");
293 BOOST_CHECK_EQUAL(obj["last"].getValStr(), "Smith");
294 BOOST_CHECK_EQUAL(obj["distance"].getValStr(), "25");
295 BOOST_CHECK_EQUAL(obj["time"].getValStr(), "3600");
296 BOOST_CHECK_EQUAL(obj["calories"].getValStr(), "12");
297 BOOST_CHECK_EQUAL(obj["temperature"].getValStr(), "90.012");
298 BOOST_CHECK_EQUAL(obj["moon"].getValStr(), "1");
299 BOOST_CHECK_EQUAL(obj["spoon"].getValStr(), "");
300 BOOST_CHECK_EQUAL(obj["cat1"].getValStr(), "9000");
301 BOOST_CHECK_EQUAL(obj["cat2"].getValStr(), "12345");
302
303 BOOST_CHECK_EQUAL(obj["nyuknyuknyuk"].getValStr(), "");
304
305 BOOST_CHECK(obj.exists("age"));
306 BOOST_CHECK(obj.exists("first"));
307 BOOST_CHECK(obj.exists("last"));
308 BOOST_CHECK(obj.exists("distance"));
309 BOOST_CHECK(obj.exists("time"));
310 BOOST_CHECK(obj.exists("calories"));
311 BOOST_CHECK(obj.exists("temperature"));
312 BOOST_CHECK(obj.exists("moon"));
313 BOOST_CHECK(obj.exists("spoon"));
314 BOOST_CHECK(obj.exists("cat1"));
315 BOOST_CHECK(obj.exists("cat2"));
316
317 BOOST_CHECK(!obj.exists("nyuknyuknyuk"));
318
319 std::map<std::string, UniValue::VType> objTypes;
320 objTypes["age"] = UniValue::VNUM;
321 objTypes["first"] = UniValue::VSTR;
322 objTypes["last"] = UniValue::VSTR;
323 objTypes["distance"] = UniValue::VNUM;
324 objTypes["time"] = UniValue::VNUM;
325 objTypes["calories"] = UniValue::VNUM;
326 objTypes["temperature"] = UniValue::VNUM;
327 objTypes["moon"] = UniValue::VBOOL;
328 objTypes["spoon"] = UniValue::VBOOL;
329 objTypes["cat1"] = UniValue::VNUM;
330 objTypes["cat2"] = UniValue::VNUM;
331 BOOST_CHECK(obj.checkObject(objTypes));
332
333 objTypes["cat2"] = UniValue::VSTR;
334 BOOST_CHECK(!obj.checkObject(objTypes));
335
336 obj.clear();
337 BOOST_CHECK(obj.empty());
338 BOOST_CHECK_EQUAL(obj.size(), 0);
339 BOOST_CHECK_EQUAL(obj.getType(), UniValue::VNULL);
340
341 BOOST_CHECK_EQUAL(obj.setObject(), true);
342 UniValue uv;
343 uv.setInt(42);
344 obj.__pushKV("age", uv);
345 BOOST_CHECK_EQUAL(obj.size(), 1);
346 BOOST_CHECK_EQUAL(obj["age"].getValStr(), "42");
347
348 uv.setInt(43);
349 obj.pushKV("age", uv);
350 BOOST_CHECK_EQUAL(obj.size(), 1);
351 BOOST_CHECK_EQUAL(obj["age"].getValStr(), "43");
352
353 obj.pushKV("name", "foo bar");
354
355 std::map<std::string,UniValue> kv;
356 obj.getObjMap(kv);
357 BOOST_CHECK_EQUAL(kv["age"].getValStr(), "43");
358 BOOST_CHECK_EQUAL(kv["name"].getValStr(), "foo bar");
359
360}
361
362static const char *json1 =
363"[1.10000000,{\"key1\":\"str\\u0000\",\"key2\":800,\"key3\":{\"name\":\"martian http://test.com\"}}]";
364
365BOOST_AUTO_TEST_CASE(univalue_readwrite)
366{
367 UniValue v;
368 BOOST_CHECK(v.read(json1));
369
370 std::string strJson1(json1);
371 BOOST_CHECK(v.read(strJson1));
372
373 BOOST_CHECK(v.isArray());
374 BOOST_CHECK_EQUAL(v.size(), 2);
375
376 BOOST_CHECK_EQUAL(v[0].getValStr(), "1.10000000");
377
378 UniValue obj = v[1];
379 BOOST_CHECK(obj.isObject());
380 BOOST_CHECK_EQUAL(obj.size(), 3);
381
382 BOOST_CHECK(obj["key1"].isStr());
383 std::string correctValue("str");
384 correctValue.push_back('\0');
385 BOOST_CHECK_EQUAL(obj["key1"].getValStr(), correctValue);
386 BOOST_CHECK(obj["key2"].isNum());
387 BOOST_CHECK_EQUAL(obj["key2"].getValStr(), "800");
388 BOOST_CHECK(obj["key3"].isObject());
389
390 BOOST_CHECK_EQUAL(strJson1, v.write());
391
392 /* Check for (correctly reporting) a parsing error if the initial
393 JSON construct is followed by more stuff. Note that whitespace
394 is, of course, exempt. */
395
396 BOOST_CHECK(v.read(" {}\n "));
397 BOOST_CHECK(v.isObject());
398 BOOST_CHECK(v.read(" []\n "));
399 BOOST_CHECK(v.isArray());
400
401 BOOST_CHECK(!v.read("@{}"));
402 BOOST_CHECK(!v.read("{} garbage"));
403 BOOST_CHECK(!v.read("[]{}"));
404 BOOST_CHECK(!v.read("{}[]"));
405 BOOST_CHECK(!v.read("{} 42"));
406}
407
408BOOST_AUTO_TEST_SUITE_END()
409
410int main (int argc, char *argv[])
411{
412 univalue_constructor();
413 univalue_typecheck();
414 univalue_set();
415 univalue_array();
416 univalue_object();
417 univalue_readwrite();
418 return 0;
419}
420
UniValue::setArray
bool setArray()
Definition: univalue.cpp:94
UniValue::setNumStr
bool setNumStr(const std::string &val)
Definition: univalue.cpp:46
UniValue::get_str
const std::string & get_str() const
Definition: univalue_get.cpp:98
UniValue::setObject
bool setObject()
Definition: univalue.cpp:101
UniValue::checkObject
bool checkObject(const std::map< std::string, UniValue::VType > &memberTypes) const
Definition: univalue.cpp:179
UniValue::isTrue
bool isTrue() const
Definition: univalue.h:76
UniValue::isArray
bool isArray() const
Definition: univalue.h:81
UniValue::getType
enum VType getType() const
Definition: univalue.h:62
UniValue::VNULL
@ VNULL
Definition: univalue.h:19
UniValue::VOBJ
@ VOBJ
Definition: univalue.h:19
UniValue::VSTR
@ VSTR
Definition: univalue.h:19
UniValue::VARR
@ VARR
Definition: univalue.h:19
UniValue::VNUM
@ VNUM
Definition: univalue.h:19
UniValue::VBOOL
@ VBOOL
Definition: univalue.h:19
UniValue::get_int64
int64_t get_int64() const
Definition: univalue_get.cpp:115
UniValue::write
std::string write(unsigned int prettyIndent=0, unsigned int indentLevel=0) const
Definition: univalue_write.cpp:28
UniValue::isNull
bool isNull() const
Definition: univalue.h:75
UniValue::clear
void clear()
Definition: univalue.cpp:15
UniValue::getValStr
const std::string & getValStr() const
Definition: univalue.h:63
UniValue::get_obj
const UniValue & get_obj() const
Definition: univalue_get.cpp:135
UniValue::__pushKV
void __pushKV(const std::string &key, const UniValue &val)
Definition: univalue.cpp:127
UniValue::size
size_t size() const
Definition: univalue.h:66
UniValue::getValues
const std::vector< UniValue > & getValues() const
Definition: univalue_get.cpp:84
UniValue::getKeys
const std::vector< std::string > & getKeys() const
Definition: univalue_get.cpp:77
UniValue::empty
bool empty() const
Definition: univalue.h:64
UniValue::pushKVs
bool pushKVs(const UniValue &obj)
Definition: univalue.cpp:146
UniValue::isStr
bool isStr() const
Definition: univalue.h:79
UniValue::push_back
bool push_back(const UniValue &val)
Definition: univalue.cpp:108
UniValue::setNull
bool setNull()
Definition: univalue.cpp:23
UniValue::isBool
bool isBool() const
Definition: univalue.h:78
UniValue::setInt
bool setInt(uint64_t val)
Definition: univalue.cpp:57
UniValue::get_array
const UniValue & get_array() const
Definition: univalue_get.cpp:142
UniValue::exists
bool exists(const std::string &key) const
Definition: univalue.h:73
UniValue::pushKV
bool pushKV(const std::string &key, const UniValue &val)
Definition: univalue.cpp:133
UniValue::setStr
bool setStr(const std::string &val)
Definition: univalue.cpp:86
UniValue::isNum
bool isNum() const
Definition: univalue.h:80
UniValue::getBool
bool getBool() const
Definition: univalue.h:68
UniValue::push_backV
bool push_backV(const std::vector< UniValue > &vec)
Definition: univalue.cpp:117
UniValue::getObjMap
void getObjMap(std::map< std::string, UniValue > &kv) const
Definition: univalue.cpp:157
UniValue::get_real
double get_real() const
Definition: univalue_get.cpp:125
UniValue::isFalse
bool isFalse() const
Definition: univalue.h:77
UniValue::get_bool
bool get_bool() const
Definition: univalue_get.cpp:91
UniValue::read
bool read(const char *raw, size_t len)
Definition: univalue_read.cpp:259
UniValue::isObject
bool isObject() const
Definition: univalue.h:82
UniValue::get_int
int get_int() const
Definition: univalue_get.cpp:105
UniValue::setFloat
bool setFloat(double val)
Definition: univalue.cpp:75
UniValue::setBool
bool setBool(bool val)
Definition: univalue.cpp:29
main
int main(int argc, char *argv[])
Definition: object.cpp:410
BOOST_CHECK_THROW
#define BOOST_CHECK_THROW(stmt, excMatch)
Definition: object.cpp:19
json1
static const char * json1
Definition: object.cpp:362
BOOST_AUTO_TEST_SUITE_END
#define BOOST_AUTO_TEST_SUITE_END()
Definition: object.cpp:16
BOOST_FIXTURE_TEST_SUITE
#define BOOST_FIXTURE_TEST_SUITE(a, b)
Definition: object.cpp:14
BOOST_CHECK_EQUAL
#define BOOST_CHECK_EQUAL(v1, v2)
Definition: object.cpp:18
BOOST_AUTO_TEST_CASE
#define BOOST_AUTO_TEST_CASE(funcName)
Definition: object.cpp:15
BOOST_CHECK_NO_THROW
#define BOOST_CHECK_NO_THROW(stmt)
Definition: object.cpp:28
BOOST_CHECK
#define BOOST_CHECK(expr)
Definition: object.cpp:17
BasicTestingSetup
Basic testing setup.
Definition: setup_common.h:76
Generated on Mon Nov 8 2021 14:20:07 for Bitcoin Core by doxygen 1.9.2