wehub/alibaba--zvec
1
0
Fork 0
Code Issues Pull Requests Actions 4 Deployments Models Agent Notes Packages Projects Releases Wiki Activity
Files
be3ef883e104e6e259d681b996bf142f5921c12f
alibaba--zvec/tests/ailego/encoding/json_parse_test.cc
T
wehub-resource-sync be3ef883e1 chore: import upstream snapshot with attribution
2026-07-13 12:47:42 +08:00

1797 lines
50 KiB
C++
Raw Blame History

// Copyright 2025-present the zvec project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <gtest/gtest.h>
#include <zvec/ailego/encoding/json.h>
using namespace zvec::ailego;
TEST(Json, JsonParser) {
{
JsonValue val;
JsonParser parser;
JsonString str =
"{first: {int: 123, float: 1.0, "
"true:[true, true, true, true], false:[false], zero:[0,0,0]}, "
"true:true, false:[false, false, false, false], zero:[0,0]}";
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_simple(true);
EXPECT_TRUE(parser.parse(str.c_str(), &val));
EXPECT_TRUE(val.refer() == 1);
const JsonValue &val2 = val;
const JsonObject &obj2 = val2.as_object();
EXPECT_TRUE(val2.as_object().refer() == 1);
JsonValue val_result;
EXPECT_TRUE(obj2.get("first", &val_result));
EXPECT_TRUE(val_result.refer() == 2);
EXPECT_TRUE(val_result.as_object().refer() == 2);
EXPECT_TRUE(obj2.get("true", &val_result));
EXPECT_TRUE(obj2.get("false", &val_result));
EXPECT_TRUE(obj2.get("zero", &val_result));
const JsonValue val3 = val;
EXPECT_TRUE(val3.refer() == 2);
EXPECT_TRUE(val3.as_object().refer() == 1);
JsonValue val4 = val;
EXPECT_TRUE(val4.refer() == 3);
EXPECT_TRUE(val3.refer() == 3);
EXPECT_TRUE(val2.refer() == 3);
JsonObject &obj4 = val4.as_object();
EXPECT_TRUE(obj4.refer() == 2);
EXPECT_TRUE(val4.refer() == 0);
EXPECT_TRUE(val3.refer() == 2);
EXPECT_TRUE(val3.as_object().refer() == 2);
EXPECT_TRUE(val2.refer() == 2);
}
{
JsonString str =
"[ true,,\'\\u9701abcd \\u38981515\\u89454845\\uabcd\\uef12\'";
JsonParser parser;
JsonValue val = JsonValue();
JsonValue tmp;
EXPECT_FALSE(tmp.parse(str));
parser.set_squote();
EXPECT_FALSE(parser.parse(str.c_str(), &val));
}
{
JsonParser parser;
JsonString str = "{ 0:0, 1: 1, 2:2, 3:3, 4: 4, 5:5}";
JsonValue val;
parser.set_simple(true);
EXPECT_TRUE(parser.parse(str.c_str(), &val));
EXPECT_TRUE(val.refer() == 1);
JsonValue val2 = val;
EXPECT_TRUE(val2.refer() == 2);
JsonObject &obj2 = val2.as_object();
EXPECT_TRUE(val2.refer() == 0);
EXPECT_TRUE(obj2.refer() == 2);
EXPECT_TRUE(obj2["0"].refer() == 2);
EXPECT_TRUE(obj2["1"].refer() == 2);
EXPECT_TRUE(obj2["2"].refer() == 2);
EXPECT_TRUE(obj2["3"].refer() == 2);
EXPECT_TRUE(obj2["4"].refer() == 2);
EXPECT_TRUE(obj2["5"].refer() == 2);
EXPECT_TRUE(obj2.refer() == 0);
JsonValue val3 = val;
EXPECT_TRUE(val3.refer() == 2);
JsonObject::const_iterator iter = obj2.begin();
EXPECT_TRUE(iter->key().refer() == 2);
EXPECT_TRUE(iter->value().refer() == 2);
}
{
JsonParser parser;
JsonString str = "[0, 1, 2, 3, 4, 5]";
JsonValue val;
parser.set_simple(true);
EXPECT_TRUE(parser.parse(str.c_str(), &val));
EXPECT_TRUE(val.refer() == 1);
JsonValue val2 = val;
EXPECT_TRUE(val2.refer() == 2);
JsonArray &arr2 = val2.as_array();
EXPECT_TRUE(val2.refer() == 0);
EXPECT_TRUE(arr2.refer() == 2);
EXPECT_TRUE(arr2[0].refer() == 2);
EXPECT_TRUE(arr2[1].refer() == 2);
EXPECT_TRUE(arr2[2].refer() == 2);
EXPECT_TRUE(arr2[3].refer() == 2);
EXPECT_TRUE(arr2[4].refer() == 2);
EXPECT_TRUE(arr2[5].refer() == 2);
EXPECT_TRUE(arr2.refer() == 0);
JsonValue val3 = val;
EXPECT_TRUE(val3.refer() == 2);
JsonArray::const_iterator iter = arr2.begin();
EXPECT_TRUE(iter->refer() == 2);
}
{
JsonString str =
"[ 15, true, null,\'\\u9701abcd "
"\\u38981515\\u89454845\\uabcd\\uef12\',]";
JsonParser parser;
JsonValue val(true);
parser.set_squote();
EXPECT_TRUE(parser.parse(str.c_str(), &val));
EXPECT_TRUE(val[1].as_bool());
val[1] = val[2];
EXPECT_FALSE(val[1].as_bool());
}
{
JsonParser parser;
JsonValue val1, val2, val3, val4;
EXPECT_TRUE(parser.parse(
"[0.0, 1.0, 2.0, 3.0, 4.0, 5.0, "
"6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,"
"17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,"
"\"32\",\"33\",\"34\",\"35\",\"36\","
"{\"5\":5,\"4\":4,\"3\":3,\"2\":2,\"1\":1,\"0\":0,\"-1\":-1}]",
&val1));
EXPECT_TRUE(
parser.parse("[\"0\",\"1\",\"2\",\"3\",\"4\",\"5\",\"6\",\"7\",\"8\","
"\"9\",\"10\",\"11\",\"12\",\"13\",\"14\",\"15\",\"16\","
"\"17\",\"18\",\"19\",\"20\",\"21\",\"22\",\"23\",\"24\","
"\"25\",\"26\",\"27\",\"28\",\"29\",\"30\",\"31\","
"\"32\",\"33\",\"34\",\"35\",\"36\","
"{\"-2\":\"-2\",\"-1\":\"-1\",\"1\":\"1\",\"2\":\"2\","
"\"3\":\"3\",\"4\":\"4\",\"5\":\"5\",\"6\":\"6\"},"
"[],null,true,false,0.0,1.0,9.999,-1]",
&val2));
EXPECT_TRUE(
parser.parse("[\"0\",\"1\",\"2\",\"3\",\"4\",\"5\",\"6\",\"7\",\"8\","
"\"9\",\"10\",\"11\",\"12\",\"13\",\"14\",\"15\",\"16\","
"\"17\",\"18\",\"19\",\"20\",\"21\",\"22\",\"23\",\"24\","
"\"25\",\"26\",\"27\",\"28\",\"29\",\"30\",\"31\","
"\"32\",\"33\",\"34\",\"35\",\"36\","
"{\"5\":\"5\",\"4\":\"4\",\"3\":\"3\","
"\"2\":\"2\",\"1\":\"1\",\"0\":0,"
"\"-1\":\"-1\",\"-2\":\"-2\",\"6\":\"6\"},"
"[],null,true,false,0.0,1.0,9.999,-1]",
&val3));
EXPECT_TRUE(
parser.parse("[0.0, 1.0, 2.0, 3.0, 4.0, 5.0, "
"6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,"
"17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,"
"\"32\",\"33\",\"34\",\"35\",\"36\","
"{\"-2\":\"-2\",\"-1\":-1,\"1\":1,\"2\":2,"
"\"3\":3,\"4\":4,\"5\":5,\"6\":\"6\",\"0\":0},"
"[],null,true,false,0.0,1.0,9.999,-1]",
&val4));
JsonValue tmp1 = val1;
tmp1.merge(val2);
JsonValue tmp2 = val2;
tmp2.merge(val1);
JsonDumper dumper;
EXPECT_TRUE(dumper.dump(val1));
EXPECT_TRUE(dumper.dump(val2));
EXPECT_TRUE(dumper.dump(val3));
EXPECT_TRUE(dumper.dump(val4));
EXPECT_TRUE(dumper.dump(tmp1));
EXPECT_TRUE(tmp1.as_json_string() == val3.as_json_string());
EXPECT_TRUE(tmp2.as_json_string() == val4.as_json_string());
}
{
JsonValue val;
JsonParser parser;
std::string str =
"{\"req\": {\"aid\": \"\", \"friend\": "
"\"1234567890\", \"uintype\": "
"0}}";
EXPECT_TRUE(parser.parse(str.c_str(), &val));
EXPECT_FALSE(parser.parse("", &val));
JsonValue tmp;
EXPECT_TRUE(tmp.parse(str));
EXPECT_TRUE(tmp == val);
EXPECT_FALSE(tmp != val);
const JsonValue &req = val["req"];
EXPECT_TRUE(req.is_object());
EXPECT_TRUE(req["show"].as_integer() == 0);
EXPECT_TRUE(req["friend"].as_integer() == 1234567890);
EXPECT_TRUE(req[1].is_null());
}
{
JsonValue val;
JsonParser parser;
std::string str = "[true, false, 0, 1, 2, \"3\"]";
EXPECT_TRUE(parser.parse(str.c_str(), &val));
EXPECT_TRUE(val[0u].as_bool());
EXPECT_FALSE(val[1].as_bool());
EXPECT_TRUE(val[2].as_integer() == 0);
EXPECT_TRUE(val[3].as_integer() == 1);
EXPECT_TRUE(val[4].as_integer() == 2);
EXPECT_TRUE(val[5].as_integer() == 3);
JsonValue tmp;
EXPECT_TRUE(tmp.parse(str));
EXPECT_TRUE(tmp == val);
EXPECT_FALSE(tmp != val);
const JsonValue val2 = val;
EXPECT_TRUE(val2[0u].as_bool());
EXPECT_FALSE(val2[1].as_bool());
EXPECT_TRUE(val2[2].as_integer() == 0);
EXPECT_TRUE(val2[3].as_integer() == 1);
EXPECT_TRUE(val2[4].as_integer() == 2);
EXPECT_TRUE(val2[5].as_integer() == 3);
EXPECT_TRUE(val2[6].is_null());
EXPECT_TRUE(val2[(JsonValue::size_type)-1].as_integer() == 0);
}
{
JsonValue val;
JsonParser parser;
std::string str = "{abcd:\"1234\"}";
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_comment(true);
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_simple(true);
EXPECT_TRUE(parser.parse(str.c_str(), &val));
EXPECT_TRUE(val["abcd"].as_c_string() == std::string("1234"));
parser.set_unstrict(true);
EXPECT_TRUE(parser.parse(str.c_str(), &val));
EXPECT_TRUE(val["abcd"].as_integer() == 1234);
}
{
JsonValue val;
JsonParser parser;
std::string str = "/*comments*/ { abcd\t : /* //comments */\"1234\" }";
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_comment(true);
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_simple(true);
parser.set_comment(false);
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_simple(true);
parser.set_comment(true);
EXPECT_TRUE(parser.parse(str.c_str(), &val));
EXPECT_TRUE(val["abcd"].as_c_string() == std::string("1234"));
parser.set_unstrict(true);
EXPECT_TRUE(parser.parse(str.c_str(), &val));
EXPECT_TRUE(val["abcd"].as_integer() == 1234);
}
{
JsonValue val;
JsonParser parser;
std::string str = "{ abcd/* fff*/ : /* //comments */\"1234\" }";
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_comment(true);
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_simple(true);
parser.set_comment(false);
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_simple(true);
parser.set_comment(true);
EXPECT_TRUE(parser.parse(str.c_str(), &val));
EXPECT_TRUE(val["abcd"].as_c_string() == std::string("1234"));
parser.set_unstrict(true);
EXPECT_TRUE(parser.parse(str.c_str(), &val));
EXPECT_TRUE(val["abcd"].as_integer() == 1234);
}
{
JsonValue val;
JsonParser parser;
std::string str =
"{ \"abcd\\\"/* fff*/ : /* //comments */\"1234\" , {, [, ]}}";
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_comment(true);
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_simple(true);
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_unstrict(true);
EXPECT_FALSE(parser.parse(str.c_str(), &val));
}
{
JsonValue val;
JsonParser parser;
std::string str = "{ abcd///comments */\"1234\", [] }";
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_comment(true);
EXPECT_FALSE(parser.parse(str.c_str(), &val));
}
{
JsonValue val;
JsonParser parser;
std::string str = "{ abcd/*//*/ : \t \"1234\" }";
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_simple(true);
EXPECT_TRUE(parser.parse(str.c_str(), &val));
EXPECT_TRUE(val["abcd"].as_c_string() == nullptr);
EXPECT_TRUE(val["abcd/*//*/"].as_c_string() == std::string("1234"));
parser.set_comment(true);
EXPECT_TRUE(parser.parse(str.c_str(), &val));
EXPECT_TRUE(val["abcd"].as_c_string() == std::string("1234"));
}
{
JsonValue val;
JsonParser parser;
std::string str = "{ ,{}, \"abcd/*//*/ : \t \"1234\", }";
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_simple(true);
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_comment(true);
EXPECT_FALSE(parser.parse(str.c_str(), &val));
}
{
JsonValue val;
JsonParser parser;
std::string str = "{ ccdd: [], abcd\" /*//*/ \n: \t \"1234\" }";
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_simple(true);
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_comment(true);
EXPECT_TRUE(parser.parse(str.c_str(), &val));
EXPECT_TRUE(val["abcd"].as_c_string() == nullptr);
EXPECT_TRUE(val["abcd\""].as_c_string() == std::string("1234"));
}
{
JsonValue val;
JsonParser parser;
std::string str = "{,, \"\" \n: \t \"1234\" }";
EXPECT_TRUE(parser.parse(str.c_str(), &val));
EXPECT_TRUE(val[""].as_c_string() == std::string("1234"));
parser.set_simple(true);
EXPECT_TRUE(parser.parse(str.c_str(), &val));
EXPECT_TRUE(val[""].as_c_string() == std::string("1234"));
}
{
JsonValue val;
JsonParser parser;
std::string str = "{ , \n: \t \"1234\" }";
EXPECT_FALSE(parser.parse(str.c_str(), &val));
EXPECT_TRUE(val[""].as_c_string() == nullptr);
parser.set_simple(true);
EXPECT_FALSE(parser.parse(str.c_str(), &val));
}
{
JsonValue val;
JsonParser parser;
std::string str = "{ \'ccdd\': [], \'abcd\' /*//*/ \n: \t \"1234\" }";
parser.set_comment(true);
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_simple(true);
EXPECT_TRUE(parser.parse(str.c_str(), &val));
EXPECT_TRUE(val["\'abcd\'"].as_c_string() == std::string("1234"));
parser.set_squote(true);
EXPECT_TRUE(parser.parse(str.c_str(), &val));
EXPECT_TRUE(val["abcd"].as_c_string() == std::string("1234"));
}
{
JsonValue val;
JsonParser parser;
std::string str = "{ 1234 : \'abcd\', \'5678\' : [5, \'5678\'] }";
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_squote(true);
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_simple(true);
EXPECT_TRUE(parser.parse(str.c_str(), &val));
EXPECT_TRUE(val["1234"].as_c_string() == std::string("abcd"));
EXPECT_TRUE(val["5678"].as_array().at(1).as_c_string() ==
std::string("5678"));
}
{
JsonValue val;
JsonParser parser;
std::string str = "{ 1234 : \'ab\"cd\', \'5678\' : [\"5\", \'5678\'] }";
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_squote(true);
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_simple(true);
EXPECT_TRUE(parser.parse(str.c_str(), &val));
EXPECT_TRUE(val["1234"].as_c_string() == std::string("ab\"cd"));
EXPECT_TRUE(val["5678"].as_array().at(1).as_c_string() ==
std::string("5678"));
}
{
JsonValue val;
JsonParser parser;
std::string str = "{ 1234 : \'ab\\\'cd\', \'5678\' : [\"5\", \'5678\'] }";
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_squote(true);
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_simple(true);
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_unstrict(true);
EXPECT_TRUE(parser.parse(str.c_str(), &val));
EXPECT_TRUE(val["1234"].as_c_string() == std::string("ab\\\'cd"));
EXPECT_TRUE(val["5678"].as_array().at(1).as_c_string() ==
std::string("5678"));
}
{
JsonValue val;
JsonParser parser;
std::string str = "{ \'1234\'\' : \'abcd\', \'5678\' : [\"5\", \'5678\'] }";
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_squote(true);
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_simple(true);
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_unstrict(true);
EXPECT_FALSE(parser.parse(str.c_str(), &val));
}
{
JsonValue val;
JsonParser parser;
std::string str =
"{ \'1234\' : \'abcd\' \", \'5678\' : [\"5\", \'5678\'] }";
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_squote(true);
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_simple(true);
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_unstrict(true);
EXPECT_FALSE(parser.parse(str.c_str(), &val));
}
{
JsonValue val;
JsonParser parser;
std::string str =
"{ \'1234\' : \'abcd\' , \'5678\' : [\"5\" \", \'5678\'] }";
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_squote(true);
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_simple(true);
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_unstrict(true);
EXPECT_FALSE(parser.parse(str.c_str(), &val));
}
{
JsonValue val;
JsonParser parser;
std::string str =
"{ \'1234\' : \'abcd\' , \'5678\' : [\"5\" , \'5678\' \'] }";
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_squote(true);
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_simple(true);
EXPECT_FALSE(parser.parse(str.c_str(), &val));
parser.set_unstrict(true);
EXPECT_FALSE(parser.parse(str.c_str(), &val));
}
{
JsonValue val1;
JsonValue val2;
JsonString str =
"{\"a\":1, \"b\":2, \"c\":3, \"string\": \"string\", "
"\"array\": [null, true, false, "
", 0], \"object\": {\"a\":1.0, \"b\":2.0, \"c\":3.0}, "
"\"true\": true, \"null\": null}";
EXPECT_TRUE(val1.parse(str));
EXPECT_TRUE(val2.parse(str));
EXPECT_TRUE(val2 == val1);
EXPECT_FALSE((val2 != val1));
EXPECT_TRUE(val2.as_object() == val1);
EXPECT_TRUE(val2 == val1.as_object());
EXPECT_TRUE(val2.as_object() == val1.as_object());
EXPECT_TRUE(val1["string"] == val2["string"]);
}
}
TEST(Json, JsonObject) {
{
JsonObject jobj;
for (int i = 0; i < 1000; ++i) {
JsonValue key(i);
EXPECT_TRUE(jobj.set(key.as_json_string().c_str(), JsonValue((float)i)));
JsonValue::integer_type val;
EXPECT_TRUE(jobj.get(key.as_json_string(), &val));
EXPECT_EQ(val, i);
}
for (int i = 0; i < 1000; ++i) {
JsonValue key(i);
jobj.unset(key.as_json_string().c_str());
JsonValue::integer_type val = 0;
EXPECT_FALSE(jobj.get(key.as_stl_string(), &val));
EXPECT_EQ(val, 0);
}
}
{
JsonObject obj;
obj.set("0", JsonValue(0));
obj.set("1", JsonValue(1));
obj.set("2", JsonValue(2));
obj.set("3", JsonValue(3));
obj.set("4", JsonValue(4));
obj.set("5", JsonValue(5));
obj.set("6", JsonValue(6));
obj.set("7", JsonValue(7));
obj.set("8", JsonValue(8));
obj.set("9", JsonValue(9));
EXPECT_EQ(obj.size(), 10u);
EXPECT_EQ(obj["0"].as_integer(), 0);
EXPECT_EQ(obj["1"].as_integer(), 1);
EXPECT_EQ(obj["2"].as_integer(), 2);
EXPECT_EQ(obj["3"].as_integer(), 3);
EXPECT_EQ(obj["4"].as_integer(), 4);
EXPECT_EQ(obj["5"].as_integer(), 5);
EXPECT_EQ(obj["6"].as_integer(), 6);
EXPECT_EQ(obj["7"].as_integer(), 7);
EXPECT_EQ(obj["8"].as_integer(), 8);
EXPECT_EQ(obj["9"].as_integer(), 9);
EXPECT_EQ(obj.size(), 10u);
int index_id = 0;
for (JsonObject::const_iterator it = obj.cbegin(); it != obj.cend();
++it, ++index_id) {
EXPECT_EQ(it->value().as_integer(), index_id);
}
int index_id_r = 9;
for (JsonObject::const_reverse_iterator it = obj.crbegin();
it != obj.crend(); ++it, --index_id_r) {
EXPECT_EQ(it->value().as_integer(), index_id_r);
}
obj.unset("1");
EXPECT_EQ(obj.size(), 9u);
obj.unset("3");
EXPECT_EQ(obj.size(), 8u);
obj.unset("5");
EXPECT_EQ(obj.size(), 7u);
obj.unset("7");
EXPECT_EQ(obj.size(), 6u);
obj.unset("9");
EXPECT_EQ(obj.size(), 5u);
obj.clear();
EXPECT_EQ(obj.size(), 0u);
}
{
JsonObject obj;
// 0
EXPECT_FALSE(obj.has("00000"));
EXPECT_FALSE(obj.has("11111"));
EXPECT_FALSE(obj.has("22222"));
EXPECT_FALSE(obj.has("33333"));
EXPECT_FALSE(obj.has("44444"));
EXPECT_FALSE(obj.has("55555"));
EXPECT_FALSE(obj.has("66666"));
EXPECT_FALSE(obj.has("77777"));
EXPECT_FALSE(obj.has("88888"));
EXPECT_FALSE(obj.has("99999"));
// 1
EXPECT_TRUE(obj.set("55555", "55555"));
EXPECT_FALSE(obj.has("00000"));
EXPECT_FALSE(obj.has("11111"));
EXPECT_FALSE(obj.has("22222"));
EXPECT_FALSE(obj.has("33333"));
EXPECT_FALSE(obj.has("44444"));
EXPECT_TRUE(obj.has("55555"));
EXPECT_FALSE(obj.has("66666"));
EXPECT_FALSE(obj.has("77777"));
EXPECT_FALSE(obj.has("88888"));
EXPECT_FALSE(obj.has("99999"));
// 2
EXPECT_TRUE(obj.set("88888", "88888"));
EXPECT_FALSE(obj.has("00000"));
EXPECT_FALSE(obj.has("11111"));
EXPECT_FALSE(obj.has("22222"));
EXPECT_FALSE(obj.has("33333"));
EXPECT_FALSE(obj.has("44444"));
EXPECT_TRUE(obj.has("55555"));
EXPECT_FALSE(obj.has("66666"));
EXPECT_FALSE(obj.has("77777"));
EXPECT_TRUE(obj.has("88888"));
EXPECT_FALSE(obj.has("99999"));
// 2
EXPECT_TRUE(obj.set("66666", "66666"));
EXPECT_FALSE(obj.has("00000"));
EXPECT_FALSE(obj.has("11111"));
EXPECT_FALSE(obj.has("22222"));
EXPECT_FALSE(obj.has("33333"));
EXPECT_FALSE(obj.has("44444"));
EXPECT_TRUE(obj.has("55555"));
EXPECT_TRUE(obj.has("66666"));
EXPECT_FALSE(obj.has("77777"));
EXPECT_TRUE(obj.has("88888"));
EXPECT_FALSE(obj.has("99999"));
// 3
EXPECT_TRUE(obj.set("44444", "44444"));
EXPECT_FALSE(obj.has("00000"));
EXPECT_FALSE(obj.has("11111"));
EXPECT_FALSE(obj.has("22222"));
EXPECT_FALSE(obj.has("33333"));
EXPECT_TRUE(obj.has("44444"));
EXPECT_TRUE(obj.has("55555"));
EXPECT_TRUE(obj.has("66666"));
EXPECT_FALSE(obj.has("77777"));
EXPECT_TRUE(obj.has("88888"));
EXPECT_FALSE(obj.has("99999"));
// 4
EXPECT_TRUE(obj.set("99999", "99999"));
EXPECT_FALSE(obj.has("00000"));
EXPECT_FALSE(obj.has("11111"));
EXPECT_FALSE(obj.has("22222"));
EXPECT_FALSE(obj.has("33333"));
EXPECT_TRUE(obj.has("44444"));
EXPECT_TRUE(obj.has("55555"));
EXPECT_TRUE(obj.has("66666"));
EXPECT_FALSE(obj.has("77777"));
EXPECT_TRUE(obj.has("88888"));
EXPECT_TRUE(obj.has("99999"));
// 5
EXPECT_TRUE(obj.set("22222", "22222"));
EXPECT_FALSE(obj.has("00000"));
EXPECT_FALSE(obj.has("11111"));
EXPECT_TRUE(obj.has("22222"));
EXPECT_FALSE(obj.has("33333"));
EXPECT_TRUE(obj.has("44444"));
EXPECT_TRUE(obj.has("55555"));
EXPECT_TRUE(obj.has("66666"));
EXPECT_FALSE(obj.has("77777"));
EXPECT_TRUE(obj.has("88888"));
EXPECT_TRUE(obj.has("99999"));
// 6
EXPECT_TRUE(obj.set("00000", "00000"));
EXPECT_TRUE(obj.has("00000"));
EXPECT_FALSE(obj.has("11111"));
EXPECT_TRUE(obj.has("22222"));
EXPECT_FALSE(obj.has("33333"));
EXPECT_TRUE(obj.has("44444"));
EXPECT_TRUE(obj.has("55555"));
EXPECT_TRUE(obj.has("66666"));
EXPECT_FALSE(obj.has("77777"));
EXPECT_TRUE(obj.has("88888"));
EXPECT_TRUE(obj.has("99999"));
// 7
EXPECT_TRUE(obj.set("77777", "77777"));
EXPECT_TRUE(obj.has("00000"));
EXPECT_FALSE(obj.has("11111"));
EXPECT_TRUE(obj.has("22222"));
EXPECT_FALSE(obj.has("33333"));
EXPECT_TRUE(obj.has("44444"));
EXPECT_TRUE(obj.has("55555"));
EXPECT_TRUE(obj.has("66666"));
EXPECT_TRUE(obj.has("77777"));
EXPECT_TRUE(obj.has("88888"));
EXPECT_TRUE(obj.has("99999"));
// 8
EXPECT_TRUE(obj.set("11111", "11111"));
EXPECT_TRUE(obj.has("00000"));
EXPECT_TRUE(obj.has("11111"));
EXPECT_TRUE(obj.has("22222"));
EXPECT_FALSE(obj.has("33333"));
EXPECT_TRUE(obj.has("44444"));
EXPECT_TRUE(obj.has("55555"));
EXPECT_TRUE(obj.has("66666"));
EXPECT_TRUE(obj.has("77777"));
EXPECT_TRUE(obj.has("88888"));
EXPECT_TRUE(obj.has("99999"));
// 9
EXPECT_TRUE(obj.set("33333", "33333"));
EXPECT_TRUE(obj.has("00000"));
EXPECT_TRUE(obj.has("11111"));
EXPECT_TRUE(obj.has("22222"));
EXPECT_TRUE(obj.has("33333"));
EXPECT_TRUE(obj.has("44444"));
EXPECT_TRUE(obj.has("55555"));
EXPECT_TRUE(obj.has("66666"));
EXPECT_TRUE(obj.has("77777"));
EXPECT_TRUE(obj.has("88888"));
EXPECT_TRUE(obj.has("99999"));
EXPECT_EQ(10u, obj.size());
int index_ids[] = {0, 11111, 22222, 33333, 44444,
55555, 66666, 77777, 88888, 99999};
int i = 0;
for (JsonObject::iterator it = obj.begin(); it != obj.end(); ++it, ++i) {
EXPECT_EQ(it->value().as_integer(), index_ids[i]);
}
EXPECT_EQ(i, (int)obj.size());
}
{
JsonObject obj;
EXPECT_TRUE(obj.set("key0", "key0"));
EXPECT_TRUE(obj.set("key1", "key1"));
EXPECT_TRUE(obj.set("key2", "key2"));
EXPECT_TRUE(obj.set("key3", "key3"));
EXPECT_TRUE(obj.set("key4", "key4"));
EXPECT_TRUE(obj.set("key5", "key5"));
EXPECT_FALSE(obj.set("key0", "000000"));
EXPECT_FALSE(obj.set("key1", "000000"));
EXPECT_FALSE(obj.set("key5", "000000"));
EXPECT_EQ(obj.size(), 6u);
JsonString str;
EXPECT_TRUE(obj.get("key0", &str));
EXPECT_TRUE(str == JsonString("key0"));
EXPECT_TRUE(obj.get("key3", &str));
EXPECT_TRUE(str == JsonString("key3"));
EXPECT_TRUE(obj.get("key5", &str));
EXPECT_TRUE(str == JsonString("key5"));
EXPECT_EQ(obj.size(), 6u);
obj["key0"] = 0;
obj["key1"] = 1;
obj["key2"] = 2;
obj["key3"] = 3;
obj["key4"] = 4;
obj["key5"] = 5;
EXPECT_EQ(obj.size(), 6u);
int index_id = 0;
for (JsonObject::iterator it = obj.begin(); it != obj.end();
++it, ++index_id) {
EXPECT_EQ(it->value().as_integer(), index_id);
}
EXPECT_EQ(index_id, 6);
int index_id_r = 5;
for (JsonObject::reverse_iterator it = obj.rbegin(); it != obj.rend();
++it, --index_id_r) {
EXPECT_EQ(it->value().as_integer(), index_id_r);
}
EXPECT_EQ(index_id_r, -1);
}
{
JsonObject::reverse_iterator it1 = JsonObject::iterator();
JsonObject::reverse_iterator it2 = JsonObject::reverse_iterator();
EXPECT_TRUE(it1 == it2);
JsonObject::iterator it3 = JsonObject::reverse_iterator();
JsonObject::iterator it4 = JsonObject::iterator();
EXPECT_TRUE(it3 == it4);
JsonObject::const_iterator it5 = JsonObject::const_iterator();
JsonObject::const_iterator it6 = JsonObject::iterator();
EXPECT_TRUE(it5 == it6);
JsonObject::const_iterator it7 = JsonObject::reverse_iterator();
JsonObject::const_iterator it8 = JsonObject::const_reverse_iterator();
EXPECT_TRUE(it7 == it8);
JsonObject::const_reverse_iterator it9 = JsonObject::const_iterator();
JsonObject::const_reverse_iterator it10 = JsonObject::iterator();
EXPECT_TRUE(it9 == it10);
JsonObject::const_reverse_iterator it11 = JsonObject::reverse_iterator();
JsonObject::const_reverse_iterator it12 =
JsonObject::const_reverse_iterator();
EXPECT_TRUE(it11 == it12);
}
{
JsonObject obj1;
JsonObject obj2;
JsonObject obj3;
JsonObject::iterator iter1;
EXPECT_TRUE(obj1.set("aaa", "123456"));
obj2 = obj1;
iter1 = obj1.begin();
obj3 = obj1;
iter1->value() = "abcdefg";
EXPECT_TRUE(obj1["aaa"].as_string() == "abcdefg");
EXPECT_TRUE(obj2["aaa"].as_string() == "123456");
EXPECT_TRUE(obj3["aaa"].as_string() == "123456");
}
{
JsonObject obj1;
obj1.set("FTitle", "123456789");
obj1.set("FDesc", "abcdef");
const JsonObject &obj2 = obj1;
EXPECT_TRUE(obj1["FTitle"].as_stl_string() == "123456789");
EXPECT_TRUE(obj1["FDesc"].as_stl_string() == "abcdef");
EXPECT_TRUE(obj2["FTitle"].as_stl_string() == "123456789");
EXPECT_TRUE(obj2["FDesc"].as_stl_string() == "abcdef");
}
}
TEST(Json, JsonArray) {
{
JsonArray arr1;
arr1.push(JsonValue(0.0));
arr1.push(JsonValue(2));
arr1.push("2");
arr1.push(JsonValue(true));
arr1.push(JsonArray());
arr1.push(JsonObject());
arr1.push(JsonValue());
arr1.push(JsonString());
JsonArray arr2 = arr1;
EXPECT_TRUE(arr2 == arr1);
JsonArray arr3;
arr3.push(JsonValue(0.0));
arr3.push(JsonValue(2));
arr3.push("2");
arr3.push(JsonValue(true));
arr3.push(JsonArray());
arr3.push(JsonObject());
arr3.push(JsonValue());
arr3.push(JsonString());
EXPECT_TRUE(arr2 == arr3);
EXPECT_TRUE(arr1 == arr3);
arr2.push(JsonObject());
EXPECT_TRUE(arr2 != arr3);
EXPECT_TRUE(arr2 != arr1);
EXPECT_TRUE(arr1 == arr3);
}
{
JsonArray jarr;
EXPECT_TRUE(jarr.capacity() == 0);
EXPECT_TRUE(jarr.size() == 0);
jarr.reserve(21);
EXPECT_TRUE(jarr.capacity() == 32);
EXPECT_TRUE(jarr.size() == 0);
jarr.reserve(2);
EXPECT_TRUE(jarr.capacity() == 32);
EXPECT_TRUE(jarr.size() == 0);
jarr.reserve(33);
EXPECT_TRUE(jarr.capacity() == 64);
EXPECT_TRUE(jarr.size() == 0);
}
{
JsonArray arr1;
JsonArray arr2;
JsonArray arr3;
JsonArray::iterator iter1;
arr1.push("123456");
arr2 = arr1;
iter1 = arr1.begin();
arr3 = arr1;
*iter1 = "abcdefg";
EXPECT_TRUE(arr1[0].as_string() == "abcdefg");
EXPECT_TRUE(arr2[0].as_string() == "123456");
EXPECT_TRUE(arr3[0].as_string() == "123456");
}
{
JsonArray arr1;
JsonArray arr2;
JsonArray arr3;
arr1.push("123456");
arr2 = arr1;
JsonValue &val1 = arr1.front();
arr3 = arr1;
val1 = "abcdefg";
EXPECT_TRUE(arr1[0].as_string() == "abcdefg");
EXPECT_TRUE(arr2[0].as_string() == "123456");
EXPECT_TRUE(arr3[0].as_string() == "123456");
}
{
JsonArray arr;
JsonValue val(666);
arr.push("0");
arr.push(JsonValue(1));
arr.push(JsonValue(2));
arr.push("3");
arr.push("4");
arr.push("5");
arr.push("6");
arr.push(JsonValue(7.0));
EXPECT_TRUE(arr.size() == 8);
EXPECT_TRUE(arr.capacity() == 32);
EXPECT_TRUE(arr[0].as_string() == "0");
EXPECT_TRUE(arr[1].as_integer() == 1);
EXPECT_TRUE(arr[2].as_integer() == 2);
EXPECT_TRUE(arr[3].as_integer() == 3);
EXPECT_TRUE(arr[4].as_integer() == 4);
EXPECT_TRUE(arr[5].as_integer() == 5);
EXPECT_TRUE(arr[6].as_integer() == 6);
EXPECT_TRUE(arr[7].as_integer() == 7);
arr.resize(20, val);
EXPECT_TRUE(arr.size() == 20);
arr.resize(5, val);
EXPECT_TRUE(arr.size() == 5);
EXPECT_TRUE(arr[0].as_string() == "0");
EXPECT_TRUE(arr[1].as_integer() == 1);
EXPECT_TRUE(arr[2].as_integer() == 2);
EXPECT_TRUE(arr[3].as_string() == "3");
EXPECT_TRUE(arr[4].as_string() == "4");
EXPECT_TRUE(val.as_integer() == 666);
arr.reverse();
EXPECT_TRUE(arr.size() == 5);
EXPECT_TRUE(arr[4].as_string() == "0");
EXPECT_TRUE(arr[3].as_integer() == 1);
EXPECT_TRUE(arr[2].as_integer() == 2);
EXPECT_TRUE(arr[1].as_string() == "3");
EXPECT_TRUE(arr[0].as_string() == "4");
arr.shift();
arr.reverse();
EXPECT_TRUE(arr.size() == 4);
EXPECT_TRUE(arr[0].as_string() == "0");
EXPECT_TRUE(arr[1].as_integer() == 1);
EXPECT_TRUE(arr[2].as_integer() == 2);
EXPECT_TRUE(arr[3].as_string() == "3");
}
{
JsonArray::reverse_iterator it1 = JsonArray::iterator();
JsonArray::reverse_iterator it2 = JsonArray::reverse_iterator();
EXPECT_TRUE(it1 == it2);
JsonArray::iterator it3 = JsonArray::reverse_iterator();
JsonArray::iterator it4 = JsonArray::iterator();
EXPECT_TRUE(it3 == it4);
JsonArray::const_iterator it5 = JsonArray::const_iterator();
JsonArray::const_iterator it6 = JsonArray::iterator();
EXPECT_TRUE(it5 == it6);
JsonArray::const_iterator it7 = JsonArray::reverse_iterator();
JsonArray::const_iterator it8 = JsonArray::const_reverse_iterator();
EXPECT_TRUE(it7 == it8);
JsonArray::const_reverse_iterator it9 = JsonArray::const_iterator();
JsonArray::const_reverse_iterator it10 = JsonArray::iterator();
EXPECT_TRUE(it9 == it10);
JsonArray::const_reverse_iterator it11 = JsonArray::reverse_iterator();
JsonArray::const_reverse_iterator it12 =
JsonArray::const_reverse_iterator();
EXPECT_TRUE(it11 == it12);
}
{
JsonArray arr;
arr.resize(1023);
EXPECT_TRUE(arr.size() == 1023);
EXPECT_TRUE(arr.capacity() == 1024);
EXPECT_TRUE(arr[0].is_null());
EXPECT_TRUE(arr[1022].is_null());
}
{
JsonArray arr;
EXPECT_TRUE(arr.capacity() == 0);
arr.resize(0);
EXPECT_TRUE(arr.capacity() == 32);
arr.push(nullptr);
EXPECT_TRUE(arr.capacity() == 32);
EXPECT_TRUE(arr.size() == 1);
arr.resize(0);
EXPECT_TRUE(arr.size() == 0);
arr.resize(1);
EXPECT_TRUE(arr.capacity() == 32);
EXPECT_TRUE(arr.size() == 1);
}
{
JsonValue val;
EXPECT_TRUE(val.parse("[0, 1]"));
EXPECT_TRUE(val.as_array().front() == 0);
EXPECT_TRUE(val.as_array().front().as_integer() == 0);
}
{
JsonValue val;
EXPECT_TRUE(val.parse("[-1]"));
EXPECT_TRUE(val.as_array().front() == -1);
EXPECT_TRUE(val.as_array().front().as_integer() == -1);
EXPECT_TRUE(val.as_array().front().as_integer() == -1);
EXPECT_TRUE(val.as_array().front().as_integer() == -1);
}
{
JsonValue val;
EXPECT_TRUE(val.parse("[4294967295]"));
EXPECT_TRUE(val.parse("[+4294967295]"));
EXPECT_TRUE(val.as_array().front() == 4294967295);
EXPECT_TRUE((int32_t)val.as_array().front().as_integer() == -1);
EXPECT_TRUE(val.as_array().front().as_integer() == 4294967295);
}
{
JsonValue val;
EXPECT_TRUE(val.parse("[ 2147483647 ]"));
EXPECT_TRUE(val.parse("[ +2147483647 ]"));
EXPECT_TRUE(val.as_array().front() == 2147483647);
EXPECT_TRUE(val.as_array().front().as_integer() == 2147483647);
EXPECT_TRUE(val.as_array().front().as_integer() == 2147483647);
EXPECT_TRUE(val.as_array().front().as_integer() == 2147483647);
}
{
JsonValue val;
EXPECT_TRUE(val.parse("[ -2147483647 ]"));
EXPECT_TRUE(val.as_array().front() == -2147483647);
EXPECT_TRUE(val.as_array().front().as_integer() == -2147483647);
EXPECT_TRUE(val.as_array().front().as_integer() == -2147483647);
EXPECT_TRUE(val.as_array().front().as_integer() == -2147483647);
}
{
JsonValue val;
EXPECT_TRUE(val.parse("[9223372036854775807]"));
EXPECT_TRUE(val.parse("[+9223372036854775807]"));
EXPECT_TRUE(val.as_array().front() == 9223372036854775807uLL);
EXPECT_TRUE((int32_t)val.as_array().front().as_integer() == -1);
EXPECT_TRUE(val.as_array().front().as_integer() == 9223372036854775807uLL);
}
{
JsonValue val;
EXPECT_TRUE(val.parse("[-9223372036854775807]"));
EXPECT_TRUE(val.as_array().front() == -9223372036854775807LL);
EXPECT_TRUE(val.as_array().front().as_integer() == -9223372036854775807LL);
}
{
JsonValue val;
EXPECT_TRUE(val.parse("[ 1844674407370955161 ]"));
EXPECT_TRUE(val.parse("[ +1844674407370955161 ]"));
EXPECT_TRUE(val.as_array().front() == 1844674407370955161uLL);
EXPECT_TRUE(val.as_array().front().as_integer() == 1844674407370955161uLL);
}
{
JsonValue val;
EXPECT_TRUE(val.parse("[ 18446744073709551615 ]"));
EXPECT_TRUE(val.parse("[ +18446744073709551615 ]"));
EXPECT_TRUE(val.as_array().front() == 18446744073709551615uLL);
EXPECT_TRUE(val.as_array().front().as_integer() == -1);
EXPECT_TRUE(val.as_array().front().as_integer() ==
JsonValue::integer_type(18446744073709551615uLL));
}
{
JsonValue val;
EXPECT_TRUE(val.parse("[ 18446744073709551616 ]"));
EXPECT_FALSE(val.as_array().front().is_integer());
EXPECT_TRUE(val.as_array().front() == 18446744073709551616.0);
EXPECT_TRUE(val.as_array().front().as_float() == 18446744073709551616.0);
}
{
JsonValue val;
EXPECT_TRUE(val.parse("[ 1e+30, 1.3e12 ]"));
EXPECT_TRUE(val.as_array().front() == 1e+30);
EXPECT_TRUE(val.as_array().back() == 1.3e12);
}
{
JsonValue val;
EXPECT_TRUE(val.parse("[0,[0]]"));
EXPECT_TRUE(val.refer() == 1);
EXPECT_TRUE(val.as_array().refer() == 1);
EXPECT_TRUE(val.refer() == 0);
val.as_array().push(val);
EXPECT_TRUE(val.as_json_string() == "[0,[0],[0,[0]]]");
val.as_array().pop();
val.as_array().push(val);
EXPECT_TRUE(val.as_json_string() == "[0,[0],[0,[0]]]");
val.as_array().pop();
val.as_array().pop();
val.as_array().pop();
val.as_array().push(val);
EXPECT_TRUE(val.as_json_string() == "[[]]");
}
{
JsonValue val;
EXPECT_TRUE(val.parse("[0,[0]]"));
EXPECT_TRUE(val.refer() == 1);
EXPECT_TRUE(val.as_array().refer() == 1);
EXPECT_TRUE(val.refer() == 0);
val.as_array()[0] = val;
EXPECT_TRUE(val.as_json_string() == "[[0,[0]],[0]]");
}
{
JsonValue val;
EXPECT_TRUE(val.parse("{\"0\":[0]}"));
EXPECT_TRUE(val.refer() == 1);
EXPECT_TRUE(val.as_object().refer() == 1);
EXPECT_TRUE(val.refer() == 0);
JsonObject obj = val.as_object();
val.as_object()["1"].assign(obj);
EXPECT_TRUE(val.as_json_string() == "{\"0\":[0],\"1\":{\"0\":[0]}}");
}
{
JsonValue val;
EXPECT_TRUE(val.parse("{\"0\":[0]}"));
EXPECT_TRUE(val.refer() == 1);
EXPECT_TRUE(val.as_object().refer() == 1);
EXPECT_TRUE(val.refer() == 0);
EXPECT_TRUE(val.as_object().set("1", val));
EXPECT_TRUE(val.as_json_string() == "{\"0\":[0],\"1\":{\"0\":[0]}}");
}
{
JsonValue val;
EXPECT_TRUE(val.parse("{\"0\":[0]}"));
EXPECT_TRUE(val.refer() == 1);
EXPECT_TRUE(val.as_object().refer() == 1);
EXPECT_TRUE(val.refer() == 0);
JsonValue val2 = val;
val.as_object()["1"] = val2;
EXPECT_TRUE(val.as_json_string() == "{\"0\":[0],\"1\":{\"0\":[0]}}");
}
{
JsonValue val;
EXPECT_TRUE(val.parse("{\"0\":[0]}"));
EXPECT_TRUE(val.refer() == 1);
EXPECT_TRUE(val.as_object().refer() == 1);
EXPECT_TRUE(val.refer() == 0);
JsonObject obj = val.as_object();
val.as_object()["1"] = obj;
EXPECT_TRUE(val.as_json_string() == "{\"0\":[0],\"1\":{\"0\":[0]}}");
}
}
TEST(Json, JsonString) {
{
JsonString str1("1234567890abcdefghijklmn");
EXPECT_TRUE(str1 == str1.decode());
}
{
JsonString str1("\\\"1234\\\\567890abcdefghijklmn\\t");
JsonString str2 = "\"1234\\567890abcdefghijklmn\t";
EXPECT_TRUE(str2 == str1.decode());
}
{
JsonString str1(" \\/ \\\\ \\\" \\b \\f \\n \\r \\t ");
JsonString str2 = " / \\ \" \b \f \n \r \t ";
EXPECT_TRUE(str2 == str1.decode());
}
{
JsonString str1("\\n\\r \\u8096 \\u5141 \\u950B \\u000a \\u000d");
JsonString str2("\n\r \xE8\x82\x96 \xE5\x85\x81 \xE9\x94\x8B \n \r");
EXPECT_TRUE(str2 == str1.decode());
}
{
JsonString str1("\\u007f");
JsonString str2("\x7F");
EXPECT_TRUE(str2 == str1.decode());
}
{
JsonString str1("\\u0080");
JsonString str2("\xC2\x80");
EXPECT_TRUE(str2 == str1.decode());
}
{
JsonString str1("\\u07FF");
JsonString str2("\xDF\xBF");
EXPECT_TRUE(str2 == str1.decode());
}
{
JsonString str1("\\u0800");
JsonString str2("\xE0\xA0\x80");
EXPECT_TRUE(str2 == str1.decode());
}
{
JsonString str1("\\uFFFF");
JsonString str2("\xEF\xBF\xBF");
EXPECT_TRUE(str2 == str1.decode());
}
{
JsonString a("abcdefg");
JsonString b("abcdefl");
JsonString c("abcdefg");
EXPECT_TRUE(a == c);
EXPECT_TRUE(b != c);
EXPECT_TRUE(b != a);
EXPECT_TRUE(a.compare(c) == 0);
EXPECT_TRUE(b.compare(c) != 0);
EXPECT_TRUE(b.compare(c) != 0);
}
{
JsonString a("abcdefg\"");
JsonString b("abcd");
JsonString c("abcdefg");
EXPECT_TRUE(a != c);
EXPECT_TRUE(b != c);
EXPECT_TRUE(b != a);
}
{
JsonString a("abcd\0efg");
JsonString b("abcd");
JsonString c("abcdefg\0");
EXPECT_TRUE(a != c);
EXPECT_TRUE(b != c);
EXPECT_TRUE(b == a);
EXPECT_TRUE(a.compare(b) == 0);
}
{
JsonString a("abcd\0efg", 8);
JsonString b("abcd");
JsonString c("abcdefg\0");
EXPECT_TRUE(a != c);
EXPECT_TRUE(b != c);
EXPECT_TRUE(b != a);
EXPECT_TRUE(a.compare("abcd") == 0);
EXPECT_TRUE(b.compare("abcd\0") == 0);
EXPECT_TRUE(c.compare("abcdefg") == 0);
}
{
JsonString a("abcd\0efg", 8);
JsonString b("abcd");
JsonString c("abcd\0efg", 8);
EXPECT_TRUE(a == c);
EXPECT_TRUE(b != c);
EXPECT_TRUE(b != a);
}
{
JsonString a;
JsonString b("\0");
JsonString c(nullptr);
EXPECT_TRUE(a == c);
EXPECT_TRUE(b == c);
EXPECT_TRUE(b == a);
}
{
JsonString a;
JsonString b("\0", 1);
JsonString c(nullptr);
EXPECT_TRUE(a == c);
EXPECT_TRUE(b != c);
EXPECT_TRUE(b != a);
}
{
JsonString str1(
"author:\\u8096\\u5141\\u950b;\\r\\ntest:\\u007f \\u0080 \\u07ff "
"\\u0800 \\uffff");
JsonString str2(
"author:\xE8\x82\x96\xE5\x85\x81\xE9\x94\x8B;\r\ntest:"
"\x7F \xC2\x80 "
"\xDF\xBF \xE0\xA0\x80 \xEF\xBF\xBF");
JsonString str3(
"author:\xE8\x82\x96\xE5\x85\x81\xE9\x94\x8B;"
"\\r\\ntest:\x7F \xC2\x80 "
"\xDF\xBF \xE0\xA0\x80 \xEF\xBF\xBF");
EXPECT_TRUE(str2 == str1.decode());
EXPECT_TRUE(str2.encode() == str3);
}
{
JsonString str1("\\007f \\0080 \\u07ff \\u0800 \\uffff");
JsonString str2("\\u008\\u07ff \\u0800 \\uffff");
EXPECT_FALSE(str1.decode().is_valid());
EXPECT_FALSE(str2.decode().is_valid());
}
{
JsonString str1(" \x1f \x0e \x01 \x1e / \\ AAA\" AAA\b \f \n \r \t ");
JsonString str2(
" \\u001f \\u000e \\u0001 \\u001e / \\\\ AAA\\\" "
"AAA\\b \\f \\n \\r "
"\\t ");
EXPECT_TRUE(str1.encode() == str2);
EXPECT_TRUE(str1 == str2.decode());
}
{
JsonString jstr;
EXPECT_TRUE(jstr.capacity() == 0);
EXPECT_TRUE(jstr.size() == 0);
jstr.reserve(21);
EXPECT_TRUE(jstr.capacity() == 32 - 1);
EXPECT_TRUE(jstr.size() == 0);
jstr.reserve(2);
EXPECT_TRUE(jstr.capacity() == 32 - 1);
EXPECT_TRUE(jstr.size() == 0);
jstr.reserve(32);
EXPECT_TRUE(jstr.capacity() == 64 - 1);
EXPECT_TRUE(jstr.size() == 0);
char buf[1000];
buf[0] = '\0';
jstr.assign(buf, sizeof(buf));
EXPECT_TRUE(jstr.capacity() == 1024 - 1);
EXPECT_TRUE(jstr.length() == 1000);
EXPECT_TRUE(JsonString(jstr.c_str()) == "");
memcpy(buf, "abcdef", 7);
jstr.assign(buf, 200);
EXPECT_TRUE(jstr.capacity() == 1024 - 1);
EXPECT_TRUE(jstr.length() == 200);
EXPECT_TRUE(JsonString(jstr.c_str()) == "abcdef");
}
}
TEST(Json, JsonValue) {
{
EXPECT_TRUE(JsonValue(true) == JsonValue(true));
EXPECT_TRUE(JsonValue(false) == JsonValue(false));
EXPECT_TRUE(JsonValue((char)'\r') == JsonValue(0xd));
EXPECT_TRUE(JsonValue((char)'\r') == JsonValue('\r'));
EXPECT_TRUE(JsonValue(10000) == JsonValue(10000));
EXPECT_TRUE(JsonValue(0xffff) == JsonValue(0xffff));
EXPECT_TRUE(JsonValue(0x10000) == JsonValue(0x10000));
EXPECT_TRUE(JsonValue(0xffffffff) == JsonValue(0xffffffff));
EXPECT_TRUE(JsonValue(0x100000000) == JsonValue(0x100000000));
EXPECT_TRUE(JsonValue(0xffffffffffffffff) == JsonValue(0xffffffffffffffff));
EXPECT_TRUE(JsonValue(0.999999) == JsonValue(0.999999));
EXPECT_TRUE(JsonValue(false) != JsonValue(0.0));
EXPECT_TRUE(JsonValue(0.0) != JsonValue(0));
EXPECT_TRUE(JsonValue("0.0") != JsonValue(0));
EXPECT_TRUE(JsonValue("0.0") == JsonValue("0.0"));
EXPECT_TRUE(JsonValue(std::string("0.0001")) == JsonValue("0.0001"));
}
{
EXPECT_EQ(JsonValue(0).as_json_string().as_stl_string(), "0");
EXPECT_EQ(JsonValue(1).as_json_string().as_stl_string(), "1");
EXPECT_EQ(JsonValue(-1).as_json_string().as_stl_string(), "-1");
EXPECT_EQ(JsonValue(99).as_json_string().as_stl_string(), "99");
EXPECT_EQ(JsonValue(-99).as_json_string().as_stl_string(), "-99");
EXPECT_EQ(JsonValue(188).as_json_string().as_stl_string(), "188");
EXPECT_EQ(JsonValue(-188).as_json_string().as_stl_string(), "-188");
EXPECT_EQ(JsonValue(1520).as_json_string().as_stl_string(), "1520");
EXPECT_EQ(JsonValue(-1520).as_json_string().as_stl_string(), "-1520");
EXPECT_EQ(JsonValue(12345).as_json_string().as_stl_string(), "12345");
EXPECT_EQ(JsonValue(-12345).as_json_string().as_stl_string(), "-12345");
EXPECT_EQ(JsonValue(65535).as_json_string().as_stl_string(), "65535");
EXPECT_EQ(JsonValue(-65535).as_json_string().as_stl_string(), "-65535");
EXPECT_EQ(JsonValue(65536).as_json_string().as_stl_string(), "65536");
EXPECT_EQ(JsonValue(-65536).as_json_string().as_stl_string(), "-65536");
EXPECT_EQ(JsonValue(234567).as_json_string().as_stl_string(), "234567");
EXPECT_EQ(JsonValue(-234567).as_json_string().as_stl_string(), "-234567");
EXPECT_EQ(JsonValue(1234567890).as_json_string().as_stl_string(),
"1234567890");
EXPECT_EQ(JsonValue(-1234567890).as_json_string().as_stl_string(),
"-1234567890");
EXPECT_EQ(JsonValue(9999999999).as_json_string().as_stl_string(),
"9999999999");
EXPECT_EQ(JsonValue(-9999999999).as_json_string().as_stl_string(),
"-9999999999");
EXPECT_EQ(JsonValue(4294967295).as_json_string().as_stl_string(),
"4294967295");
// EXPECT_EQ(JsonValue(-4294967295).as_json_string().as_stl_string(),
// "-4294967295LL");
EXPECT_EQ(JsonValue(4294967296).as_json_string().as_stl_string(),
"4294967296");
EXPECT_EQ(JsonValue(-4294967296).as_json_string().as_stl_string(),
"-4294967296");
EXPECT_EQ(JsonValue(281474976710655).as_json_string().as_stl_string(),
"281474976710655");
EXPECT_EQ(JsonValue(-281474976710655).as_json_string().as_stl_string(),
"-281474976710655");
EXPECT_EQ(JsonValue(281474976710656).as_json_string().as_stl_string(),
"281474976710656");
EXPECT_EQ(JsonValue(-281474976710656).as_json_string().as_stl_string(),
"-281474976710656");
EXPECT_EQ(JsonValue(9223372036854775807ll).as_json_string().as_stl_string(),
"9223372036854775807");
EXPECT_EQ(
JsonValue(-9223372036854775807ll).as_json_string().as_stl_string(),
"-9223372036854775807");
}
{
JsonValue jval;
jval.assign("aaaaaaaaaaaa");
jval.assign("122326263", 10);
jval.assign(200);
jval.assign(0xffffffffffff);
}
{
JsonValue val1;
JsonValue val2;
JsonValue val3;
JsonValue val4;
val1 = "abcdef";
val2 = val1;
val3 = val1;
EXPECT_TRUE(val1.refer() == 3);
EXPECT_TRUE(val2.refer() == 3);
EXPECT_TRUE(val3.refer() == 3);
EXPECT_TRUE(val3.as_stl_string() == "abcdef");
JsonString &str = val1.as_string();
EXPECT_TRUE(str.refer() == 2);
val4 = val1;
str = "123456";
EXPECT_TRUE(val1.refer() == 0);
EXPECT_TRUE(val2.refer() == 2);
EXPECT_TRUE(val3.refer() == 2);
EXPECT_TRUE(val4.refer() == 1);
EXPECT_TRUE(val1.as_stl_string() == "123456");
EXPECT_TRUE(val2.as_stl_string() == "abcdef");
EXPECT_TRUE(val3.as_stl_string() == "abcdef");
EXPECT_TRUE(val4.as_stl_string() == "abcdef");
}
{
JsonValue val1;
JsonValue val2;
JsonValue val3;
val1["abcd"] = "1234";
val2 = val1.as_object();
val3 = val2;
EXPECT_TRUE(val1.refer() == 0);
EXPECT_TRUE(val2.refer() == 2);
EXPECT_TRUE(val3.refer() == 2);
EXPECT_TRUE(val1.as_object().refer() == 0);
EXPECT_TRUE(val2.as_object().refer() == 2);
EXPECT_TRUE(val3.as_object().refer() == 2);
}
}
TEST(Json, General) {
{
JsonObject obj;
JsonArray arr;
JsonValue val;
JsonString str;
EXPECT_TRUE(obj.refer() == -1);
EXPECT_TRUE(arr.refer() == -1);
EXPECT_TRUE(val.refer() == -1);
EXPECT_TRUE(str.refer() == -1);
val = str;
EXPECT_TRUE(val.refer() == 1);
val = obj;
EXPECT_TRUE(val.refer() == 1);
val = arr;
EXPECT_TRUE(val.refer() == 1);
arr.push("acdef");
EXPECT_TRUE(arr.refer() == 1);
arr.begin();
EXPECT_TRUE(arr.refer() == 0);
arr.end();
EXPECT_TRUE(arr.refer() == 0);
JsonArray arr1 = arr;
JsonArray arr2 = arr1;
JsonArray arr3 = arr;
EXPECT_TRUE(arr1.refer() == 2);
EXPECT_TRUE(arr2.refer() == 2);
EXPECT_TRUE(arr3.refer() == 1);
EXPECT_TRUE(arr.refer() == 0);
obj.set("1111", "null");
EXPECT_TRUE(obj.refer() == 1);
obj.rbegin();
EXPECT_TRUE(obj.refer() == 0);
obj.rend();
EXPECT_TRUE(obj.refer() == 0);
JsonObject obj1 = obj;
JsonObject obj2 = obj1;
JsonObject obj3 = obj;
EXPECT_TRUE(obj1.refer() == 2);
EXPECT_TRUE(obj2.refer() == 2);
EXPECT_TRUE(obj3.refer() == 1);
EXPECT_TRUE(obj.refer() == 0);
}
{
short a = 1;
enum { A = 1, B = 2 };
EXPECT_TRUE(a == A);
EXPECT_TRUE(A == a);
EXPECT_TRUE(a != B);
EXPECT_TRUE(B != a);
}
{
unsigned short a = 1;
enum { A = 1, B = 2 };
EXPECT_TRUE(a == A);
EXPECT_TRUE(A == a);
EXPECT_TRUE(a != B);
EXPECT_TRUE(B != a);
}
{
int a = 1;
enum { A = 1, B = 2 };
EXPECT_TRUE(a == A);
EXPECT_TRUE(A == a);
EXPECT_TRUE(a != B);
EXPECT_TRUE(B != a);
}
{
unsigned int a = 1;
enum { A = 1, B = 2 };
EXPECT_TRUE(a == A);
EXPECT_TRUE(A == a);
EXPECT_TRUE(a != B);
EXPECT_TRUE(B != a);
}
{
long a = 1;
enum { A = 1, B = 2 };
EXPECT_TRUE(a == A);
EXPECT_TRUE(A == a);
EXPECT_TRUE(a != B);
EXPECT_TRUE(B != a);
}
{
unsigned long a = 1;
enum { A = 1, B = 2 };
EXPECT_TRUE(a == A);
EXPECT_TRUE(A == a);
EXPECT_TRUE(a != B);
EXPECT_TRUE(B != a);
}
{
long long a = 1;
enum { A = 1, B = 2 };
EXPECT_TRUE(a == A);
EXPECT_TRUE(A == a);
EXPECT_TRUE(a != B);
EXPECT_TRUE(B != a);
}
{
unsigned long long a = 1;
enum { A = 1, B = 2 };
EXPECT_TRUE(a == A);
EXPECT_TRUE(A == a);
EXPECT_TRUE(a != B);
EXPECT_TRUE(B != a);
}
{
float a = 1;
enum { A = 1, B = 2 };
EXPECT_TRUE(a == A);
EXPECT_TRUE(A == a);
EXPECT_TRUE(a != B);
EXPECT_TRUE(B != a);
}
{
double a = 1;
enum { A = 1, B = 2 };
EXPECT_TRUE(a == A);
EXPECT_TRUE(A == a);
EXPECT_TRUE(a != B);
EXPECT_TRUE(B != a);
}
{
EXPECT_TRUE(JsonString() == JsonString());
EXPECT_TRUE(JsonValue() == JsonValue());
EXPECT_TRUE(JsonObject() == JsonObject());
EXPECT_TRUE(JsonArray() == JsonArray());
EXPECT_FALSE((JsonString() != JsonString()));
EXPECT_FALSE((JsonValue() != JsonValue()));
EXPECT_FALSE((JsonObject() != JsonObject()));
EXPECT_FALSE((JsonArray() != JsonArray()));
EXPECT_TRUE(JsonString() != JsonValue());
EXPECT_TRUE(JsonObject() != JsonValue());
EXPECT_TRUE(JsonArray() != JsonValue());
EXPECT_TRUE(JsonValue() != JsonString());
EXPECT_TRUE(JsonValue() != JsonObject());
EXPECT_TRUE(JsonValue() != JsonArray());
EXPECT_FALSE((JsonString() == JsonValue()));
EXPECT_FALSE((JsonObject() == JsonValue()));
EXPECT_FALSE((JsonArray() == JsonValue()));
EXPECT_FALSE((JsonValue() == JsonString()));
EXPECT_FALSE((JsonValue() == JsonObject()));
EXPECT_FALSE((JsonValue() == JsonArray()));
EXPECT_TRUE(JsonString() == std::string());
EXPECT_TRUE(std::string() == JsonString());
EXPECT_FALSE((JsonString() != std::string()));
EXPECT_FALSE((std::string() != JsonString()));
EXPECT_TRUE(JsonString() == std::string(""));
EXPECT_TRUE(std::string("") == JsonString());
EXPECT_FALSE((JsonString() != std::string("")));
EXPECT_FALSE((std::string("") != JsonString()));
EXPECT_TRUE(JsonString("") == std::string());
EXPECT_TRUE(std::string() == JsonString(""));
EXPECT_FALSE((JsonString("") != std::string()));
EXPECT_FALSE((std::string() != JsonString("")));
}
}
Reference in New Issue View Git Blame Copy Permalink