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