• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include <string>
16 #include <fstream>
17 #include "gtest/gtest.h"
18 #include "JsonReader.h"
19 using namespace std;
20 
21 namespace {
22     string g_name = "jin";
23     bool g_isChild = true;
24     int32_t g_age = 13;
25     uint32_t g_code1 = 214748;
26     int64_t g_code2 = 3333333333;
27     double g_height = 165.3;
28     string g_schoolName = "abc";
29     string g_schoolAddr = "cba";
30     string g_newName = "li";
31     bool g_newIsChild = false;
32     int32_t g_newAge = 26;
33     uint32_t g_newCode1 = 2147489;
34     int64_t g_newCode2 = 3333333339;
35     double g_newHeight = 185.3;
36     string g_obj = R"({"name":"jin","isChild":true,"age":13,"code1":214748,"code2":3333333333,
37         "height":165.3,"school":{"schoolName":"abc","schoolAddr":"cba"}})";
38     string g_arr = "[\"jin\",true,13,214748,3333333333,165.3,{\"schoolName\":\"abc\",\"schoolAddr\":\"cba\"}]";
39 
TEST(JsonReaderTest,ParseJsonData2Test)40     TEST(JsonReaderTest, ParseJsonData2Test)
41     {
42         int age = 20;
43         std::string str = "{\"name\":\"jin\", \"age\":20}";
44         Json2::Value val = JsonReader::ParseJsonData2(str);
45         EXPECT_EQ(val["name"].AsString(), "jin");
46         EXPECT_EQ(val["age"].AsInt(), age);
47     }
48 
TEST(JsonReaderTest,CreateObjectTest)49     TEST(JsonReaderTest, CreateObjectTest)
50     {
51         Json2::Value school = JsonReader::CreateObject();
52         school.Add("schoolName", g_schoolName.c_str());
53         school.Add("schoolAddr", g_schoolAddr.c_str());
54         Json2::Value student = JsonReader::CreateObject();
55         student.Add("name", g_name.c_str());
56         EXPECT_EQ(student["name"].AsString(), g_name);
57         student.Add("isChild", g_isChild);
58         EXPECT_EQ(student["isChild"].AsBool(), g_isChild);
59         student.Add("age", g_age);
60         EXPECT_EQ(student["age"].AsInt(), g_age);
61         student.Add("code1", g_code1);
62         EXPECT_EQ(student["code1"].AsUInt(), g_code1);
63         student.Add("code2", g_code2);
64         EXPECT_EQ(student["code2"].AsInt64(), g_code2);
65         student.Add("height", g_height);
66         EXPECT_EQ(student["height"].AsDouble(), g_height);
67         student.Add("school", school);
68         EXPECT_EQ(student["school"]["schoolName"].AsString(), g_schoolName);
69         EXPECT_EQ(student["school"]["schoolAddr"].AsString(), g_schoolAddr);
70     }
71 
TEST(JsonReaderTest,CreateArrayTest)72     TEST(JsonReaderTest, CreateArrayTest)
73     {
74         Json2::Value school = JsonReader::CreateObject();
75         school.Add("schoolName", g_schoolName.c_str());
76         school.Add("schoolAddr", g_schoolAddr.c_str());
77         Json2::Value books = JsonReader::CreateArray();
78         books.Add(g_name.c_str());
79         books.Add(g_isChild);
80         books.Add(g_age);
81         books.Add(g_code1);
82         books.Add(g_code2);
83         books.Add(g_height);
84         books.Add(school);
85         int size = 7;
86         int actualSize = books.GetArraySize();
87         EXPECT_EQ(actualSize, size);
88         int index = 0;
89         EXPECT_EQ(books.GetArrayItem(index++).AsString(), g_name);
90         EXPECT_EQ(books.GetArrayItem(index++).AsBool(), g_isChild);
91         EXPECT_EQ(books.GetArrayItem(index++).AsInt(), g_age);
92         EXPECT_EQ(books.GetArrayItem(index++).AsUInt(), g_code1);
93         EXPECT_EQ(books.GetArrayItem(index++).AsInt64(), g_code2);
94         EXPECT_EQ(books.GetArrayItem(index++).AsDouble(), g_height);
95         EXPECT_EQ(books.GetArrayItem(index)["schoolName"].AsString(), g_schoolName);
96         EXPECT_EQ(books.GetArrayItem(index)["schoolAddr"].AsString(), g_schoolAddr);
97     }
98 
TEST(JsonReaderTest,CreateBoolTest)99     TEST(JsonReaderTest, CreateBoolTest)
100     {
101         Json2::Value resultJson = JsonReader::CreateObject();
102         resultJson.Add("result", JsonReader::CreateBool(true));
103         EXPECT_TRUE(resultJson["result"].AsBool());
104     }
105 
TEST(JsonReaderTest,CreateStringTest)106     TEST(JsonReaderTest, CreateStringTest)
107     {
108         std::string content = "content";
109         Json2::Value resultJson = JsonReader::CreateObject();
110         resultJson.Add("content", JsonReader::CreateString(content));
111         EXPECT_EQ(resultJson["content"].AsString(), content);
112     }
113 
TEST(JsonReaderTest,DepthCopyTest)114     TEST(JsonReaderTest, DepthCopyTest)
115     {
116         std::string content = "content";
117         Json2::Value resultJson = JsonReader::CreateObject();
118         resultJson.Add("content", JsonReader::CreateString(content));
119         Json2::Value newJson = JsonReader::DepthCopy(resultJson);
120         resultJson.Clear();
121         EXPECT_EQ(newJson["content"].AsString(), content);
122     }
123 
TEST(JsonReaderTest,ObjectReplaceTest)124     TEST(JsonReaderTest, ObjectReplaceTest)
125     {
126         Json2::Value objVal = JsonReader::ParseJsonData2(g_obj);
127         objVal.Replace("name", g_newName.c_str());
128         EXPECT_EQ(objVal["name"].AsString(), g_newName);
129         objVal.Replace("isChild", g_newIsChild);
130         EXPECT_EQ(objVal["isChild"].AsBool(), g_newIsChild);
131         objVal.Replace("age", g_newAge);
132         EXPECT_EQ(objVal["age"].AsInt(), g_newAge);
133         objVal.Replace("code1", g_newCode1);
134         EXPECT_EQ(objVal["code1"].AsUInt(), g_newCode1);
135         objVal.Replace("code2", g_newCode2);
136         EXPECT_EQ(objVal["code2"].AsInt64(), g_newCode2);
137         objVal.Replace("height", g_newHeight);
138         EXPECT_EQ(objVal["height"].AsDouble(), g_newHeight);
139         std::string content = "content";
140         Json2::Value resultJson = JsonReader::CreateObject();
141         resultJson.Add("content", JsonReader::CreateString(content));
142         objVal.Replace("school", resultJson);
143         EXPECT_EQ(objVal["school"]["content"].AsString(), content);
144     }
145 
TEST(JsonReaderTest,ArrayReplaceTest)146     TEST(JsonReaderTest, ArrayReplaceTest)
147     {
148         Json2::Value arrVal = JsonReader::ParseJsonData2(g_arr);
149         int index = 0;
150         arrVal.Replace(index, g_newName.c_str());
151         EXPECT_EQ(arrVal.GetArrayItem(index++).AsString(), g_newName);
152         arrVal.Replace(index, g_newIsChild);
153         EXPECT_EQ(arrVal.GetArrayItem(index++).AsBool(), g_newIsChild);
154         arrVal.Replace(index, g_newAge);
155         EXPECT_EQ(arrVal.GetArrayItem(index++).AsInt(), g_newAge);
156         arrVal.Replace(index, g_newCode1);
157         EXPECT_EQ(arrVal.GetArrayItem(index++).AsUInt(), g_newCode1);
158         arrVal.Replace(index, g_newCode2);
159         EXPECT_EQ(arrVal.GetArrayItem(index++).AsInt64(), g_newCode2);
160         arrVal.Replace(index, g_newHeight);
161         EXPECT_EQ(arrVal.GetArrayItem(index++).AsDouble(), g_newHeight);
162         std::string content = "content";
163         Json2::Value resultJson = JsonReader::CreateObject();
164         resultJson.Add("content", JsonReader::CreateString(content));
165         arrVal.Replace(index, resultJson);
166         EXPECT_EQ(arrVal.GetArrayItem(index)["content"].AsString(), content);
167     }
168 
TEST(JsonReaderTest,IsValueTest)169     TEST(JsonReaderTest, IsValueTest)
170     {
171         Json2::Value arrVal = JsonReader::ParseJsonData2(g_arr);
172         EXPECT_TRUE(arrVal.IsArray());
173         Json2::Value objVal = JsonReader::ParseJsonData2(g_obj);
174         EXPECT_FALSE(objVal.IsNull());
175         EXPECT_TRUE(objVal.IsMember("school"));
176         EXPECT_TRUE(objVal["name"].IsString());
177         EXPECT_TRUE(objVal["age"].IsNumber());
178         EXPECT_TRUE(objVal["age"].IsInt());
179         EXPECT_TRUE(objVal["code1"].IsUInt());
180         EXPECT_TRUE(objVal["code2"].IsUInt64());
181         EXPECT_TRUE(objVal["isChild"].IsBool());
182         EXPECT_TRUE(objVal["height"].IsDouble());
183     }
184 
TEST(JsonReaderTest,GetValueTest)185     TEST(JsonReaderTest, GetValueTest)
186     {
187         Json2::Value objVal = JsonReader::ParseJsonData2(g_obj);
188         EXPECT_EQ(objVal.GetString("name"), g_name);
189         EXPECT_EQ(objVal.GetBool("isChild"), g_isChild);
190         EXPECT_EQ(objVal.GetInt("age"), g_age);
191         EXPECT_EQ(objVal.GetUInt("code1"), g_code1);
192         EXPECT_EQ(objVal.GetInt64("code2"), g_code2);
193         EXPECT_EQ(objVal.GetFloat("height"), (float)g_height);
194         EXPECT_EQ(objVal.GetDouble("height"), g_height);
195         EXPECT_EQ(objVal.GetDouble("height1", 0.0), 0.0); // key not exist retrun default value
196         EXPECT_EQ(objVal.GetValue("school").GetString("schoolName"), g_schoolName);
197         EXPECT_EQ(objVal.GetValue("school").GetString("schoolAddr"), g_schoolAddr);
198     }
199 
TEST(JsonReaderTest,OperatorBracketCharPtrTest)200     TEST(JsonReaderTest, OperatorBracketCharPtrTest)
201     {
202         Json2::Value objVal = JsonReader::ParseJsonData2(g_obj);
203         const char* key = "name";
204         Json2::Value name = objVal[key];
205         std::string value = name.AsString();
206         EXPECT_EQ(value, g_name);
207         // key not exist
208         const char* key2 = "name22";
209         Json2::Value name2 = objVal[key2];
210         std::string value2 = name2.AsString();
211         EXPECT_EQ(value2, "");
212     }
213 
TEST(JsonReaderTest,OperatorBracketConstCharPtrTest)214     TEST(JsonReaderTest, OperatorBracketConstCharPtrTest)
215     {
216         const Json2::Value objVal = static_cast<const Json2::Value>(JsonReader::ParseJsonData2(g_obj));
217         const char* key = "name";
218         const Json2::Value name = objVal[key];
219         std::string value = name.AsString();
220         EXPECT_EQ(value, g_name);
221         // key not exist
222         const char* key2 = "name22";
223         Json2::Value name2 = objVal[key2];
224         std::string value2 = name2.AsString();
225         EXPECT_EQ(value2, "");
226     }
227 
TEST(ValueTest,OperatorBracketStdStringTest)228     TEST(ValueTest, OperatorBracketStdStringTest)
229     {
230         Json2::Value objVal = JsonReader::ParseJsonData2(g_obj);
231         std::string key = "name";
232         Json2::Value name = objVal[key];
233         std::string value = name.AsString();
234         EXPECT_EQ(value, g_name);
235         // key not exist
236         std::string key2 = "name22";
237         Json2::Value name2 = objVal[key2];
238         std::string value2 = name2.AsString();
239         EXPECT_EQ(value2, "");
240     }
241 
TEST(ValueTest,OperatorBracketConstStdStringTest)242     TEST(ValueTest, OperatorBracketConstStdStringTest)
243     {
244         const Json2::Value objVal = static_cast<const Json2::Value>(JsonReader::ParseJsonData2(g_obj));
245         std::string key = "name";
246         const Json2::Value name = objVal[key];
247         std::string value = name.AsString();
248         EXPECT_EQ(value, g_name);
249         // key not exist
250         std::string key2 = "name22";
251         Json2::Value name2 = objVal[key2];
252         std::string value2 = name2.AsString();
253         EXPECT_EQ(value2, "");
254     }
255 
TEST(ValueTest,GetMemberNamesTest)256     TEST(ValueTest, GetMemberNamesTest)
257     {
258         Json2::Value objVal = JsonReader::ParseJsonData2(g_obj);
259         Json2::Value::Members members = objVal.GetMemberNames();
260         int size = 7;
261         int memberSize = members.size();
262         EXPECT_EQ(memberSize, size);
263     }
264 
TEST(ValueTest,ToStringTest_NoJsonPtr)265     TEST(ValueTest, ToStringTest_NoJsonPtr)
266     {
267         Json2::Value objVal = JsonReader::ParseJsonData2(g_obj);
268         std::string key2 = "name22";
269         Json2::Value name2 = objVal[key2];
270         std::string str = name2.ToString();
271         EXPECT_TRUE(str.empty());
272     }
273 
TEST(ValueTest,ToStyledStringTest)274     TEST(ValueTest, ToStyledStringTest)
275     {
276         // no jsonPtr
277         Json2::Value objVal = JsonReader::ParseJsonData2(g_obj);
278         std::string key1 = "name22";
279         Json2::Value name1= objVal[key1];
280         std::string str1 = name1.ToStyledString();
281         EXPECT_TRUE(str1.empty());
282         // jsonPtr exist
283         std::string key2 = "name";
284         Json2::Value name2= objVal[key2];
285         std::string str2 = name2.ToStyledString();
286         EXPECT_FALSE(str2.empty());
287     }
288 
TEST(ValueTest,IsIntTest)289     TEST(ValueTest, IsIntTest)
290     {
291         Json2::Value objVal = JsonReader::ParseJsonData2(g_obj);
292         std::string key1 = "name";
293         Json2::Value name = objVal[key1];
294         EXPECT_FALSE(name.IsInt());
295 
296         std::string key2 = "age";
297         Json2::Value age = objVal[key2];
298         EXPECT_TRUE(age.IsInt());
299     }
300 
TEST(ValueTest,IsUIntTest)301     TEST(ValueTest, IsUIntTest)
302     {
303         Json2::Value objVal = JsonReader::ParseJsonData2(g_obj);
304         std::string key1 = "name";
305         Json2::Value name = objVal[key1];
306         EXPECT_FALSE(name.IsUInt());
307 
308         std::string key2 = "age";
309         Json2::Value age = objVal[key2];
310         EXPECT_TRUE(age.IsUInt());
311     }
312 
TEST(ValueTest,IsInt64Test)313     TEST(ValueTest, IsInt64Test)
314     {
315         Json2::Value objVal = JsonReader::ParseJsonData2(g_obj);
316         std::string key1 = "name";
317         Json2::Value name = objVal[key1];
318         EXPECT_FALSE(name.IsInt64());
319 
320         std::string key2 = "age";
321         Json2::Value age = objVal[key2];
322         EXPECT_TRUE(age.IsInt64());
323     }
324 
TEST(ValueTest,IsUInt64Test)325     TEST(ValueTest, IsUInt64Test)
326     {
327         Json2::Value objVal = JsonReader::ParseJsonData2(g_obj);
328         std::string key1 = "name";
329         Json2::Value name = objVal[key1];
330         EXPECT_FALSE(name.IsUInt64());
331 
332         std::string key2 = "age";
333         Json2::Value age = objVal[key2];
334         EXPECT_TRUE(age.IsUInt64());
335     }
336 
TEST(ValueTest,IsDoubleTest)337     TEST(ValueTest, IsDoubleTest)
338     {
339         Json2::Value objVal = JsonReader::ParseJsonData2(g_obj);
340         std::string key1 = "name";
341         Json2::Value name = objVal[key1];
342         EXPECT_FALSE(name.IsDouble());
343 
344         std::string key2 = "age";
345         Json2::Value age = objVal[key2];
346         EXPECT_TRUE(age.IsDouble());
347     }
348 
TEST(ValueTest,IsObjectTest)349     TEST(ValueTest, IsObjectTest)
350     {
351         Json2::Value objVal = JsonReader::ParseJsonData2(g_obj);
352         std::string key = "school";
353         Json2::Value school = objVal[key];
354         EXPECT_TRUE(school.IsObject());
355     }
356 
TEST(ValueTest,GetBoolTest_TypeErr)357     TEST(ValueTest, GetBoolTest_TypeErr)
358     {
359         Json2::Value objVal = JsonReader::ParseJsonData2(g_obj);
360         bool ret = objVal.GetBool("name");
361         EXPECT_FALSE(ret);
362     }
363 
TEST(ValueTest,GetStringTest_TypeErr)364     TEST(ValueTest, GetStringTest_TypeErr)
365     {
366         Json2::Value objVal = JsonReader::ParseJsonData2(g_obj);
367         std::string ret = objVal.GetString("age");
368         EXPECT_EQ(ret, "");
369     }
370 
TEST(ValueTest,AsFolatTest_TypeErr)371     TEST(ValueTest, AsFolatTest_TypeErr)
372     {
373         Json2::Value objVal = JsonReader::ParseJsonData2(g_obj);
374         Json2::Value height = objVal.GetValue("height");
375         float val = height.AsFloat();
376         float expectVal = 165.3;
377         EXPECT_EQ(val, expectVal);
378     }
379 
TEST(ValueTest,AsDoubleTest_TypeErr)380     TEST(ValueTest, AsDoubleTest_TypeErr)
381     {
382         Json2::Value objVal = JsonReader::ParseJsonData2(g_obj);
383         Json2::Value name = objVal.GetValue("name");
384         double val = name.AsDouble();
385         float expectVal = 0.0;
386         EXPECT_EQ(val, expectVal);
387     }
388 
TEST(ValueTest,AsBoolTest_TypeErr)389     TEST(ValueTest, AsBoolTest_TypeErr)
390     {
391         Json2::Value objVal = JsonReader::ParseJsonData2(g_obj);
392         Json2::Value name = objVal.GetValue("name");
393         bool val = name.AsBool();
394         EXPECT_FALSE(val);
395     }
396 
TEST(JsonReaderTest,CreateNullTest)397     TEST(JsonReaderTest, CreateNullTest)
398     {
399         Json2::Value value = JsonReader::CreateNull();
400         EXPECT_TRUE(value.IsNull());
401     }
402 
TEST(JsonReaderTest,GetKeyTest)403     TEST(JsonReaderTest, GetKeyTest)
404     {
405         Json2::Value jsonData1 = JsonReader::ParseJsonData2(g_obj);
406         Json2::Value height = jsonData1.GetValue("height");
407         std::string str = height.GetKey();
408         EXPECT_EQ(str, "height");
409     }
410 
TEST(JsonReaderTest,ReadFileTest)411     TEST(JsonReaderTest, ReadFileTest)
412     {
413         std::string path = "1.json";
414         std::ofstream file(path);
415         if (!file) {
416             printf("Error creating file: %s\r\n", path.c_str());
417             EXPECT_TRUE(false);
418             return;
419         }
420         file << g_obj;
421         file.close();
422         std::string readStr = JsonReader::ReadFile(path);
423         EXPECT_EQ(readStr, g_obj);
424     }
425 
TEST(JsonReaderTest,GetErrorPtrTest)426     TEST(JsonReaderTest, GetErrorPtrTest)
427     {
428         Json2::Value jsonData = JsonReader::ParseJsonData2(g_obj);
429         std::string errors = JsonReader::GetErrorPtr();
430         EXPECT_FALSE(jsonData.IsNull());
431         EXPECT_TRUE(errors.empty());
432     }
433 
TEST(JsonReaderTest,AddTest_Err)434     TEST(JsonReaderTest, AddTest_Err)
435     {
436         Json2::Value jsonData = JsonReader::ParseJsonData2(g_obj);
437         // key is nullptr
438         const char* key = nullptr;
439         bool ret = jsonData.Add(key, "aaa");
440         EXPECT_FALSE(ret);
441         ret = jsonData.Add(key, false);
442         EXPECT_FALSE(ret);
443         double d = 22.0;
444         ret = jsonData.Add(key, d);
445         EXPECT_FALSE(ret);
446         std::string str = "{\"name\":\"jin\", \"age\":20}";
447         Json2::Value val = JsonReader::ParseJsonData2(str);
448         ret = jsonData.Add(key, val);
449         EXPECT_FALSE(ret);
450     }
451 
TEST(JsonReaderTest,AddTest_ArrayErr)452     TEST(JsonReaderTest, AddTest_ArrayErr)
453     {
454         Json2::Value jsonData = JsonReader::ParseJsonData2(g_obj);
455         bool ret = jsonData.Add("aaa");
456         EXPECT_FALSE(ret);
457         ret = jsonData.Add(false);
458         EXPECT_FALSE(ret);
459         double d = 436.96;
460         ret = jsonData.Add(d);
461         EXPECT_FALSE(ret);
462         Json2::Value val = JsonReader::CreateNull();
463         ret = jsonData.Add(val);
464         EXPECT_FALSE(ret);
465     }
466 
TEST(JsonReaderTest,ReplaceTest_Err)467     TEST(JsonReaderTest, ReplaceTest_Err)
468     {
469         Json2::Value jsonData = JsonReader::ParseJsonData2(g_obj);
470         // key is nullptr
471         const char* key = nullptr;
472         bool ret = jsonData.Replace(key, "aaa");
473         EXPECT_FALSE(ret);
474         ret = jsonData.Replace(key, false);
475         EXPECT_FALSE(ret);
476         double d = 22.0;
477         ret = jsonData.Replace(key, d);
478         EXPECT_FALSE(ret);
479         std::string str = "{\"name\":\"jin\", \"age\":20}";
480         Json2::Value val = JsonReader::ParseJsonData2(str);
481         ret = jsonData.Replace(key, val);
482         EXPECT_FALSE(ret);
483     }
484 
TEST(JsonReaderTest,ReplaceTest_ArrayErr)485     TEST(JsonReaderTest, ReplaceTest_ArrayErr)
486     {
487         Json2::Value jsonData = JsonReader::ParseJsonData2(g_obj);
488         // key is nullptr
489         const char* key = nullptr;
490         int invalidIndex = -1;
491         bool ret = jsonData.Replace(invalidIndex, "aaa");
492         EXPECT_FALSE(ret);
493         ret = jsonData.Replace(invalidIndex, false);
494         EXPECT_FALSE(ret);
495         double d = 22.0;
496         ret = jsonData.Replace(invalidIndex, d);
497         EXPECT_FALSE(ret);
498         std::string str = "{\"name\":\"jin\", \"age\":20}";
499         Json2::Value val = JsonReader::ParseJsonData2(str);
500         ret = jsonData.Replace(invalidIndex, val);
501         EXPECT_FALSE(ret);
502     }
503 }