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