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 <gtest/gtest.h>
17 #include <memory>
18 #include <string>
19 #include "cjson_utils.h"
20
21 using namespace testing::ext;
22
23 namespace OHOS {
24 namespace Security {
25 namespace AccessToken {
26 namespace {
27 std::string g_testJsonStr = R"(
28 {
29 "beginTime": 11,
30 "endTime": 22,
31 "bundleRecords": [
32 {
33 "tokenId": 123,
34 "isRemote": false,
35 "bundleName": "com.ohos.test1",
36 "permissionRecords": [{
37 "permissionName": "ohos.permission.READ_IMAGEVIDEO",
38 "accessCount": 1,
39 "secAccessCount": 1,
40 "rejectCount": 1,
41 "lastAccessTime": 11,
42 "lastRejectTime": 22,
43 "lastAccessDuration": 0,
44 "accessRecords": [{
45 "status": 1,
46 "lockScreenStatus": 1,
47 "timestamp": 11,
48 "duration": 0,
49 "count": 2,
50 "usedType": 0
51 }
52 ],
53 "rejectRecords": []
54 }]
55 },
56 {
57 "tokenId": 234,
58 "isRemote": true,
59 "bundleName": "com.ohos.test",
60 "permissionRecords": []
61 }
62 ]
63 }
64 )";
65 };
66
67 class CJsonUtilsTest : public testing::Test {
68 public:
69 static void SetUpTestCase();
70 static void TearDownTestCase();
71
72 void SetUp();
73 void TearDown();
74 };
75
SetUpTestCase()76 void CJsonUtilsTest::SetUpTestCase() {}
TearDownTestCase()77 void CJsonUtilsTest::TearDownTestCase() {}
SetUp()78 void CJsonUtilsTest::SetUp() {}
TearDown()79 void CJsonUtilsTest::TearDown() {}
80
81 /*
82 * @tc.name: CreateJsonFromString
83 * @tc.desc: CreateJsonFromString
84 * @tc.type: FUNC
85 * @tc.require: TDD coverage
86 */
87 HWTEST_F(CJsonUtilsTest, CreateJsonFromStringTest001, TestSize.Level3)
88 {
89 std::string test1;
90 EXPECT_EQ(nullptr, CreateJsonFromString(test1));
91
92 std::string test2 = "{\"key\":\"value\"}";
93 EXPECT_NE(nullptr, CreateJsonFromString(test2));
94 }
95
96 /*
97 * @tc.name: PackJsonToString
98 * @tc.desc: PackJsonToString
99 * @tc.type: FUNC
100 * @tc.require: TDD coverage
101 */
102 HWTEST_F(CJsonUtilsTest, PackJsonToStringTest001, TestSize.Level3)
103 {
104 std::string res = PackJsonToString(nullptr);
105 EXPECT_TRUE(res.empty());
106
107 std::string test = "{\"key\":\"value\"}";
108 CJsonUnique json = CreateJsonFromString(test);
109 EXPECT_NE(nullptr, json);
110
111 res = PackJsonToString(json);
112 EXPECT_FALSE(res.empty());
113
114 FreeJsonString(nullptr);
115 }
116
117 /*
118 * @tc.name: GetObjFromJson
119 * @tc.desc: GetObjFromJson
120 * @tc.type: FUNC
121 * @tc.require: TDD coverage
122 */
123 HWTEST_F(CJsonUtilsTest, GetObjFromJsonTest001, TestSize.Level3)
124 {
125 std::string test;
126 EXPECT_EQ(nullptr, GetObjFromJson(nullptr, test));
127
128 test = "test1";
129 CJsonUnique jsonInner = CreateJson();
130 ASSERT_EQ(true, AddStringToJson(jsonInner, "test0", "0"));
131 EXPECT_EQ(nullptr, GetObjFromJson(jsonInner, test));
132
133 test = "test0";
134 EXPECT_EQ(nullptr, GetObjFromJson(jsonInner, test));
135 }
136
137 /*
138 * @tc.name: GetArrayFromJson
139 * @tc.desc: GetArrayFromJson
140 * @tc.type: FUNC
141 * @tc.require: TDD coverage
142 */
143 HWTEST_F(CJsonUtilsTest, GetArrayFromJsonTest001, TestSize.Level3)
144 {
145 std::string test;
146 EXPECT_EQ(nullptr, GetArrayFromJson(nullptr, test));
147
148 test = "test1";
149 CJsonUnique jsonInner = CreateJson();
150 ASSERT_EQ(true, AddStringToJson(jsonInner, "test0", "0"));
151 EXPECT_EQ(nullptr, GetArrayFromJson(jsonInner, test));
152
153 test = "test0";
154 EXPECT_EQ(nullptr, GetArrayFromJson(jsonInner, test));
155 }
156
157 /*
158 * @tc.name: GetArrayFromJson
159 * @tc.desc: GetArrayFromJson
160 * @tc.type: FUNC
161 * @tc.require: TDD coverage
162 */
163 HWTEST_F(CJsonUtilsTest, GetArrayFromJsonTest002, TestSize.Level3)
164 {
165 std::string test;
166 std::vector<std::string> out;
167 EXPECT_FALSE(GetArrayFromJson(nullptr, test, out));
168
169 cJSON* arrayJson = cJSON_CreateArray();
170 cJSON* arrayItem = cJSON_CreateString("test");
171 cJSON_AddItemToArray(arrayJson, arrayItem);
172 std::string key = "data";
173 cJSON* array = cJSON_CreateObject();
174 EXPECT_NE(NULL, array);
175 cJSON_AddItemToObject(array, key.c_str(), arrayJson);
176 EXPECT_TRUE(GetArrayFromJson(array, key, out));
177 EXPECT_FALSE(GetArrayFromJson(arrayItem, key, out));
178 cJSON_Delete(array);
179 }
180
181 /*
182 * @tc.name: GetStringFromJson
183 * @tc.desc: GetStringFromJson
184 * @tc.type: FUNC
185 * @tc.require: TDD coverage
186 */
187 HWTEST_F(CJsonUtilsTest, GetStringFromJsonTest001, TestSize.Level3)
188 {
189 std::string test;
190 std::string res;
191 CJsonUnique jsonInner = CreateJson();
192 EXPECT_EQ(false, GetStringFromJson(jsonInner.get(), "", res));
193 EXPECT_EQ(false, GetStringFromJson(nullptr, "test", res));
194
195 ASSERT_EQ(true, AddStringToJson(jsonInner, "test0", "0"));
196 EXPECT_EQ(false, GetStringFromJson(jsonInner.get(), test, res));
197
198 test = "test1";
199 EXPECT_EQ(false, GetStringFromJson(jsonInner.get(), test, res));
200
201 CJsonUnique jsonArray = CreateJsonArray();
202 ASSERT_EQ(true, AddObjToJson(jsonArray, "test1", jsonInner));
203 EXPECT_EQ(false, GetStringFromJson(jsonArray.get(), test, res));
204 }
205
206 /*
207 * @tc.name: GetIntFromJson
208 * @tc.desc: GetIntFromJson
209 * @tc.type: FUNC
210 * @tc.require: TDD coverage
211 */
212 HWTEST_F(CJsonUtilsTest, GetIntFromJsonTest001, TestSize.Level3)
213 {
214 std::string test = "test1";
215 int32_t res;
216 CJsonUnique jsonInner = CreateJson();
217 EXPECT_EQ(false, GetIntFromJson(jsonInner, "", res));
218 EXPECT_EQ(false, GetIntFromJson(nullptr, test, res));
219
220 ASSERT_EQ(true, AddStringToJson(jsonInner, "test0", "abc"));
221 EXPECT_EQ(false, GetIntFromJson(jsonInner, test, res));
222
223 test = "test0";
224 EXPECT_EQ(false, GetIntFromJson(jsonInner, test, res));
225 }
226
227 /*
228 * @tc.name: GetUnsignedIntFromJson
229 * @tc.desc: GetUnsignedIntFromJson
230 * @tc.type: FUNC
231 * @tc.require: TDD coverage
232 */
233 HWTEST_F(CJsonUtilsTest, GetUnsignedIntFromJsonTest001, TestSize.Level3)
234 {
235 std::string test = "test1";
236 uint32_t res;
237 CJsonUnique jsonInner = CreateJson();
238 EXPECT_EQ(false, GetUnsignedIntFromJson(jsonInner, "", res));
239 EXPECT_EQ(false, GetUnsignedIntFromJson(nullptr, test, res));
240
241 ASSERT_EQ(true, AddStringToJson(jsonInner, "test0", "abc"));
242 EXPECT_EQ(false, GetUnsignedIntFromJson(jsonInner, test, res));
243
244 test = "test0";
245 EXPECT_EQ(false, GetUnsignedIntFromJson(jsonInner, test, res));
246 }
247
248 /*
249 * @tc.name: GetBoolFromJson
250 * @tc.desc: GetBoolFromJson
251 * @tc.type: FUNC
252 * @tc.require: TDD coverage
253 */
254 HWTEST_F(CJsonUtilsTest, GetBoolFromJsonTest001, TestSize.Level3)
255 {
256 std::string test = "test1";
257 bool res;
258 CJsonUnique jsonInner = CreateJson();
259 EXPECT_EQ(false, GetBoolFromJson(jsonInner, "", res));
260 EXPECT_EQ(false, GetBoolFromJson(nullptr, test, res));
261
262 ASSERT_EQ(true, AddStringToJson(jsonInner, "test0", "0"));
263 EXPECT_EQ(false, GetBoolFromJson(jsonInner, test, res));
264
265 test = "test0";
266 EXPECT_EQ(false, GetBoolFromJson(jsonInner, test, res));
267 }
268
269 /*
270 * @tc.name: GetBoolFromJson
271 * @tc.desc: GetBoolFromJson
272 * @tc.type: FUNC
273 * @tc.require: TDD coverage
274 */
275 HWTEST_F(CJsonUtilsTest, GetBoolFromJsonTest002, TestSize.Level3)
276 {
277 std::string test = "test1";
278 bool res;
279 CJsonUnique jsonInner = CreateJson();
280 EXPECT_EQ(false, GetBoolFromJson(jsonInner, "", res));
281 EXPECT_EQ(false, GetBoolFromJson(nullptr, "test1", res));
282
283 ASSERT_EQ(true, AddBoolToJson(jsonInner, test, true));
284
285 EXPECT_EQ(true, GetBoolFromJson(jsonInner, test, res));
286 EXPECT_EQ(res, true);
287 }
288
289 /*
290 * @tc.name: AddObjToJson
291 * @tc.desc: AddObjToJson
292 * @tc.type: FUNC
293 * @tc.require: TDD coverage
294 */
295 HWTEST_F(CJsonUtilsTest, AddObjToJsonTest001, TestSize.Level3)
296 {
297 CJsonUnique jsonInner = CreateJson();
298 std::string test = "test1";
299 ASSERT_EQ(false, AddObjToJson(jsonInner.get(), "", nullptr));
300 ASSERT_EQ(false, AddObjToJson(nullptr, "test", nullptr));
301
302 ASSERT_EQ(true, AddStringToJson(jsonInner, "test0", "0"));
303 ASSERT_EQ(true, AddStringToJson(jsonInner, "test1", "1"));
304
305 CJsonUnique jsonArray = CreateJsonArray();
306 ASSERT_EQ(true, AddObjToJson(jsonArray, "test1", jsonInner));
307 ASSERT_EQ(true, AddObjToJson(jsonArray, "test1", jsonInner));
308 }
309
310 /*
311 * @tc.name: AddObjToArray
312 * @tc.desc: AddObjToArray
313 * @tc.type: FUNC
314 * @tc.require: TDD coverage
315 */
316 HWTEST_F(CJsonUtilsTest, AddObjToArrayTest001, TestSize.Level3)
317 {
318 ASSERT_EQ(false, AddObjToArray(nullptr, nullptr));
319
320 CJsonUnique jsonInner = CreateJson();
321 ASSERT_EQ(false, AddObjToArray(nullptr, jsonInner.get()));
322 }
323
324 /*
325 * @tc.name: AddStringToJson
326 * @tc.desc: AddStringToJson
327 * @tc.type: FUNC
328 * @tc.require: TDD coverage
329 */
330 HWTEST_F(CJsonUtilsTest, AddStringToJsonTest001, TestSize.Level3)
331 {
332 CJsonUnique jsonInner = CreateJson();
333 ASSERT_EQ(false, AddStringToJson(jsonInner, "", ""));
334 ASSERT_EQ(false, AddStringToJson(nullptr, "key_string", "test0"));
335
336 ASSERT_EQ(true, AddStringToJson(jsonInner, "key_string", "test0"));
337 // twice
338 ASSERT_EQ(true, AddStringToJson(jsonInner, "key_string", "test0"));
339 }
340
341 /*
342 * @tc.name: AddBoolToJson
343 * @tc.desc: AddBoolToJson
344 * @tc.type: FUNC
345 * @tc.require: TDD coverage
346 */
347 HWTEST_F(CJsonUtilsTest, AddBoolToJsonTest001, TestSize.Level3)
348 {
349 CJsonUnique jsonInner = CreateJson();
350 ASSERT_EQ(false, AddBoolToJson(jsonInner, "", true));
351 ASSERT_EQ(false, AddBoolToJson(nullptr, "key_bool", true));
352
353 ASSERT_EQ(true, AddBoolToJson(jsonInner, "key_bool", true));
354 // twice
355 ASSERT_EQ(true, AddBoolToJson(jsonInner, "key_bool", true));
356 }
357
358 /*
359 * @tc.name: AddIntToJson
360 * @tc.desc: AddIntToJson
361 * @tc.type: FUNC
362 * @tc.require: TDD coverage
363 */
364 HWTEST_F(CJsonUtilsTest, AddIntToJsonTest001, TestSize.Level3)
365 {
366 CJsonUnique jsonInner = CreateJson();
367 ASSERT_EQ(false, AddIntToJson(jsonInner, "", 0));
368 ASSERT_EQ(false, AddIntToJson(nullptr, "key_int32", 0));
369
370 ASSERT_EQ(true, AddIntToJson(jsonInner, "key_int32", 0));
371 // twice
372 ASSERT_EQ(true, AddIntToJson(jsonInner, "key_int32", 0));
373 }
374
375 /*
376 * @tc.name: AddUnsignedIntToJson
377 * @tc.desc: AddUnsignedIntToJson
378 * @tc.type: FUNC
379 * @tc.require: TDD coverage
380 */
381 HWTEST_F(CJsonUtilsTest, AddUnsignedIntToJsonTest001, TestSize.Level3)
382 {
383 CJsonUnique jsonInner = CreateJson();
384 ASSERT_EQ(false, AddUnsignedIntToJson(jsonInner, "", 0));
385 ASSERT_EQ(false, AddUnsignedIntToJson(nullptr, "key_uint32", 0));
386
387 ASSERT_EQ(true, AddUnsignedIntToJson(jsonInner, "key_uint32", 0));
388 // twice
389 ASSERT_EQ(true, AddUnsignedIntToJson(jsonInner, "key_uint32", 0));
390 }
391
392 /*
393 * @tc.name: AddInt64ToJson
394 * @tc.desc: AddInt64ToJson
395 * @tc.type: FUNC
396 * @tc.require: TDD coverage
397 */
398 HWTEST_F(CJsonUtilsTest, AddInt64ToJsonTest001, TestSize.Level3)
399 {
400 CJsonUnique jsonInner = CreateJson();
401 ASSERT_EQ(false, AddInt64ToJson(jsonInner, "", 0));
402 ASSERT_EQ(false, AddInt64ToJson(nullptr, "key_int64", 0));
403
404 ASSERT_EQ(true, AddInt64ToJson(jsonInner, "key_int64", 0));
405 // twice
406 ASSERT_EQ(true, AddInt64ToJson(jsonInner, "key_int64", 0));
407 }
408
409 /*
410 * @tc.name: JsonToStringFormatted
411 * @tc.desc: JsonToStringFormatted with json is nullptr
412 * @tc.type: FUNC
413 * @tc.require: TDD coverage
414 */
415 HWTEST_F(CJsonUtilsTest, JsonToStringFormattedTest001, TestSize.Level3)
416 {
417 std::string str = JsonToStringFormatted(nullptr);
418 EXPECT_TRUE(str.empty());
419
420 CJsonUnique jsonInner = CreateJson();
421 str = JsonToStringFormatted(jsonInner.get(), 501); // 501: level
422 EXPECT_TRUE(str.empty());
423 }
424
425 /*
426 * @tc.name: JsonToStringFormatted
427 * @tc.desc: JsonToStringFormatted
428 * @tc.type: FUNC
429 * @tc.require: TDD coverage
430 */
431 HWTEST_F(CJsonUtilsTest, JsonToStringFormattedTest002, TestSize.Level3)
432 {
433 CJsonUnique jsonInner = CreateJson();
434 std::string str = JsonToStringFormatted(jsonInner.get());
435 EXPECT_FALSE(str.empty());
436
437 CJsonUnique json = CreateJsonFromString(g_testJsonStr);
438 EXPECT_NE(nullptr, json.get());
439
440 str = JsonToStringFormatted(json.get());
441 EXPECT_FALSE(str.empty());
442 }
443 } // namespace AccessToken
444 } // namespace Security
445 } // namespace OHOS
446