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
20namespace {
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
396    TEST(JsonReaderTest, CreateNullTest)
397    {
398        Json2::Value value = JsonReader::CreateNull();
399        EXPECT_TRUE(value.IsNull());
400    }
401
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
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
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
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
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
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
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}