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