1 /*
2 * Copyright (c) 2025 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
16 #include "UTTest_json_object.h"
17
18 namespace OHOS {
19 namespace DistributedHardware {
20 struct TestJsonStru {
21 int32_t value1 = 0;
22 std::string value2 = "";
23 bool value3 = false;
24 };
25
ToJson(JsonItemObject & itemObject,const TestJsonStru & testObj)26 void ToJson(JsonItemObject &itemObject, const TestJsonStru &testObj)
27 {
28 itemObject["value1"] = testObj.value1;
29 itemObject["value2"] = testObj.value2;
30 itemObject["value3"] = testObj.value3;
31 }
32
FromJson(const JsonItemObject & itemObject,TestJsonStru & testObj)33 void FromJson(const JsonItemObject &itemObject, TestJsonStru &testObj)
34 {
35 if (itemObject.Contains("value1") && itemObject["value1"].IsNumberInteger()) {
36 testObj.value1 = itemObject["value1"].Get<int32_t>();
37 }
38 if (itemObject.Contains("value2") && itemObject["value2"].IsString()) {
39 testObj.value2 = itemObject["value2"].Get<std::string>();
40 }
41 if (itemObject.Contains("value3") && itemObject["value3"].IsBoolean()) {
42 testObj.value3 = itemObject["value3"].Get<bool>();
43 }
44 }
45
SetUp()46 void JsonObjectTest::SetUp()
47 {
48 }
49
TearDown()50 void JsonObjectTest::TearDown()
51 {
52 }
53
SetUpTestCase()54 void JsonObjectTest::SetUpTestCase()
55 {
56 }
57
TearDownTestCase()58 void JsonObjectTest::TearDownTestCase()
59 {
60 }
61
62 HWTEST_F(JsonObjectTest, SetValue_001, testing::ext::TestSize.Level0)
63 {
64 uint8_t value1 = 200;
65 int16_t value2 = -20000;
66 uint16_t value3 = 65000;
67 int32_t value4 = 100000;
68 uint32_t value5 = 1000000000;
69 int64_t value6 = -9999999;
70 uint64_t value7 = 200000000000;
71 JsonObject object1;
72 object1["TEST1"] = value1;
73 object1["TEST2"] = value2;
74 object1["TEST3"] = value3;
75 object1["TEST4"] = value4;
76 JsonObject object2;
77 object2["TEST5"] = value5;
78 object2["TEST6"] = value6;
79 object2["TEST7"] = value7;
80 std::string strRet1 = R"({"TEST1":200,"TEST2":-20000,"TEST3":65000,"TEST4":100000})";
81 std::string strRet2 = R"({"TEST5":1000000000,"TEST6":-9999999,"TEST7":200000000000})";
82 EXPECT_EQ(strRet1, object1.Dump());
83 EXPECT_EQ(strRet2, object2.Dump());
84 }
85
86 HWTEST_F(JsonObjectTest, SetValue_002, testing::ext::TestSize.Level0)
87 {
88 JsonObject object;
89 const char* strValue1 = "value1";
90 object["TEST1"] = strValue1;
91 std::string strValue2 = "value2";
92 object["TEST2"] = strValue2;
93 std::string strRet = R"({"TEST1":"value1","TEST2":"value2"})";
94 EXPECT_EQ(strRet, object.Dump());
95 }
96
97 HWTEST_F(JsonObjectTest, SetValue_003, testing::ext::TestSize.Level0)
98 {
99 JsonObject object;
100 object["TEST"] = 15.3;
101 std::string strRet = R"({"TEST":15.3})";
102 EXPECT_EQ(strRet, object.Dump());
103 }
104
105 HWTEST_F(JsonObjectTest, SetValue_004, testing::ext::TestSize.Level0)
106 {
107 JsonObject object;
108 object["TEST1"] = true;
109 object["TEST2"] = false;
110 std::string strRet = R"({"TEST1":true,"TEST2":false})";
111 EXPECT_EQ(strRet, object.Dump());
112 }
113
114 HWTEST_F(JsonObjectTest, SetValue_005, testing::ext::TestSize.Level0)
115 {
116 JsonObject object;
117 object["TEST1"] = "value1";
118 object["TEST2"] = 1000000000;
119 object["TEST3"] = 5589.532;
120 object["TEST4"] = true;
121 std::string strRet = R"({"TEST1":"value1","TEST2":1000000000,"TEST3":5589.532,"TEST4":true})";
122 EXPECT_EQ(strRet, object.Dump());
123 }
124
125 HWTEST_F(JsonObjectTest, SetValue_006, testing::ext::TestSize.Level0)
126 {
127 JsonObject object1;
128 object1["TEST1"] = "value1";
129 JsonObject object2;
130 object2["TEST2"] = "value2";
131 object1.Insert("OBJ", object2);
132 std::string strRet = R"({"TEST1":"value1","OBJ":{"TEST2":"value2"}})";
133 EXPECT_EQ(strRet, object1.Dump());
134 }
135
136 HWTEST_F(JsonObjectTest, SetValue_007, testing::ext::TestSize.Level0)
137 {
138 JsonObject subObj;
139 subObj["TEST"] = "test";
140 JsonObject object(JsonCreateType::JSON_CREATE_TYPE_ARRAY);
141 object.PushBack(15);
142 object.PushBack(23);
143 object.PushBack("value");
144 object.PushBack(subObj);
145 std::string strRet = R"([15,23,"value",{"TEST":"test"}])";
146 EXPECT_EQ(strRet, object.Dump());
147 }
148
149 HWTEST_F(JsonObjectTest, SetValue_008, testing::ext::TestSize.Level0)
150 {
151 std::vector<int32_t> verData = {45, 23, 68, 74, 56};
152 JsonObject object;
153 object["ARRAY"] = verData;
154 std::string strRet = R"({"ARRAY":[45,23,68,74,56]})";
155 EXPECT_EQ(strRet, object.Dump());
156 }
157
158 HWTEST_F(JsonObjectTest, SetValue_009, testing::ext::TestSize.Level0)
159 {
160 TestJsonStru testObj;
161 testObj.value1 = 44523;
162 testObj.value2 = "testValue";
163 testObj.value3 = true;
164 JsonObject object;
165 object["Object"] = testObj;
166 std::string strRet = R"({"Object":{"value1":44523,"value2":"testValue","value3":true}})";
167 EXPECT_EQ(strRet, object.Dump());
168
169 JsonObject object1;
170 object1 = testObj;
171 strRet = R"({"value1":44523,"value2":"testValue","value3":true})";
172 EXPECT_EQ(strRet, object1.Dump());
173 }
174
175 HWTEST_F(JsonObjectTest, SetValue_010, testing::ext::TestSize.Level0)
176 {
177 TestJsonStru testObj;
178 testObj.value1 = 10;
179 testObj.value2 = "val1";
180 testObj.value3 = true;
181 std::vector<TestJsonStru> verData;
182 verData.push_back(testObj);
183 testObj.value1 = 12;
184 testObj.value2 = "val2";
185 testObj.value3 = false;
186 verData.push_back(testObj);
187
188 JsonObject object;
189 object["Obj"] = verData;
190 std::string strRet = R"({"Obj":[{"value1":10,"value2":"val1","value3":true},)";
191 strRet += R"({"value1":12,"value2":"val2","value3":false}]})";
192 EXPECT_EQ(strRet, object.Dump());
193 }
194
195 HWTEST_F(JsonObjectTest, SetValue_011, testing::ext::TestSize.Level0)
196 {
197 JsonObject object;
198 object["TEST"] = 25;
199 std::string strRet = "{\n\t\"TEST\":\t25\n}";
200 EXPECT_EQ(strRet, object.DumpFormated());
201 }
202
203 HWTEST_F(JsonObjectTest, SetValue_012, testing::ext::TestSize.Level0)
204 {
205 JsonObject object;
206 object["TEST1"] = "value1";
207 object["TEST2"] = 1000000000;
208 object["TEST3"] = 5589.532;
209 object["TEST4"] = true;
210 std::string strRet = R"({"TEST1":"value1","TEST2":1000000000,"TEST3":5589.532,"TEST4":true})";
211 EXPECT_EQ(strRet, object.Dump());
212
213 JsonObject object1;
214 object1.Duplicate(object);
215 EXPECT_EQ(strRet, object1.Dump());
216 }
217
218 HWTEST_F(JsonObjectTest, Parse_001, testing::ext::TestSize.Level0)
219 {
220 std::string strJson = R"(
221 {
222 "TEST1":"value1",
223 "TEST2":15,
224 "TEST3":true,
225 "TEST4":0.03
226 }
227 )";
228 JsonObject object(strJson);
229 bool ret = object.IsDiscarded();
230 EXPECT_FALSE(ret);
231 if (!ret) {
232 std::vector<JsonItemObject> verItems = object.Items();
233 EXPECT_EQ(verItems.size(), 4);
234 EXPECT_TRUE(object.Contains("TEST1"));
235 EXPECT_TRUE(object.Contains("TEST2"));
236 EXPECT_TRUE(object.Contains("TEST3"));
237 EXPECT_TRUE(object.Contains("TEST4"));
238 EXPECT_FALSE(object.Contains("ABC"));
239 EXPECT_TRUE(object.IsObject());
240
241 EXPECT_FALSE(object["TEST1"].IsNumber());
242 EXPECT_FALSE(object["TEST1"].IsNumberInteger());
243 EXPECT_TRUE(object["TEST1"].IsString());
244 EXPECT_FALSE(object["TEST1"].IsObject());
245 EXPECT_FALSE(object["TEST1"].IsArray());
246 EXPECT_FALSE(object["TEST1"].IsBoolean());
247
248 EXPECT_TRUE(object["TEST2"].IsNumber());
249 EXPECT_TRUE(object["TEST2"].IsNumberInteger());
250 EXPECT_FALSE(object["TEST2"].IsString());
251 EXPECT_FALSE(object["TEST2"].IsObject());
252 EXPECT_FALSE(object["TEST2"].IsArray());
253 EXPECT_FALSE(object["TEST2"].IsBoolean());
254
255 EXPECT_FALSE(object["TEST3"].IsNumber());
256 EXPECT_FALSE(object["TEST3"].IsNumberInteger());
257 EXPECT_FALSE(object["TEST3"].IsString());
258 EXPECT_FALSE(object["TEST3"].IsObject());
259 EXPECT_FALSE(object["TEST3"].IsArray());
260 EXPECT_TRUE(object["TEST3"].IsBoolean());
261
262 EXPECT_TRUE(object["TEST4"].IsNumber());
263 EXPECT_FALSE(object["TEST4"].IsNumberInteger());
264 EXPECT_FALSE(object["TEST4"].IsString());
265 EXPECT_FALSE(object["TEST4"].IsObject());
266 EXPECT_FALSE(object["TEST4"].IsArray());
267 EXPECT_FALSE(object["TEST4"].IsBoolean());
268 }
269 }
270
271 HWTEST_F(JsonObjectTest, Parse_002, testing::ext::TestSize.Level0)
272 {
273 std::string strJson = R"({"TEST1":"value1","TEST2":15,"TEST3":true, "TEST4":0.03)";
274 JsonObject object(strJson);
275 EXPECT_TRUE(object.IsDiscarded());
276 }
277
278 HWTEST_F(JsonObjectTest, Parse_003, testing::ext::TestSize.Level0)
279 {
280 std::string strJson = R"({"TEST1":15.0,"TEST2":15.01})";
281 JsonObject object(strJson);
282 bool ret = object.IsDiscarded();
283 EXPECT_FALSE(ret);
284 if (!ret) {
285 EXPECT_TRUE(object["TEST1"].IsNumber());
286 EXPECT_TRUE(object["TEST2"].IsNumber());
287 EXPECT_TRUE(object["TEST1"].IsNumberInteger());
288 EXPECT_FALSE(object["TEST2"].IsNumberInteger());
289 }
290 }
291
292 HWTEST_F(JsonObjectTest, Parse_004, testing::ext::TestSize.Level0)
293 {
294 std::string strJson = R"({"TEST1":15.0,"TEST2":15.01})";
295 JsonObject object;
296 EXPECT_TRUE(object.Parse(strJson));
297
298 std::string strJson1 = "";
299 JsonObject object1;
300 EXPECT_FALSE(object1.Parse(strJson1));
301 }
302
303 HWTEST_F(JsonObjectTest, Get_001, testing::ext::TestSize.Level0)
304 {
305 std::string strJson = R"({"TEST1":"value1","TEST2":15,"TEST3":true, "TEST4":0.03})";
306 JsonObject object(strJson);
307 bool ret = object.IsDiscarded();
308 EXPECT_FALSE(ret);
309 if (!ret) {
310 EXPECT_EQ(object["TEST1"].Get<std::string>(), "value1");
311 EXPECT_EQ(object["TEST2"].Get<int32_t>(), 15);
312 EXPECT_EQ(object["TEST3"].Get<bool>(), true);
313 EXPECT_EQ(object["TEST4"].Get<double>(), 0.03);
314
315 EXPECT_EQ(object["TEST1"].Get<bool>(), false);
316 EXPECT_EQ(object["TEST1"].Get<int32_t>(), 0);
317 EXPECT_EQ(object["TEST2"].Get<std::string>(), "");
318 }
319 }
320
321 HWTEST_F(JsonObjectTest, Get_002, testing::ext::TestSize.Level0)
322 {
323 std::string strJson = R"({"TEST1":"value1","TEST2":15,"TEST3":true, "TEST4":0.03})";
324 JsonObject object(strJson);
325 bool ret = object.IsDiscarded();
326 EXPECT_FALSE(ret);
327 if (!ret) {
328 std::string strValue;
329 object["TEST1"].GetTo(strValue);
330 EXPECT_EQ(strValue, "value1");
331
332 int32_t value1 = 0;
333 object["TEST2"].GetTo(value1);
334 EXPECT_EQ(value1, 15);
335 uint32_t value2 = 0;
336 object["TEST2"].GetTo(value2);
337 EXPECT_EQ(value2, 15);
338 int64_t value3 = 0;
339 object["TEST2"].GetTo(value3);
340 EXPECT_EQ(value3, 15);
341
342 bool value4 = false;
343 object["TEST3"].GetTo(value4);
344 EXPECT_EQ(value4, true);
345
346 double value5 = 0.0;
347 object["TEST4"].GetTo(value5);
348 EXPECT_EQ(value5, 0.03);
349 }
350 }
351
352 HWTEST_F(JsonObjectTest, Get_003, testing::ext::TestSize.Level0)
353 {
354 std::string strJson = R"({"value1":124,"value2":"MyTest","value3":true})";
355 JsonObject object(strJson);
356 bool ret = object.IsDiscarded();
357 EXPECT_FALSE(ret);
358 if (!ret) {
359 TestJsonStru testData = object.Get<TestJsonStru>();
360 EXPECT_EQ(testData.value1, 124);
361 EXPECT_EQ(testData.value2, "MyTest");
362 EXPECT_EQ(testData.value3, true);
363 }
364 }
365
366 HWTEST_F(JsonObjectTest, Get_004, testing::ext::TestSize.Level0)
367 {
368 std::string strJson = R"({"Object":{"value1":124,"value2":"MyTest","value3":true}})";
369 JsonObject object(strJson);
370 bool ret = object.IsDiscarded();
371 EXPECT_FALSE(ret);
372 if (!ret) {
373 TestJsonStru testData = object["Object"].Get<TestJsonStru>();
374 EXPECT_EQ(testData.value1, 124);
375 EXPECT_EQ(testData.value2, "MyTest");
376 EXPECT_EQ(testData.value3, true);
377 }
378 }
379
380 HWTEST_F(JsonObjectTest, Get_005, testing::ext::TestSize.Level0)
381 {
382 std::string strJson = R"({"Object":{"value1":124,"value2":"MyTest","value3":true}})";
383 JsonObject object(strJson);
384 bool ret = object.IsDiscarded();
385 EXPECT_FALSE(ret);
386 if (!ret) {
387 JsonItemObject item = object["Object"];
388 EXPECT_EQ(item.Key(), "Object");
389 }
390 }
391
392 HWTEST_F(JsonObjectTest, Get_006, testing::ext::TestSize.Level0)
393 {
394 std::string strJson = R"({"Object":{"value1":124,"value2":"MyTest","value3":true}})";
395 JsonObject object(strJson);
396 bool ret = object.IsDiscarded();
397 EXPECT_FALSE(ret);
398 if (!ret) {
399 JsonItemObject item = object.At("Object");
400 EXPECT_EQ(item.Key(), "Object");
401 }
402 }
403
404 HWTEST_F(JsonObjectTest, Get_007, testing::ext::TestSize.Level0)
405 {
406 std::string strJson = R"({"ARRAY":[13, 24, 36, 48]})";
407 std::vector<int32_t> verValues = {13, 24, 36, 48};
408 JsonObject object(strJson);
409 bool ret = object.IsDiscarded();
410 EXPECT_FALSE(ret);
411 if (!ret) {
412 EXPECT_TRUE(object["ARRAY"].IsArray());
413 std::vector<JsonItemObject> verItems = object["ARRAY"].Items();
414 EXPECT_EQ(verItems.size(), verValues.size());
415 for (size_t i = 0; i < verValues.size() && i < verItems.size(); ++i) {
416 EXPECT_EQ(verValues[i], verItems[i].Get<int32_t>());
417 }
418 }
419 }
420
421 HWTEST_F(JsonObjectTest, Get_008, testing::ext::TestSize.Level0)
422 {
423 std::string strJson = R"({"ARRAY":[13, 24, 36, 48]})";
424 std::vector<int32_t> verValues = {13, 24, 36, 48};
425 JsonObject object;
426 EXPECT_TRUE(object.Parse(strJson));
427 bool ret = object.IsDiscarded();
428 EXPECT_FALSE(ret);
429 if (!ret) {
430 EXPECT_TRUE(object["ARRAY"].IsArray());
431 std::vector<int32_t> verVal;
432 object["ARRAY"].Get(verVal);
433 EXPECT_EQ(verVal.size(), verValues.size());
434 for (size_t i = 0; i < verValues.size() && i < verVal.size(); ++i) {
435 EXPECT_EQ(verValues[i], verVal[i]);
436 }
437 }
438 }
439
440 HWTEST_F(JsonObjectTest, Get_009, testing::ext::TestSize.Level0)
441 {
442 std::string strJson = R"(
443 {
444 "ARRAY":[
445 {"value1": 124, "value2": "MyTest", "value3": true},
446 {"value1": 230, "value2": "test1", "value3": false},
447 {"value1": 430, "value2": "test2", "value3": true}
448 ]
449 }
450 )";
451 JsonObject object(strJson);
452 bool ret = object.IsDiscarded();
453 EXPECT_FALSE(ret);
454 if (!ret) {
455 EXPECT_TRUE(object["ARRAY"].IsArray());
456 std::vector<TestJsonStru> verVal;
457 object["ARRAY"].Get(verVal);
458 EXPECT_EQ(verVal.size(), 3);
459 EXPECT_EQ(verVal[0].value1, 124);
460 EXPECT_EQ(verVal[0].value2, "MyTest");
461 EXPECT_EQ(verVal[0].value3, true);
462 EXPECT_EQ(verVal[1].value1, 230);
463 EXPECT_EQ(verVal[1].value2, "test1");
464 EXPECT_EQ(verVal[1].value3, false);
465 EXPECT_EQ(verVal[2].value1, 430);
466 EXPECT_EQ(verVal[2].value2, "test2");
467 EXPECT_EQ(verVal[2].value3, true);
468 }
469 }
470
471 HWTEST_F(JsonObjectTest, Get_010, testing::ext::TestSize.Level0)
472 {
473 std::string strJson = R"({"Object":{"value1":124,"value2":"MyTest","value3":true}})";
474 JsonObject object(strJson);
475 bool ret = object.IsDiscarded();
476 EXPECT_FALSE(ret);
477 if (!ret) {
478 JsonItemObject item = object.At("Object");
479 item.Erase("value2");
480 std::string newStrJson = R"({"Object":{"value1":124,"value3":true}})";
481 EXPECT_EQ(object.Dump(), newStrJson);
482 }
483 }
484
485 HWTEST_F(JsonObjectTest, Get_011, testing::ext::TestSize.Level0)
486 {
487 std::string strJson = R"({"value1":124,"value2":"MyTest","value3":true})";
488 JsonObject object(strJson);
489 bool ret = object.IsDiscarded();
490 EXPECT_FALSE(ret);
491 if (!ret) {
492 object.Erase("value2");
493 JsonObject subJsonObj;
494 subJsonObj["TEST"] = 13.5;
495 object.Insert("SUB", subJsonObj);
496 std::string newStrJson = R"({"value1":124,"value3":true,"SUB":{"TEST":13.5}})";
497 EXPECT_EQ(object.Dump(), newStrJson);
498 }
499 }
500
501 HWTEST_F(JsonObjectTest, Get_012, testing::ext::TestSize.Level0)
502 {
503 std::string strJson = R"({"value1":124,"value2":"MyTest","value3":true})";
504 JsonObject object(strJson);
505 bool ret = object.IsDiscarded();
506 EXPECT_FALSE(ret);
507 if (!ret) {
508 JsonObject subJsonObj;
509 subJsonObj["TEST"] = 13.5;
510 object.Insert("value2", subJsonObj);
511 std::string newStrJson = R"({"value1":124,"value3":true,"value2":{"TEST":13.5}})";
512 EXPECT_EQ(object.Dump(), newStrJson);
513 }
514 }
515
516 HWTEST_F(JsonObjectTest, Get_013, testing::ext::TestSize.Level0)
517 {
518 std::string strJson = R"({"ARRAY":[13,24,36,48]})";
519 JsonObject object;
520 EXPECT_TRUE(object.Parse(strJson));
521 bool ret = object.IsDiscarded();
522 EXPECT_FALSE(ret);
523 if (!ret) {
524 EXPECT_EQ(object.Dump(), strJson);
525 }
526 }
527
528 HWTEST_F(JsonObjectTest, Get_014, testing::ext::TestSize.Level0)
529 {
530 std::string strJson = R"({"value1":124,"value2":"MyTest","value3":true})";
531 JsonObject object;
532 EXPECT_TRUE(object.Parse(strJson));
533 bool ret = object.IsDiscarded();
534 EXPECT_FALSE(ret);
535 if (!ret) {
536 EXPECT_EQ(object.Dump(), strJson);
537 }
538 }
539
540 HWTEST_F(JsonObjectTest, Get_015, testing::ext::TestSize.Level0)
541 {
542 std::string strJson = R"({"Object":{"value1":124,"value2":"MyTest","value3":true}})";
543 JsonObject object;
544 EXPECT_TRUE(object.Parse(strJson));
545 bool ret = object.IsDiscarded();
546 EXPECT_FALSE(ret);
547 if (!ret) {
548 EXPECT_EQ(object.Dump(), strJson);
549 }
550 }
551
552 HWTEST_F(JsonObjectTest, SetValue_016, testing::ext::TestSize.Level0)
553 {
554 JsonObject object;
555 object["TEST1"] = "value1";
556 object["TEST2"] = 1000000000;
557 object["TEST3"] = 5589.532;
558 object["TEST4"] = true;
559 std::string strJson = object.Dump();
560 JsonObject object1(strJson);
561 bool ret = object1.IsDiscarded();
562 EXPECT_FALSE(ret);
563 if (!ret) {
564 EXPECT_EQ(object1["TEST1"].Get<std::string>(), "value1");
565 EXPECT_EQ(object1["TEST2"].Get<int64_t>(), 1000000000);
566 EXPECT_EQ(object1["TEST3"].Get<double>(), 5589.532);
567 EXPECT_EQ(object1["TEST4"].Get<bool>(), true);
568 }
569 }
570 } // namespace DistributedHardware
571 } // namespace OHOS