Browse Source
This merge commit bumps the univalue subtree and also updates the whitespace for some failing tests.0.16
MarcoFalke
7 years ago
31 changed files with 851 additions and 297 deletions
@ -1,7 +0,0 @@
@@ -1,7 +0,0 @@
|
||||
|
||||
UniValue |
||||
|
||||
A universal value object, with JSON encoding (output) and decoding (input). |
||||
|
||||
Built as a single dynamic RAII C++ object class, and no templates. |
||||
|
||||
@ -0,0 +1,32 @@
@@ -0,0 +1,32 @@
|
||||
|
||||
# UniValue |
||||
|
||||
## Summary |
||||
|
||||
A universal value class, with JSON encoding and decoding. |
||||
|
||||
UniValue is an abstract data type that may be a null, boolean, string, |
||||
number, array container, or a key/value dictionary container, nested to |
||||
an arbitrary depth. |
||||
|
||||
This class is aligned with the JSON standard, [RFC |
||||
7159](https://tools.ietf.org/html/rfc7159.html). |
||||
|
||||
## Installation |
||||
|
||||
This project is a standard GNU |
||||
[autotools](https://www.gnu.org/software/automake/manual/html_node/Autotools-Introduction.html) |
||||
project. Build and install instructions are available in the `INSTALL` |
||||
file provided with GNU autotools. |
||||
|
||||
``` |
||||
$ ./autogen.sh |
||||
$ ./configure |
||||
$ make |
||||
``` |
||||
|
||||
## Design |
||||
|
||||
UniValue provides a single dynamic RAII C++ object class, |
||||
and minimizes template use (contra json_spirit). |
||||
|
||||
@ -0,0 +1,147 @@
@@ -0,0 +1,147 @@
|
||||
// Copyright 2014 BitPay Inc.
|
||||
// Copyright 2015 Bitcoin Core Developers
|
||||
// Distributed under the MIT software license, see the accompanying
|
||||
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
|
||||
#include <stdint.h> |
||||
#include <errno.h> |
||||
#include <string.h> |
||||
#include <stdlib.h> |
||||
#include <stdexcept> |
||||
#include <vector> |
||||
#include <limits> |
||||
#include <string> |
||||
|
||||
#include "univalue.h" |
||||
|
||||
namespace |
||||
{ |
||||
static bool ParsePrechecks(const std::string& str) |
||||
{ |
||||
if (str.empty()) // No empty string allowed
|
||||
return false; |
||||
if (str.size() >= 1 && (json_isspace(str[0]) || json_isspace(str[str.size()-1]))) // No padding allowed
|
||||
return false; |
||||
if (str.size() != strlen(str.c_str())) // No embedded NUL characters allowed
|
||||
return false; |
||||
return true; |
||||
} |
||||
|
||||
bool ParseInt32(const std::string& str, int32_t *out) |
||||
{ |
||||
if (!ParsePrechecks(str)) |
||||
return false; |
||||
char *endp = NULL; |
||||
errno = 0; // strtol will not set errno if valid
|
||||
long int n = strtol(str.c_str(), &endp, 10); |
||||
if(out) *out = (int32_t)n; |
||||
// Note that strtol returns a *long int*, so even if strtol doesn't report a over/underflow
|
||||
// we still have to check that the returned value is within the range of an *int32_t*. On 64-bit
|
||||
// platforms the size of these types may be different.
|
||||
return endp && *endp == 0 && !errno && |
||||
n >= std::numeric_limits<int32_t>::min() && |
||||
n <= std::numeric_limits<int32_t>::max(); |
||||
} |
||||
|
||||
bool ParseInt64(const std::string& str, int64_t *out) |
||||
{ |
||||
if (!ParsePrechecks(str)) |
||||
return false; |
||||
char *endp = NULL; |
||||
errno = 0; // strtoll will not set errno if valid
|
||||
long long int n = strtoll(str.c_str(), &endp, 10); |
||||
if(out) *out = (int64_t)n; |
||||
// Note that strtoll returns a *long long int*, so even if strtol doesn't report a over/underflow
|
||||
// we still have to check that the returned value is within the range of an *int64_t*.
|
||||
return endp && *endp == 0 && !errno && |
||||
n >= std::numeric_limits<int64_t>::min() && |
||||
n <= std::numeric_limits<int64_t>::max(); |
||||
} |
||||
|
||||
bool ParseDouble(const std::string& str, double *out) |
||||
{ |
||||
if (!ParsePrechecks(str)) |
||||
return false; |
||||
if (str.size() >= 2 && str[0] == '0' && str[1] == 'x') // No hexadecimal floats allowed
|
||||
return false; |
||||
std::istringstream text(str); |
||||
text.imbue(std::locale::classic()); |
||||
double result; |
||||
text >> result; |
||||
if(out) *out = result; |
||||
return text.eof() && !text.fail(); |
||||
} |
||||
} |
||||
|
||||
const std::vector<std::string>& UniValue::getKeys() const |
||||
{ |
||||
if (typ != VOBJ) |
||||
throw std::runtime_error("JSON value is not an object as expected"); |
||||
return keys; |
||||
} |
||||
|
||||
const std::vector<UniValue>& UniValue::getValues() const |
||||
{ |
||||
if (typ != VOBJ && typ != VARR) |
||||
throw std::runtime_error("JSON value is not an object or array as expected"); |
||||
return values; |
||||
} |
||||
|
||||
bool UniValue::get_bool() const |
||||
{ |
||||
if (typ != VBOOL) |
||||
throw std::runtime_error("JSON value is not a boolean as expected"); |
||||
return getBool(); |
||||
} |
||||
|
||||
const std::string& UniValue::get_str() const |
||||
{ |
||||
if (typ != VSTR) |
||||
throw std::runtime_error("JSON value is not a string as expected"); |
||||
return getValStr(); |
||||
} |
||||
|
||||
int UniValue::get_int() const |
||||
{ |
||||
if (typ != VNUM) |
||||
throw std::runtime_error("JSON value is not an integer as expected"); |
||||
int32_t retval; |
||||
if (!ParseInt32(getValStr(), &retval)) |
||||
throw std::runtime_error("JSON integer out of range"); |
||||
return retval; |
||||
} |
||||
|
||||
int64_t UniValue::get_int64() const |
||||
{ |
||||
if (typ != VNUM) |
||||
throw std::runtime_error("JSON value is not an integer as expected"); |
||||
int64_t retval; |
||||
if (!ParseInt64(getValStr(), &retval)) |
||||
throw std::runtime_error("JSON integer out of range"); |
||||
return retval; |
||||
} |
||||
|
||||
double UniValue::get_real() const |
||||
{ |
||||
if (typ != VNUM) |
||||
throw std::runtime_error("JSON value is not a number as expected"); |
||||
double retval; |
||||
if (!ParseDouble(getValStr(), &retval)) |
||||
throw std::runtime_error("JSON double out of range"); |
||||
return retval; |
||||
} |
||||
|
||||
const UniValue& UniValue::get_obj() const |
||||
{ |
||||
if (typ != VOBJ) |
||||
throw std::runtime_error("JSON value is not an object as expected"); |
||||
return *this; |
||||
} |
||||
|
||||
const UniValue& UniValue::get_array() const |
||||
{ |
||||
if (typ != VARR) |
||||
throw std::runtime_error("JSON value is not an array as expected"); |
||||
return *this; |
||||
} |
||||
|
||||
@ -1,4 +1,8 @@
@@ -1,4 +1,8 @@
|
||||
|
||||
object |
||||
unitester |
||||
test_json |
||||
no_nul |
||||
|
||||
*.trs |
||||
*.log |
||||
|
||||
@ -1 +1 @@
@@ -1 +1 @@
|
||||
"A JSON payload should be an object or array, not a string." |
||||
"This is a string that never ends, yes it goes on and on, my friends. |
||||
|
||||
Binary file not shown.
@ -0,0 +1 @@
@@ -0,0 +1 @@
|
||||
"This file ends without a newline or close-quote. |
||||
@ -0,0 +1,8 @@
@@ -0,0 +1,8 @@
|
||||
#include "univalue.h" |
||||
|
||||
int main (int argc, char *argv[]) |
||||
{ |
||||
char buf[] = "___[1,2,3]___"; |
||||
UniValue val; |
||||
return val.read(buf + 3, 7) ? 0 : 1; |
||||
} |
||||
@ -0,0 +1,395 @@
@@ -0,0 +1,395 @@
|
||||
// Copyright (c) 2014 BitPay Inc.
|
||||
// Copyright (c) 2014-2016 The Bitcoin Core developers
|
||||
// Distributed under the MIT software license, see the accompanying
|
||||
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
|
||||
#include <stdint.h> |
||||
#include <vector> |
||||
#include <string> |
||||
#include <map> |
||||
#include <cassert> |
||||
#include <stdexcept> |
||||
#include <univalue.h> |
||||
|
||||
#define BOOST_FIXTURE_TEST_SUITE(a, b) |
||||
#define BOOST_AUTO_TEST_CASE(funcName) void funcName() |
||||
#define BOOST_AUTO_TEST_SUITE_END() |
||||
#define BOOST_CHECK(expr) assert(expr) |
||||
#define BOOST_CHECK_EQUAL(v1, v2) assert((v1) == (v2)) |
||||
#define BOOST_CHECK_THROW(stmt, excMatch) { \ |
||||
try { \ |
||||
(stmt); \ |
||||
} catch (excMatch & e) { \ |
||||
} catch (...) { \ |
||||
assert(0); \ |
||||
} \ |
||||
} |
||||
#define BOOST_CHECK_NO_THROW(stmt) { \ |
||||
try { \ |
||||
(stmt); \ |
||||
} catch (...) { \ |
||||
assert(0); \ |
||||
} \ |
||||
} |
||||
|
||||
BOOST_FIXTURE_TEST_SUITE(univalue_tests, BasicTestingSetup) |
||||
|
||||
BOOST_AUTO_TEST_CASE(univalue_constructor) |
||||
{ |
||||
UniValue v1; |
||||
BOOST_CHECK(v1.isNull()); |
||||
|
||||
UniValue v2(UniValue::VSTR); |
||||
BOOST_CHECK(v2.isStr()); |
||||
|
||||
UniValue v3(UniValue::VSTR, "foo"); |
||||
BOOST_CHECK(v3.isStr()); |
||||
BOOST_CHECK_EQUAL(v3.getValStr(), "foo"); |
||||
|
||||
UniValue numTest; |
||||
BOOST_CHECK(numTest.setNumStr("82")); |
||||
BOOST_CHECK(numTest.isNum()); |
||||
BOOST_CHECK_EQUAL(numTest.getValStr(), "82"); |
||||
|
||||
uint64_t vu64 = 82; |
||||
UniValue v4(vu64); |
||||
BOOST_CHECK(v4.isNum()); |
||||
BOOST_CHECK_EQUAL(v4.getValStr(), "82"); |
||||
|
||||
int64_t vi64 = -82; |
||||
UniValue v5(vi64); |
||||
BOOST_CHECK(v5.isNum()); |
||||
BOOST_CHECK_EQUAL(v5.getValStr(), "-82"); |
||||
|
||||
int vi = -688; |
||||
UniValue v6(vi); |
||||
BOOST_CHECK(v6.isNum()); |
||||
BOOST_CHECK_EQUAL(v6.getValStr(), "-688"); |
||||
|
||||
double vd = -7.21; |
||||
UniValue v7(vd); |
||||
BOOST_CHECK(v7.isNum()); |
||||
BOOST_CHECK_EQUAL(v7.getValStr(), "-7.21"); |
||||
|
||||
std::string vs("yawn"); |
||||
UniValue v8(vs); |
||||
BOOST_CHECK(v8.isStr()); |
||||
BOOST_CHECK_EQUAL(v8.getValStr(), "yawn"); |
||||
|
||||
const char *vcs = "zappa"; |
||||
UniValue v9(vcs); |
||||
BOOST_CHECK(v9.isStr()); |
||||
BOOST_CHECK_EQUAL(v9.getValStr(), "zappa"); |
||||
} |
||||
|
||||
BOOST_AUTO_TEST_CASE(univalue_typecheck) |
||||
{ |
||||
UniValue v1; |
||||
BOOST_CHECK(v1.setNumStr("1")); |
||||
BOOST_CHECK(v1.isNum()); |
||||
BOOST_CHECK_THROW(v1.get_bool(), std::runtime_error); |
||||
|
||||
UniValue v2; |
||||
BOOST_CHECK(v2.setBool(true)); |
||||
BOOST_CHECK_EQUAL(v2.get_bool(), true); |
||||
BOOST_CHECK_THROW(v2.get_int(), std::runtime_error); |
||||
|
||||
UniValue v3; |
||||
BOOST_CHECK(v3.setNumStr("32482348723847471234")); |
||||
BOOST_CHECK_THROW(v3.get_int64(), std::runtime_error); |
||||
BOOST_CHECK(v3.setNumStr("1000")); |
||||
BOOST_CHECK_EQUAL(v3.get_int64(), 1000); |
||||
|
||||
UniValue v4; |
||||
BOOST_CHECK(v4.setNumStr("2147483648")); |
||||
BOOST_CHECK_EQUAL(v4.get_int64(), 2147483648); |
||||
BOOST_CHECK_THROW(v4.get_int(), std::runtime_error); |
||||
BOOST_CHECK(v4.setNumStr("1000")); |
||||
BOOST_CHECK_EQUAL(v4.get_int(), 1000); |
||||
BOOST_CHECK_THROW(v4.get_str(), std::runtime_error); |
||||
BOOST_CHECK_EQUAL(v4.get_real(), 1000); |
||||
BOOST_CHECK_THROW(v4.get_array(), std::runtime_error); |
||||
BOOST_CHECK_THROW(v4.getKeys(), std::runtime_error); |
||||
BOOST_CHECK_THROW(v4.getValues(), std::runtime_error); |
||||
BOOST_CHECK_THROW(v4.get_obj(), std::runtime_error); |
||||
|
||||
UniValue v5; |
||||
BOOST_CHECK(v5.read("[true, 10]")); |
||||
BOOST_CHECK_NO_THROW(v5.get_array()); |
||||
std::vector<UniValue> vals = v5.getValues(); |
||||
BOOST_CHECK_THROW(vals[0].get_int(), std::runtime_error); |
||||
BOOST_CHECK_EQUAL(vals[0].get_bool(), true); |
||||
|
||||
BOOST_CHECK_EQUAL(vals[1].get_int(), 10); |
||||
BOOST_CHECK_THROW(vals[1].get_bool(), std::runtime_error); |
||||
} |
||||
|
||||
BOOST_AUTO_TEST_CASE(univalue_set) |
||||
{ |
||||
UniValue v(UniValue::VSTR, "foo"); |
||||
v.clear(); |
||||
BOOST_CHECK(v.isNull()); |
||||
BOOST_CHECK_EQUAL(v.getValStr(), ""); |
||||
|
||||
BOOST_CHECK(v.setObject()); |
||||
BOOST_CHECK(v.isObject()); |
||||
BOOST_CHECK_EQUAL(v.size(), 0); |
||||
BOOST_CHECK_EQUAL(v.getType(), UniValue::VOBJ); |
||||
BOOST_CHECK(v.empty()); |
||||
|
||||
BOOST_CHECK(v.setArray()); |
||||
BOOST_CHECK(v.isArray()); |
||||
BOOST_CHECK_EQUAL(v.size(), 0); |
||||
|
||||
BOOST_CHECK(v.setStr("zum")); |
||||
BOOST_CHECK(v.isStr()); |
||||
BOOST_CHECK_EQUAL(v.getValStr(), "zum"); |
||||
|
||||
BOOST_CHECK(v.setFloat(-1.01)); |
||||
BOOST_CHECK(v.isNum()); |
||||
BOOST_CHECK_EQUAL(v.getValStr(), "-1.01"); |
||||
|
||||
BOOST_CHECK(v.setInt((int)1023)); |
||||
BOOST_CHECK(v.isNum()); |
||||
BOOST_CHECK_EQUAL(v.getValStr(), "1023"); |
||||
|
||||
BOOST_CHECK(v.setInt((int64_t)-1023LL)); |
||||
BOOST_CHECK(v.isNum()); |
||||
BOOST_CHECK_EQUAL(v.getValStr(), "-1023"); |
||||
|
||||
BOOST_CHECK(v.setInt((uint64_t)1023ULL)); |
||||
BOOST_CHECK(v.isNum()); |
||||
BOOST_CHECK_EQUAL(v.getValStr(), "1023"); |
||||
|
||||
BOOST_CHECK(v.setNumStr("-688")); |
||||
BOOST_CHECK(v.isNum()); |
||||
BOOST_CHECK_EQUAL(v.getValStr(), "-688"); |
||||
|
||||
BOOST_CHECK(v.setBool(false)); |
||||
BOOST_CHECK_EQUAL(v.isBool(), true); |
||||
BOOST_CHECK_EQUAL(v.isTrue(), false); |
||||
BOOST_CHECK_EQUAL(v.isFalse(), true); |
||||
BOOST_CHECK_EQUAL(v.getBool(), false); |
||||
|
||||
BOOST_CHECK(v.setBool(true)); |
||||
BOOST_CHECK_EQUAL(v.isBool(), true); |
||||
BOOST_CHECK_EQUAL(v.isTrue(), true); |
||||
BOOST_CHECK_EQUAL(v.isFalse(), false); |
||||
BOOST_CHECK_EQUAL(v.getBool(), true); |
||||
|
||||
BOOST_CHECK(!v.setNumStr("zombocom")); |
||||
|
||||
BOOST_CHECK(v.setNull()); |
||||
BOOST_CHECK(v.isNull()); |
||||
} |
||||
|
||||
BOOST_AUTO_TEST_CASE(univalue_array) |
||||
{ |
||||
UniValue arr(UniValue::VARR); |
||||
|
||||
UniValue v((int64_t)1023LL); |
||||
BOOST_CHECK(arr.push_back(v)); |
||||
|
||||
std::string vStr("zippy"); |
||||
BOOST_CHECK(arr.push_back(vStr)); |
||||
|
||||
const char *s = "pippy"; |
||||
BOOST_CHECK(arr.push_back(s)); |
||||
|
||||
std::vector<UniValue> vec; |
||||
v.setStr("boing"); |
||||
vec.push_back(v); |
||||
|
||||
v.setStr("going"); |
||||
vec.push_back(v); |
||||
|
||||
BOOST_CHECK(arr.push_backV(vec)); |
||||
|
||||
BOOST_CHECK(arr.push_back((uint64_t) 400ULL)); |
||||
BOOST_CHECK(arr.push_back((int64_t) -400LL)); |
||||
BOOST_CHECK(arr.push_back((int) -401)); |
||||
BOOST_CHECK(arr.push_back(-40.1)); |
||||
|
||||
BOOST_CHECK_EQUAL(arr.empty(), false); |
||||
BOOST_CHECK_EQUAL(arr.size(), 9); |
||||
|
||||
BOOST_CHECK_EQUAL(arr[0].getValStr(), "1023"); |
||||
BOOST_CHECK_EQUAL(arr[1].getValStr(), "zippy"); |
||||
BOOST_CHECK_EQUAL(arr[2].getValStr(), "pippy"); |
||||
BOOST_CHECK_EQUAL(arr[3].getValStr(), "boing"); |
||||
BOOST_CHECK_EQUAL(arr[4].getValStr(), "going"); |
||||
BOOST_CHECK_EQUAL(arr[5].getValStr(), "400"); |
||||
BOOST_CHECK_EQUAL(arr[6].getValStr(), "-400"); |
||||
BOOST_CHECK_EQUAL(arr[7].getValStr(), "-401"); |
||||
BOOST_CHECK_EQUAL(arr[8].getValStr(), "-40.1"); |
||||
|
||||
BOOST_CHECK_EQUAL(arr[999].getValStr(), ""); |
||||
|
||||
arr.clear(); |
||||
BOOST_CHECK(arr.empty()); |
||||
BOOST_CHECK_EQUAL(arr.size(), 0); |
||||
} |
||||
|
||||
BOOST_AUTO_TEST_CASE(univalue_object) |
||||
{ |
||||
UniValue obj(UniValue::VOBJ); |
||||
std::string strKey, strVal; |
||||
UniValue v; |
||||
|
||||
strKey = "age"; |
||||
v.setInt(100); |
||||
BOOST_CHECK(obj.pushKV(strKey, v)); |
||||
|
||||
strKey = "first"; |
||||
strVal = "John"; |
||||
BOOST_CHECK(obj.pushKV(strKey, strVal)); |
||||
|
||||
strKey = "last"; |
||||
const char *cVal = "Smith"; |
||||
BOOST_CHECK(obj.pushKV(strKey, cVal)); |
||||
|
||||
strKey = "distance"; |
||||
BOOST_CHECK(obj.pushKV(strKey, (int64_t) 25)); |
||||
|
||||
strKey = "time"; |
||||
BOOST_CHECK(obj.pushKV(strKey, (uint64_t) 3600)); |
||||
|
||||
strKey = "calories"; |
||||
BOOST_CHECK(obj.pushKV(strKey, (int) 12)); |
||||
|
||||
strKey = "temperature"; |
||||
BOOST_CHECK(obj.pushKV(strKey, (double) 90.012)); |
||||
|
||||
UniValue obj2(UniValue::VOBJ); |
||||
BOOST_CHECK(obj2.pushKV("cat1", 9000)); |
||||
BOOST_CHECK(obj2.pushKV("cat2", 12345)); |
||||
|
||||
BOOST_CHECK(obj.pushKVs(obj2)); |
||||
|
||||
BOOST_CHECK_EQUAL(obj.empty(), false); |
||||
BOOST_CHECK_EQUAL(obj.size(), 9); |
||||
|
||||
BOOST_CHECK_EQUAL(obj["age"].getValStr(), "100"); |
||||
BOOST_CHECK_EQUAL(obj["first"].getValStr(), "John"); |
||||
BOOST_CHECK_EQUAL(obj["last"].getValStr(), "Smith"); |
||||
BOOST_CHECK_EQUAL(obj["distance"].getValStr(), "25"); |
||||
BOOST_CHECK_EQUAL(obj["time"].getValStr(), "3600"); |
||||
BOOST_CHECK_EQUAL(obj["calories"].getValStr(), "12"); |
||||
BOOST_CHECK_EQUAL(obj["temperature"].getValStr(), "90.012"); |
||||
BOOST_CHECK_EQUAL(obj["cat1"].getValStr(), "9000"); |
||||
BOOST_CHECK_EQUAL(obj["cat2"].getValStr(), "12345"); |
||||
|
||||
BOOST_CHECK_EQUAL(obj["nyuknyuknyuk"].getValStr(), ""); |
||||
|
||||
BOOST_CHECK(obj.exists("age")); |
||||
BOOST_CHECK(obj.exists("first")); |
||||
BOOST_CHECK(obj.exists("last")); |
||||
BOOST_CHECK(obj.exists("distance")); |
||||
BOOST_CHECK(obj.exists("time")); |
||||
BOOST_CHECK(obj.exists("calories")); |
||||
BOOST_CHECK(obj.exists("temperature")); |
||||
BOOST_CHECK(obj.exists("cat1")); |
||||
BOOST_CHECK(obj.exists("cat2")); |
||||
|
||||
BOOST_CHECK(!obj.exists("nyuknyuknyuk")); |
||||
|
||||
std::map<std::string, UniValue::VType> objTypes; |
||||
objTypes["age"] = UniValue::VNUM; |
||||
objTypes["first"] = UniValue::VSTR; |
||||
objTypes["last"] = UniValue::VSTR; |
||||
objTypes["distance"] = UniValue::VNUM; |
||||
objTypes["time"] = UniValue::VNUM; |
||||
objTypes["calories"] = UniValue::VNUM; |
||||
objTypes["temperature"] = UniValue::VNUM; |
||||
objTypes["cat1"] = UniValue::VNUM; |
||||
objTypes["cat2"] = UniValue::VNUM; |
||||
BOOST_CHECK(obj.checkObject(objTypes)); |
||||
|
||||
objTypes["cat2"] = UniValue::VSTR; |
||||
BOOST_CHECK(!obj.checkObject(objTypes)); |
||||
|
||||
obj.clear(); |
||||
BOOST_CHECK(obj.empty()); |
||||
BOOST_CHECK_EQUAL(obj.size(), 0); |
||||
BOOST_CHECK_EQUAL(obj.getType(), UniValue::VNULL); |
||||
|
||||
BOOST_CHECK_EQUAL(obj.setObject(), true); |
||||
UniValue uv; |
||||
uv.setInt(42); |
||||
obj.__pushKV("age", uv); |
||||
BOOST_CHECK_EQUAL(obj.size(), 1); |
||||
BOOST_CHECK_EQUAL(obj["age"].getValStr(), "42"); |
||||
|
||||
uv.setInt(43); |
||||
obj.pushKV("age", uv); |
||||
BOOST_CHECK_EQUAL(obj.size(), 1); |
||||
BOOST_CHECK_EQUAL(obj["age"].getValStr(), "43"); |
||||
|
||||
obj.pushKV("name", "foo bar"); |
||||
|
||||
std::map<std::string,UniValue> kv; |
||||
obj.getObjMap(kv); |
||||
BOOST_CHECK_EQUAL(kv["age"].getValStr(), "43"); |
||||
BOOST_CHECK_EQUAL(kv["name"].getValStr(), "foo bar"); |
||||
|
||||
} |
||||
|
||||
static const char *json1 = |
||||
"[1.10000000,{\"key1\":\"str\\u0000\",\"key2\":800,\"key3\":{\"name\":\"martian http://test.com\"}}]"; |
||||
|
||||
BOOST_AUTO_TEST_CASE(univalue_readwrite) |
||||
{ |
||||
UniValue v; |
||||
BOOST_CHECK(v.read(json1)); |
||||
|
||||
std::string strJson1(json1); |
||||
BOOST_CHECK(v.read(strJson1)); |
||||
|
||||
BOOST_CHECK(v.isArray()); |
||||
BOOST_CHECK_EQUAL(v.size(), 2); |
||||
|
||||
BOOST_CHECK_EQUAL(v[0].getValStr(), "1.10000000"); |
||||
|
||||
UniValue obj = v[1]; |
||||
BOOST_CHECK(obj.isObject()); |
||||
BOOST_CHECK_EQUAL(obj.size(), 3); |
||||
|
||||
BOOST_CHECK(obj["key1"].isStr()); |
||||
std::string correctValue("str"); |
||||
correctValue.push_back('\0'); |
||||
BOOST_CHECK_EQUAL(obj["key1"].getValStr(), correctValue); |
||||
BOOST_CHECK(obj["key2"].isNum()); |
||||
BOOST_CHECK_EQUAL(obj["key2"].getValStr(), "800"); |
||||
BOOST_CHECK(obj["key3"].isObject()); |
||||
|
||||
BOOST_CHECK_EQUAL(strJson1, v.write()); |
||||
|
||||
/* Check for (correctly reporting) a parsing error if the initial
|
||||
JSON construct is followed by more stuff. Note that whitespace |
||||
is, of course, exempt. */ |
||||
|
||||
BOOST_CHECK(v.read(" {}\n ")); |
||||
BOOST_CHECK(v.isObject()); |
||||
BOOST_CHECK(v.read(" []\n ")); |
||||
BOOST_CHECK(v.isArray()); |
||||
|
||||
BOOST_CHECK(!v.read("@{}")); |
||||
BOOST_CHECK(!v.read("{} garbage")); |
||||
BOOST_CHECK(!v.read("[]{}")); |
||||
BOOST_CHECK(!v.read("{}[]")); |
||||
BOOST_CHECK(!v.read("{} 42")); |
||||
} |
||||
|
||||
BOOST_AUTO_TEST_SUITE_END() |
||||
|
||||
int main (int argc, char *argv[]) |
||||
{ |
||||
univalue_constructor(); |
||||
univalue_typecheck(); |
||||
univalue_set(); |
||||
univalue_array(); |
||||
univalue_object(); |
||||
univalue_readwrite(); |
||||
return 0; |
||||
} |
||||
|
||||
@ -0,0 +1 @@
@@ -0,0 +1 @@
|
||||
"abcdefghijklmnopqrstuvwxyz" |
||||
@ -0,0 +1,24 @@
@@ -0,0 +1,24 @@
|
||||
// Test program that can be called by the JSON test suite at
|
||||
// https://github.com/nst/JSONTestSuite.
|
||||
//
|
||||
// It reads JSON input from stdin and exits with code 0 if it can be parsed
|
||||
// successfully. It also pretty prints the parsed JSON value to stdout.
|
||||
|
||||
#include <iostream> |
||||
#include <string> |
||||
#include "univalue.h" |
||||
|
||||
using namespace std; |
||||
|
||||
int main (int argc, char *argv[]) |
||||
{ |
||||
UniValue val; |
||||
if (val.read(string(istreambuf_iterator<char>(cin), |
||||
istreambuf_iterator<char>()))) { |
||||
cout << val.write(1 /* prettyIndent */, 4 /* indentLevel */) << endl; |
||||
return 0; |
||||
} else { |
||||
cerr << "JSON Parse Error." << endl; |
||||
return 1; |
||||
} |
||||
} |
||||
Loading…
Reference in new issue