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