1 /*
2  * Copyright (C) 2022 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 <cinttypes>
17 #include <unistd.h>
18 #include <gtest/gtest.h>
19 #include "alg_defs.h"
20 #include "common_defs.h"
21 #include "device_auth.h"
22 #include "group_operation_common.h"
23 #include "hc_dev_info.h"
24 #include "json_utils.h"
25 #include "securec.h"
26 #include "data_manager.h"
27 
28 using namespace std;
29 using namespace testing::ext;
30 
31 namespace {
32 
33 static const char *NORMAL_STR = "abc";
34 static const Uint8Buff NORMAL_BUFF = { 0, 0 };
35 static QueryGroupParams g_queryGroupParams = {
36     .groupId = NORMAL_STR,
37     .groupName = NORMAL_STR,
38     .ownerName = NORMAL_STR,
39     .groupType = PEER_TO_PEER_GROUP,
40     .userId = nullptr,
41     .groupVisibility = ALL_GROUP_VISIBILITY
42 };
43 
GenerateGroupParams(const CJson * jsonParams,const char * groupId,TrustedGroupEntry * groupParams)44 static int32_t GenerateGroupParams(const CJson *jsonParams, const char *groupId, TrustedGroupEntry *groupParams)
45 {
46     (void)jsonParams;
47     (void)groupId;
48     (void)groupParams;
49     return HC_SUCCESS;
50 }
51 
GenerateDevParams(const CJson * jsonParams,const char * groupId,TrustedDeviceEntry * devParams)52 static int32_t GenerateDevParams(const CJson *jsonParams, const char *groupId, TrustedDeviceEntry *devParams)
53 {
54     (void)jsonParams;
55     (void)groupId;
56     (void)devParams;
57     return HC_SUCCESS;
58 }
59 
60 class GroupOperationTest : public testing::Test {
61 public:
62     static void SetUpTestCase();
63     static void TearDownTestCase();
64     void SetUp();
65     void TearDown();
66 };
67 
SetUpTestCase()68 void GroupOperationTest::SetUpTestCase()
69 {
70     int32_t ret = InitDeviceAuthService();
71     ASSERT_EQ(ret, HC_SUCCESS);
72 }
73 
TearDownTestCase()74 void GroupOperationTest::TearDownTestCase()
75 {
76     DestroyDeviceAuthService();
77 }
78 
SetUp()79 void GroupOperationTest::SetUp() {}
TearDown()80 void GroupOperationTest::TearDown() {}
81 
82 HWTEST_F(GroupOperationTest, GroupOperationTest001, TestSize.Level0)
83 {
84     TrustedGroupEntry *entry = GetGroupEntryById(DEFAULT_OS_ACCOUNT, nullptr);
85     ASSERT_EQ(entry, nullptr);
86 }
87 
88 HWTEST_F(GroupOperationTest, GroupOperationTest002, TestSize.Level0)
89 {
90     bool ret = IsTrustedDeviceInGroup(DEFAULT_OS_ACCOUNT, nullptr, NORMAL_STR, true);
91     ASSERT_EQ(ret, false);
92 }
93 
94 HWTEST_F(GroupOperationTest, GroupOperationTest003, TestSize.Level0)
95 {
96     bool ret = IsTrustedDeviceInGroup(DEFAULT_OS_ACCOUNT, NORMAL_STR, nullptr, true);
97     ASSERT_EQ(ret, false);
98 }
99 
100 HWTEST_F(GroupOperationTest, GroupOperationTest004, TestSize.Level0)
101 {
102     bool ret = IsTrustedDeviceInGroup(DEFAULT_OS_ACCOUNT, NORMAL_STR, NORMAL_STR, true);
103     ASSERT_EQ(ret, false);
104 }
105 
106 HWTEST_F(GroupOperationTest, GroupOperationTest005, TestSize.Level0)
107 {
108     bool ret = IsGroupOwner(DEFAULT_OS_ACCOUNT, nullptr, NORMAL_STR);
109     ASSERT_EQ(ret, false);
110 }
111 
112 HWTEST_F(GroupOperationTest, GroupOperationTest006, TestSize.Level0)
113 {
114     bool ret = IsGroupOwner(DEFAULT_OS_ACCOUNT, NORMAL_STR, nullptr);
115     ASSERT_EQ(ret, false);
116 }
117 
118 HWTEST_F(GroupOperationTest, GroupOperationTest007, TestSize.Level0)
119 {
120     bool ret = IsGroupOwner(DEFAULT_OS_ACCOUNT, NORMAL_STR, NORMAL_STR);
121     ASSERT_EQ(ret, false);
122 }
123 
124 HWTEST_F(GroupOperationTest, GroupOperationTest008, TestSize.Level0)
125 {
126     bool ret = IsGroupExistByGroupId(DEFAULT_OS_ACCOUNT, nullptr);
127     ASSERT_EQ(ret, false);
128 }
129 
130 HWTEST_F(GroupOperationTest, GroupOperationTest009, TestSize.Level0)
131 {
132     int32_t ret = CheckGroupAccessible(DEFAULT_OS_ACCOUNT, nullptr, NORMAL_STR);
133     ASSERT_NE(ret, HC_SUCCESS);
134 }
135 
136 HWTEST_F(GroupOperationTest, GroupOperationTest010, TestSize.Level0)
137 {
138     int32_t ret = CheckGroupAccessible(DEFAULT_OS_ACCOUNT, NORMAL_STR, nullptr);
139     ASSERT_NE(ret, HC_SUCCESS);
140 }
141 
142 HWTEST_F(GroupOperationTest, GroupOperationTest011, TestSize.Level0)
143 {
144     int32_t ret = CheckGroupAccessible(DEFAULT_OS_ACCOUNT, NORMAL_STR, NORMAL_STR);
145     ASSERT_NE(ret, HC_SUCCESS);
146 }
147 
148 HWTEST_F(GroupOperationTest, GroupOperationTest012, TestSize.Level0)
149 {
150     int32_t ret = CheckGroupEditAllowed(DEFAULT_OS_ACCOUNT, nullptr, NORMAL_STR);
151     ASSERT_NE(ret, HC_SUCCESS);
152 }
153 
154 HWTEST_F(GroupOperationTest, GroupOperationTest013, TestSize.Level0)
155 {
156     int32_t ret = CheckGroupEditAllowed(DEFAULT_OS_ACCOUNT, NORMAL_STR, nullptr);
157     ASSERT_NE(ret, HC_SUCCESS);
158 }
159 
160 HWTEST_F(GroupOperationTest, GroupOperationTest014, TestSize.Level0)
161 {
162     int32_t ret = CheckGroupEditAllowed(DEFAULT_OS_ACCOUNT, NORMAL_STR, NORMAL_STR);
163     ASSERT_NE(ret, HC_SUCCESS);
164 }
165 
166 HWTEST_F(GroupOperationTest, GroupOperationTest015, TestSize.Level0)
167 {
168     int32_t ret = GetGroupInfo(DEFAULT_OS_ACCOUNT, &g_queryGroupParams, nullptr);
169     ASSERT_NE(ret, HC_SUCCESS);
170 }
171 
172 HWTEST_F(GroupOperationTest, GroupOperationTest016, TestSize.Level0)
173 {
174     int32_t ret = GetTrustedDevInfoById(DEFAULT_OS_ACCOUNT, nullptr, true, NORMAL_STR, nullptr);
175     ASSERT_NE(ret, HC_SUCCESS);
176 }
177 
178 HWTEST_F(GroupOperationTest, GroupOperationTest017, TestSize.Level0)
179 {
180     int32_t ret = GetTrustedDevInfoById(DEFAULT_OS_ACCOUNT, NORMAL_STR, true, nullptr, nullptr);
181     ASSERT_NE(ret, HC_SUCCESS);
182 }
183 
184 HWTEST_F(GroupOperationTest, GroupOperationTest018, TestSize.Level0)
185 {
186     int32_t ret = GetTrustedDevInfoById(DEFAULT_OS_ACCOUNT, NORMAL_STR, true, NORMAL_STR, nullptr);
187     ASSERT_NE(ret, HC_SUCCESS);
188 }
189 
190 HWTEST_F(GroupOperationTest, GroupOperationTest019, TestSize.Level0)
191 {
192     uint8_t *hashMessage = nullptr;
193     uint32_t messageSize = 0;
194     int32_t ret = GetHashMessage(nullptr, &NORMAL_BUFF, &hashMessage, &messageSize);
195     ASSERT_NE(ret, HC_SUCCESS);
196 }
197 
198 HWTEST_F(GroupOperationTest, GroupOperationTest020, TestSize.Level0)
199 {
200     uint8_t *hashMessage = nullptr;
201     uint32_t messageSize = 0;
202     int32_t ret = GetHashMessage(&NORMAL_BUFF, nullptr, &hashMessage, &messageSize);
203     ASSERT_NE(ret, HC_SUCCESS);
204 }
205 
206 HWTEST_F(GroupOperationTest, GroupOperationTest021, TestSize.Level0)
207 {
208     uint32_t messageSize = 0;
209     int32_t ret = GetHashMessage(&NORMAL_BUFF, &NORMAL_BUFF, nullptr, &messageSize);
210     ASSERT_NE(ret, HC_SUCCESS);
211 }
212 
213 HWTEST_F(GroupOperationTest, GroupOperationTest022, TestSize.Level0)
214 {
215     uint8_t *hashMessage = nullptr;
216     int32_t ret = GetHashMessage(&NORMAL_BUFF, &NORMAL_BUFF, &hashMessage, nullptr);
217     ASSERT_NE(ret, HC_SUCCESS);
218 }
219 
220 HWTEST_F(GroupOperationTest, GroupOperationTest023, TestSize.Level0)
221 {
222     uint32_t num = GetCurDeviceNumByGroupId(DEFAULT_OS_ACCOUNT, nullptr);
223     ASSERT_EQ(num, 0);
224 }
225 
226 HWTEST_F(GroupOperationTest, GroupOperationTest024, TestSize.Level0)
227 {
228     int32_t ret = AssertPeerDeviceNotSelf(nullptr);
229     ASSERT_NE(ret, HC_SUCCESS);
230 }
231 
232 HWTEST_F(GroupOperationTest, GroupOperationTest025, TestSize.Level0)
233 {
234     char localUdid[INPUT_UDID_LEN] = { 0 };
235     (void)HcGetUdid((uint8_t *)localUdid, INPUT_UDID_LEN);
236     int32_t ret = AssertPeerDeviceNotSelf(localUdid);
237     ASSERT_NE(ret, HC_SUCCESS);
238 }
239 
240 HWTEST_F(GroupOperationTest, GroupOperationTest026, TestSize.Level0)
241 {
242     int32_t ret = CheckGroupExist(DEFAULT_OS_ACCOUNT, nullptr);
243     ASSERT_NE(ret, HC_SUCCESS);
244 }
245 
246 HWTEST_F(GroupOperationTest, GroupOperationTest027, TestSize.Level0)
247 {
248     CJson *jsonParams = CreateJson();
249     int32_t ret = AddGroupToDatabaseByJson(DEFAULT_OS_ACCOUNT, nullptr, jsonParams, NORMAL_STR);
250     FreeJson(jsonParams);
251     ASSERT_NE(ret, HC_SUCCESS);
252 }
253 
254 HWTEST_F(GroupOperationTest, GroupOperationTest028, TestSize.Level0)
255 {
256     int32_t ret = AddGroupToDatabaseByJson(DEFAULT_OS_ACCOUNT, GenerateGroupParams, nullptr, NORMAL_STR);
257     ASSERT_NE(ret, HC_SUCCESS);
258 }
259 
260 HWTEST_F(GroupOperationTest, GroupOperationTest029, TestSize.Level0)
261 {
262     CJson *jsonParams = CreateJson();
263     int32_t ret = AddGroupToDatabaseByJson(DEFAULT_OS_ACCOUNT, GenerateGroupParams, jsonParams, nullptr);
264     FreeJson(jsonParams);
265     ASSERT_NE(ret, HC_SUCCESS);
266 }
267 
268 HWTEST_F(GroupOperationTest, GroupOperationTest030, TestSize.Level0)
269 {
270     CJson *jsonParams = CreateJson();
271     int32_t ret = AddDeviceToDatabaseByJson(DEFAULT_OS_ACCOUNT, nullptr, jsonParams, NORMAL_STR);
272     FreeJson(jsonParams);
273     ASSERT_NE(ret, HC_SUCCESS);
274 }
275 
276 HWTEST_F(GroupOperationTest, GroupOperationTest031, TestSize.Level0)
277 {
278     int32_t ret = AddDeviceToDatabaseByJson(DEFAULT_OS_ACCOUNT, GenerateDevParams, nullptr, NORMAL_STR);
279     ASSERT_NE(ret, HC_SUCCESS);
280 }
281 
282 HWTEST_F(GroupOperationTest, GroupOperationTest032, TestSize.Level0)
283 {
284     CJson *jsonParams = CreateJson();
285     int32_t ret = AddDeviceToDatabaseByJson(DEFAULT_OS_ACCOUNT, GenerateDevParams, jsonParams, nullptr);
286     FreeJson(jsonParams);
287     ASSERT_NE(ret, HC_SUCCESS);
288 }
289 
290 HWTEST_F(GroupOperationTest, GroupOperationTest033, TestSize.Level0)
291 {
292     int32_t ret = DelGroupFromDb(DEFAULT_OS_ACCOUNT, nullptr);
293     ASSERT_NE(ret, HC_SUCCESS);
294 }
295 
296 HWTEST_F(GroupOperationTest, GroupOperationTest034, TestSize.Level0)
297 {
298     const char *groupId = "ABCD";
299     int32_t ret = DelGroupFromDb(DEFAULT_OS_ACCOUNT, groupId);
300     ASSERT_EQ(ret, HC_SUCCESS);
301 }
302 
303 HWTEST_F(GroupOperationTest, GroupOperationTest035, TestSize.Level0)
304 {
305     char *returnJsonStr = nullptr;
306     int32_t ret = ConvertGroupIdToJsonStr(nullptr, &returnJsonStr);
307     ASSERT_NE(ret, HC_SUCCESS);
308 }
309 
310 HWTEST_F(GroupOperationTest, GroupOperationTest036, TestSize.Level0)
311 {
312     int32_t ret = ConvertGroupIdToJsonStr(NORMAL_STR, nullptr);
313     ASSERT_NE(ret, HC_SUCCESS);
314 }
315 
316 HWTEST_F(GroupOperationTest, GroupOperationTest037, TestSize.Level0)
317 {
318     char *returnJsonStr = nullptr;
319     int32_t ret = GenerateBindSuccessData(nullptr, NORMAL_STR, NORMAL_STR, &returnJsonStr);
320     ASSERT_NE(ret, HC_SUCCESS);
321 }
322 
323 HWTEST_F(GroupOperationTest, GroupOperationTest038, TestSize.Level0)
324 {
325     char *returnJsonStr = nullptr;
326     int32_t ret = GenerateBindSuccessData(NORMAL_STR, nullptr, NORMAL_STR, &returnJsonStr);
327     ASSERT_NE(ret, HC_SUCCESS);
328 }
329 
330 HWTEST_F(GroupOperationTest, GroupOperationTest039, TestSize.Level0)
331 {
332     int32_t ret = GenerateBindSuccessData(NORMAL_STR, NORMAL_STR, NORMAL_STR, nullptr);
333     ASSERT_NE(ret, HC_SUCCESS);
334 }
335 
336 HWTEST_F(GroupOperationTest, GroupOperationTest040, TestSize.Level0)
337 {
338     char *returnJsonStr = nullptr;
339     int32_t ret = GenerateUnbindSuccessData(nullptr, NORMAL_STR, &returnJsonStr);
340     ASSERT_NE(ret, HC_SUCCESS);
341 }
342 
343 HWTEST_F(GroupOperationTest, GroupOperationTest041, TestSize.Level0)
344 {
345     char *returnJsonStr = nullptr;
346     int32_t ret = GenerateUnbindSuccessData(NORMAL_STR, nullptr, &returnJsonStr);
347     ASSERT_NE(ret, HC_SUCCESS);
348 }
349 
350 HWTEST_F(GroupOperationTest, GroupOperationTest042, TestSize.Level0)
351 {
352     int32_t ret = GenerateUnbindSuccessData(NORMAL_STR, NORMAL_STR, nullptr);
353     ASSERT_NE(ret, HC_SUCCESS);
354 }
355 
356 
357 HWTEST_F(GroupOperationTest, GroupOperationTest043, TestSize.Level0)
358 {
359     int32_t ret = ProcessKeyPair(DEFAULT_OS_ACCOUNT, CREATE_KEY_PAIR, nullptr, NORMAL_STR);
360     ASSERT_NE(ret, HC_SUCCESS);
361 }
362 
363 HWTEST_F(GroupOperationTest, GroupOperationTest044, TestSize.Level0)
364 {
365     CJson *jsonParams = CreateJson();
366     int32_t ret = ProcessKeyPair(DEFAULT_OS_ACCOUNT, CREATE_KEY_PAIR, jsonParams, nullptr);
367     FreeJson(jsonParams);
368     ASSERT_NE(ret, HC_SUCCESS);
369 }
370 
371 HWTEST_F(GroupOperationTest, GroupOperationTest045, TestSize.Level0)
372 {
373     uint32_t groupType;
374     int32_t ret = GetGroupTypeFromDb(DEFAULT_OS_ACCOUNT, nullptr, &groupType);
375     ASSERT_NE(ret, HC_SUCCESS);
376 }
377 
378 HWTEST_F(GroupOperationTest, GroupOperationTest046, TestSize.Level0)
379 {
380     int32_t ret = GetGroupTypeFromDb(DEFAULT_OS_ACCOUNT, NORMAL_STR, nullptr);
381     ASSERT_NE(ret, HC_SUCCESS);
382 }
383 
384 HWTEST_F(GroupOperationTest, GroupOperationTest047, TestSize.Level0)
385 {
386     uint32_t groupType;
387     int32_t ret = GetGroupTypeFromDb(DEFAULT_OS_ACCOUNT, NORMAL_STR, &groupType);
388     ASSERT_NE(ret, HC_SUCCESS);
389 }
390 
391 HWTEST_F(GroupOperationTest, GroupOperationTest048, TestSize.Level0)
392 {
393     char *userId = nullptr;
394     int32_t ret = GetUserIdFromJson(nullptr, &userId);
395     ASSERT_NE(ret, HC_SUCCESS);
396 }
397 
398 HWTEST_F(GroupOperationTest, GroupOperationTest049, TestSize.Level0)
399 {
400     CJson *jsonParams = CreateJson();
401     int32_t ret = GetUserIdFromJson(jsonParams, nullptr);
402     FreeJson(jsonParams);
403     ASSERT_NE(ret, HC_SUCCESS);
404 }
405 
406 HWTEST_F(GroupOperationTest, GroupOperationTest050, TestSize.Level0)
407 {
408     char *userId = nullptr;
409     CJson *jsonParams = CreateJson();
410     int32_t ret = GetUserIdFromJson(jsonParams, &userId);
411     FreeJson(jsonParams);
412     ASSERT_NE(ret, HC_SUCCESS);
413 }
414 
415 HWTEST_F(GroupOperationTest, GroupOperationTest051, TestSize.Level0)
416 {
417     char *sharedUserId = nullptr;
418     int32_t ret = GetSharedUserIdFromJson(nullptr, &sharedUserId);
419     ASSERT_NE(ret, HC_SUCCESS);
420 }
421 
422 HWTEST_F(GroupOperationTest, GroupOperationTest052, TestSize.Level0)
423 {
424     CJson *jsonParams = CreateJson();
425     int32_t ret = GetSharedUserIdFromJson(jsonParams, nullptr);
426     FreeJson(jsonParams);
427     ASSERT_NE(ret, HC_SUCCESS);
428 }
429 
430 HWTEST_F(GroupOperationTest, GroupOperationTest053, TestSize.Level0)
431 {
432     char *sharedUserId = nullptr;
433     CJson *jsonParams = CreateJson();
434     int32_t ret = GetSharedUserIdFromJson(jsonParams, &sharedUserId);
435     FreeJson(jsonParams);
436     ASSERT_NE(ret, HC_SUCCESS);
437 }
438 
439 HWTEST_F(GroupOperationTest, GroupOperationTest054, TestSize.Level0)
440 {
441     const char *groupId = nullptr;
442     int32_t ret = GetGroupIdFromJson(nullptr, &groupId);
443     ASSERT_NE(ret, HC_SUCCESS);
444 }
445 
446 HWTEST_F(GroupOperationTest, GroupOperationTest055, TestSize.Level0)
447 {
448     CJson *jsonParams = CreateJson();
449     int32_t ret = GetGroupIdFromJson(jsonParams, nullptr);
450     FreeJson(jsonParams);
451     ASSERT_NE(ret, HC_SUCCESS);
452 }
453 
454 HWTEST_F(GroupOperationTest, GroupOperationTest056, TestSize.Level0)
455 {
456     const char *groupId = nullptr;
457     CJson *jsonParams = CreateJson();
458     int32_t ret = GetGroupIdFromJson(jsonParams, &groupId);
459     FreeJson(jsonParams);
460     ASSERT_NE(ret, HC_SUCCESS);
461 }
462 
463 HWTEST_F(GroupOperationTest, GroupOperationTest057, TestSize.Level0)
464 {
465     const char *appId = nullptr;
466     int32_t ret = GetAppIdFromJson(nullptr, &appId);
467     ASSERT_NE(ret, HC_SUCCESS);
468 }
469 
470 HWTEST_F(GroupOperationTest, GroupOperationTest058, TestSize.Level0)
471 {
472     CJson *jsonParams = CreateJson();
473     int32_t ret = GetAppIdFromJson(jsonParams, nullptr);
474     FreeJson(jsonParams);
475     ASSERT_NE(ret, HC_SUCCESS);
476 }
477 
478 HWTEST_F(GroupOperationTest, GroupOperationTest059, TestSize.Level0)
479 {
480     const char *appId = nullptr;
481     CJson *jsonParams = CreateJson();
482     int32_t ret = GetAppIdFromJson(jsonParams, &appId);
483     FreeJson(jsonParams);
484     ASSERT_NE(ret, HC_SUCCESS);
485 }
486 
487 HWTEST_F(GroupOperationTest, GroupOperationTest060, TestSize.Level0)
488 {
489     int32_t ret = AssertGroupTypeMatch(PEER_TO_PEER_GROUP, IDENTICAL_ACCOUNT_GROUP);
490     ASSERT_NE(ret, HC_SUCCESS);
491 }
492 
493 HWTEST_F(GroupOperationTest, GroupOperationTest061, TestSize.Level0)
494 {
495     char *hash = nullptr;
496     int32_t ret = GetHashResult(nullptr, SHA256_LEN, hash, SHA256_LEN);
497     ASSERT_NE(ret, HC_SUCCESS);
498 }
499 
500 HWTEST_F(GroupOperationTest, GroupOperationTest062, TestSize.Level0)
501 {
502     const uint8_t *info;
503     int32_t ret = GetHashResult(info, SHA256_LEN, nullptr, SHA256_LEN);
504     ASSERT_NE(ret, HC_SUCCESS);
505 }
506 }
507