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