1 /*
2 * Copyright (C) 2021-2023 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 <cstring>
18 #include <unistd.h>
19 #include <gtest/gtest.h>
20 #include "device_auth.h"
21 #include "device_auth_defines.h"
22 #include "json_utils.h"
23 #include "securec.h"
24 #include "nativetoken_kit.h"
25 #include "token_setproc.h"
26
27 using namespace std;
28 using namespace testing::ext;
29
30 namespace {
31 #define PROC_NAME_DEVICE_MANAGER "device_manager"
32 #define PROC_NAME_SOFT_BUS "softbus_server"
33 #define PROC_NAME_DEVICE_SECURITY_LEVEL "dslm_service"
34 #define TEST_REQ_ID 123
35 #define TEST_REQ_ID2 321
36 #define TEST_REQ_ID3 322
37 #define TEST_REQ_ID4 323
38 #define TEST_APP_ID "TestAppId"
39 #define TEST_APP_ID2 "TestAppId2"
40 #define TEST_GROUP_NAME "TestGroup"
41 #define TEST_AUTH_ID "TestAuthId"
42 #define TEST_AUTH_ID2 "TestAuthId2"
43 #define TEST_AUTH_ID3 "TestAuthId3"
44 #define TEST_UDID "TestUdid"
45 #define TEST_UDID2 "TestUdid2"
46 #define TEST_UDID_CLIENT "5420459D93FE773F9945FD64277FBA2CAB8FB996DDC1D0B97676FBB1242B3930"
47 #define TEST_UDID_SERVER "52E2706717D5C39D736E134CC1E3BE1BAA2AA52DB7C76A37C749558BD2E6492C"
48 #define TEST_USER_ID_AUTH "4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4"
49 #define TEST_USER_ID "1234ABCD"
50 #define TEST_USER_ID2 "DCBA4321"
51 #define TEST_GROUP_ID "E2EE6F830B176B2C96A9F99BFAE2A61F5D1490B9F4A090E9D8C2874C230C7C21"
52 #define TEST_GROUP_ID2 "F2AA208B1E010542B20A34B03B4B6289EA7C7F6DFE97DA2E370348B826682D3D"
53 #define TEST_GROUP_ID3 "1234ABCD"
54 #define TEST_GROUP_ID4 "6B7B805962B8EB8275D73128BFDAA7ECD755A2EC304E36543941874A277FA75F"
55 #define TEST_AUTH_CODE "37364761534f454d33567a73424e794f33573330507069434b31676f7254706b"
56 #define TEST_AUTH_CODE2 "2f7562744654535564586e665467546b322b4b506b65626373466f48766a4335"
57 #define TEST_AUTH_CODE3 "1234567812345678123456781234567812345678123456781234567812345678"
58 #define TEST_AUTH_TOKEN3 "10F9F0576E61730193D2052B7F771887124A68F1607EFCF7796C1491F834CD92"
59 #define TEST_QUERY_PARAMS "bac"
60 #define TEST_PIN_CODE "123456"
61 #define TEST_DEV_AUTH_TEMP_KEY_PAIR_LEN 32
62 #define TEST_DEV_AUTH_SLEEP_TIME 50000
63 static const char *g_createParams = "{\"groupName\":\"TestGroup\",\"deviceId\":\"TestAuthId\",\"groupType\":256,\"group"
64 "Visibility\":-1,\"userType\":0,\"expireTime\":-1}";
65 static const char *g_createParams2 = "{\"groupName\":\"TestPrivateGroup\",\"deviceId\":\"TestAuth"
66 "Id\",\"groupType\":256,\"groupVisibility\":0,\"userType\":0,\"expireTime\":-1}";
67 static const char *g_disbandParams =
68 "{\"groupId\":\"E2EE6F830B176B2C96A9F99BFAE2A61F5D1490B9F4A090E9D8C2874C230C7C21\"}";
69 static const char *g_disbandParams2 =
70 "{\"groupId\":\"F2AA208B1E010542B20A34B03B4B6289EA7C7F6DFE97DA2E370348B826682D3D\"}";
71 static const char *g_addParams =
72 "{\"groupId\":\"E2EE6F830B176B2C96A9F99BFAE2A61F5D1490B9F4A090E9D8C2874C230C7C21\","
73 "\"groupType\":256,\"pinCode\":\"123456\"}";
74 static const char *g_addParams2 =
75 "{\"groupType\":1,\"groupId\":\"1234ABCD\","
76 "\"deviceList\":[{\"deviceId\":\"TestAuthId2\",\"udid\":\"TestUdid\",\"userId\":\"1234ABCD\","
77 "\"credential\":{\"credentialType\":1,"
78 "\"authCode\":\"37364761534f454d33567a73424e794f33573330507069434b31676f7254706b\"}},"
79 "{\"deviceId\":\"TestAuthId3\",\"udid\":\"TestUdid2\",\"userId\":\"1234ABCD\","
80 "\"credential\":{\"credentialType\":1,"
81 "\"authCode\":\"2f7562744654535564586e665467546b322b4b506b65626373466f48766a4335\"}}]}";
82 static const char *g_deleteParams =
83 "{\"groupId\":\"E2EE6F830B176B2C96A9F99BFAE2A61F5D1490B9F4A090E9D8C2874C230C7C21\",\"deleteId\":\"TestAuthId2\"}";
84 static const char *g_deleteParams2 =
85 "{\"groupType\":1,\"groupId\":\"1234ABCD\","
86 "\"deviceList\":[{\"deviceId\":\"TestAuthId2\"},{\"deviceId\":\"TestAuthId3\"}]}";
87 static const char *g_processData = "{\"appId\":\"TestAppId\"}";
88 static const char *g_authParams = "{\"peerConnDeviceId\":\"52E2706717D5C39D736E134CC1E3BE1BAA2AA52DB7C76A37C"
89 "749558BD2E6492C\",\"servicePkgName\":\"TestAppId\",\"isClient\":true}";
90 static const char *g_getRegisterInfoParams =
91 "{\"version\":\"1.0.0\",\"deviceId\":\"TestAuthId\",\"userId\":\"1234ABCD\"}";
92
93 enum AsyncStatus {
94 ASYNC_STATUS_WAITING = 0,
95 ASYNC_STATUS_TRANSMIT = 1,
96 ASYNC_STATUS_FINISH = 2,
97 ASYNC_STATUS_ERROR = 3
98 };
99
100 static AsyncStatus volatile g_asyncStatus;
101 static uint32_t g_transmitDataMaxLen = 2048;
102 static uint8_t g_transmitData[2048] = { 0 };
103 static uint32_t g_transmitDataLen = 0;
104
NativeTokenSet(const char * procName)105 static void NativeTokenSet(const char *procName)
106 {
107 const char *acls[] = {"ACCESS_IDS"};
108 const char *perms[] = {
109 "ohos.permission.PLACE_CALL",
110 "ohos.permission.ACCESS_IDS"
111 };
112 uint64_t tokenId;
113 NativeTokenInfoParams infoInstance = {
114 .dcapsNum = 0,
115 .permsNum = 2,
116 .aclsNum = 1,
117 .dcaps = NULL,
118 .perms = perms,
119 .acls = acls,
120 .processName = procName,
121 .aplStr = "system_core",
122 };
123 tokenId = GetAccessTokenId(&infoInstance);
124 SetSelfTokenID(tokenId);
125 }
126
OnTransmit(int64_t requestId,const uint8_t * data,uint32_t dataLen)127 static bool OnTransmit(int64_t requestId, const uint8_t *data, uint32_t dataLen)
128 {
129 if (memcpy_s(g_transmitData, g_transmitDataMaxLen, data, dataLen) != EOK) {
130 return false;
131 }
132 g_transmitDataLen = dataLen;
133 g_asyncStatus = ASYNC_STATUS_TRANSMIT;
134 return true;
135 }
136
OnSessionKeyReturned(int64_t requestId,const uint8_t * sessionKey,uint32_t sessionKeyLen)137 static void OnSessionKeyReturned(int64_t requestId, const uint8_t *sessionKey, uint32_t sessionKeyLen)
138 {
139 (void)requestId;
140 (void)sessionKey;
141 (void)sessionKeyLen;
142 return;
143 }
144
OnFinish(int64_t requestId,int operationCode,const char * authReturn)145 static void OnFinish(int64_t requestId, int operationCode, const char *authReturn)
146 {
147 g_asyncStatus = ASYNC_STATUS_FINISH;
148 }
149
OnError(int64_t requestId,int operationCode,int errorCode,const char * errorReturn)150 static void OnError(int64_t requestId, int operationCode, int errorCode, const char *errorReturn)
151 {
152 g_asyncStatus = ASYNC_STATUS_ERROR;
153 }
154
OnBindRequest(int64_t requestId,int operationCode,const char * reqParam)155 static char *OnBindRequest(int64_t requestId, int operationCode, const char* reqParam)
156 {
157 return nullptr;
158 }
159
OnAuthRequest(int64_t requestId,int operationCode,const char * reqParam)160 static char *OnAuthRequest(int64_t requestId, int operationCode, const char* reqParam)
161 {
162 return nullptr;
163 }
164
165 static DeviceAuthCallback g_gmCallback = {
166 .onTransmit = OnTransmit,
167 .onSessionKeyReturned = OnSessionKeyReturned,
168 .onFinish = OnFinish,
169 .onError = OnError,
170 .onRequest = OnBindRequest
171 };
172
173 static DeviceAuthCallback g_gaCallback = {
174 .onTransmit = OnTransmit,
175 .onSessionKeyReturned = OnSessionKeyReturned,
176 .onFinish = OnFinish,
177 .onError = OnError,
178 .onRequest = OnAuthRequest
179 };
180
OnGroupCreated(const char * groupInfo)181 static void OnGroupCreated(const char *groupInfo)
182 {
183 (void)groupInfo;
184 return;
185 }
186
OnGroupDeleted(const char * groupInfo)187 static void OnGroupDeleted(const char *groupInfo)
188 {
189 (void)groupInfo;
190 return;
191 }
192
OnDeviceBound(const char * peerUdid,const char * groupInfo)193 static void OnDeviceBound(const char *peerUdid, const char *groupInfo)
194 {
195 (void)peerUdid;
196 (void)groupInfo;
197 return;
198 }
199
OnDeviceUnBound(const char * peerUdid,const char * groupInfo)200 static void OnDeviceUnBound(const char *peerUdid, const char *groupInfo)
201 {
202 (void)peerUdid;
203 (void)groupInfo;
204 return;
205 }
206
OnDeviceNotTrusted(const char * peerUdid)207 static void OnDeviceNotTrusted(const char *peerUdid)
208 {
209 (void)peerUdid;
210 return;
211 }
212
OnLastGroupDeleted(const char * peerUdid,int groupType)213 static void OnLastGroupDeleted(const char *peerUdid, int groupType)
214 {
215 (void)peerUdid;
216 (void)groupType;
217 return;
218 }
219
OnTrustedDeviceNumChanged(int curTrustedDeviceNum)220 static void OnTrustedDeviceNumChanged(int curTrustedDeviceNum)
221 {
222 (void)curTrustedDeviceNum;
223 return;
224 }
225
226 static DataChangeListener g_listener = {
227 .onGroupCreated = OnGroupCreated,
228 .onGroupDeleted = OnGroupDeleted,
229 .onDeviceBound = OnDeviceBound,
230 .onDeviceUnBound = OnDeviceUnBound,
231 .onDeviceNotTrusted = OnDeviceNotTrusted,
232 .onLastGroupDeleted = OnLastGroupDeleted,
233 .onTrustedDeviceNumChanged = OnTrustedDeviceNumChanged,
234 };
235
CreateDemoGroup(int32_t osAccountId,int64_t reqId,const char * appId,const char * createParams)236 static void CreateDemoGroup(int32_t osAccountId, int64_t reqId, const char *appId, const char *createParams)
237 {
238 g_asyncStatus = ASYNC_STATUS_WAITING;
239 const DeviceGroupManager *gm = GetGmInstance();
240 int32_t ret = gm->createGroup(osAccountId, reqId, appId, createParams);
241 if (ret != HC_SUCCESS) {
242 g_asyncStatus = ASYNC_STATUS_ERROR;
243 return;
244 }
245 while (g_asyncStatus == ASYNC_STATUS_WAITING) {
246 usleep(TEST_DEV_AUTH_SLEEP_TIME);
247 }
248 usleep(TEST_DEV_AUTH_SLEEP_TIME);
249 }
250
DeleteDemoGroup(int32_t osAccountId,int64_t reqId,const char * appId,const char * disbandParams)251 static void DeleteDemoGroup(int32_t osAccountId, int64_t reqId, const char *appId, const char *disbandParams)
252 {
253 g_asyncStatus = ASYNC_STATUS_WAITING;
254 const DeviceGroupManager *gm = GetGmInstance();
255 ASSERT_NE(gm, nullptr);
256 int32_t ret = gm->deleteGroup(osAccountId, reqId, appId, disbandParams);
257 if (ret != HC_SUCCESS) {
258 g_asyncStatus = ASYNC_STATUS_ERROR;
259 return;
260 }
261 while (g_asyncStatus == ASYNC_STATUS_WAITING) {
262 usleep(TEST_DEV_AUTH_SLEEP_TIME);
263 }
264 usleep(TEST_DEV_AUTH_SLEEP_TIME);
265 }
266
267 class InitDeviceAuthServiceTest : public testing::Test {
268 public:
269 static void SetUpTestCase();
270 static void TearDownTestCase();
271 void SetUp();
272 void TearDown();
273 };
274
SetUpTestCase()275 void InitDeviceAuthServiceTest::SetUpTestCase() {}
TearDownTestCase()276 void InitDeviceAuthServiceTest::TearDownTestCase() {}
SetUp()277 void InitDeviceAuthServiceTest::SetUp() {}
TearDown()278 void InitDeviceAuthServiceTest::TearDown() {}
279
280 HWTEST_F(InitDeviceAuthServiceTest, InitDeviceAuthServiceTest001, TestSize.Level0)
281 {
282 int32_t ret = InitDeviceAuthService();
283 EXPECT_EQ(ret, HC_SUCCESS);
284 DestroyDeviceAuthService();
285 }
286
287 class DestroyDeviceAuthServiceTest : public testing::Test {
288 public:
289 static void SetUpTestCase();
290 static void TearDownTestCase();
291 void SetUp();
292 void TearDown();
293 };
294
SetUpTestCase()295 void DestroyDeviceAuthServiceTest::SetUpTestCase() {}
TearDownTestCase()296 void DestroyDeviceAuthServiceTest::TearDownTestCase() {}
SetUp()297 void DestroyDeviceAuthServiceTest::SetUp() {}
TearDown()298 void DestroyDeviceAuthServiceTest::TearDown() {}
299
300 HWTEST_F(DestroyDeviceAuthServiceTest, DestroyDeviceAuthServiceTest001, TestSize.Level0)
301 {
302 int32_t ret = InitDeviceAuthService();
303 EXPECT_EQ(ret, HC_SUCCESS);
304 DestroyDeviceAuthService();
305 }
306
307 class GetGmInstanceTest : public testing::Test {
308 public:
309 static void SetUpTestCase();
310 static void TearDownTestCase();
311 void SetUp();
312 void TearDown();
313 };
314
SetUpTestCase()315 void GetGmInstanceTest::SetUpTestCase() {}
TearDownTestCase()316 void GetGmInstanceTest::TearDownTestCase() {}
317
SetUp()318 void GetGmInstanceTest::SetUp()
319 {
320 int ret = InitDeviceAuthService();
321 EXPECT_EQ(ret, HC_SUCCESS);
322 }
323
TearDown()324 void GetGmInstanceTest::TearDown()
325 {
326 DestroyDeviceAuthService();
327 }
328
329 HWTEST_F(GetGmInstanceTest, GetGmInstanceTest001, TestSize.Level0)
330 {
331 const DeviceGroupManager *gm = GetGmInstance();
332 EXPECT_NE(gm, nullptr);
333 }
334
335 class GetGaInstanceTest : public testing::Test {
336 public:
337 static void SetUpTestCase();
338 static void TearDownTestCase();
339 void SetUp();
340 void TearDown();
341 };
342
SetUpTestCase()343 void GetGaInstanceTest::SetUpTestCase() {}
TearDownTestCase()344 void GetGaInstanceTest::TearDownTestCase() {}
345
SetUp()346 void GetGaInstanceTest::SetUp()
347 {
348 int ret = InitDeviceAuthService();
349 EXPECT_EQ(ret, HC_SUCCESS);
350 }
351
TearDown()352 void GetGaInstanceTest::TearDown()
353 {
354 DestroyDeviceAuthService();
355 }
356
357 HWTEST_F(GetGaInstanceTest, GetGaInstanceTest001, TestSize.Level0)
358 {
359 const GroupAuthManager *ga = GetGaInstance();
360 EXPECT_NE(ga, nullptr);
361 }
362
363 class GmRegCallbackTest : public testing::Test {
364 public:
365 static void SetUpTestCase();
366 static void TearDownTestCase();
367 void SetUp();
368 void TearDown();
369 };
370
SetUpTestCase()371 void GmRegCallbackTest::SetUpTestCase() {}
TearDownTestCase()372 void GmRegCallbackTest::TearDownTestCase() {}
373
SetUp()374 void GmRegCallbackTest::SetUp()
375 {
376 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
377 int ret = InitDeviceAuthService();
378 EXPECT_EQ(ret, HC_SUCCESS);
379 }
380
TearDown()381 void GmRegCallbackTest::TearDown()
382 {
383 DestroyDeviceAuthService();
384 }
385
386 HWTEST_F(GmRegCallbackTest, GmRegCallbackTest001, TestSize.Level0)
387 {
388 const DeviceGroupManager *gm = GetGmInstance();
389 ASSERT_NE(gm, nullptr);
390 DeviceAuthCallback callback;
391 int32_t ret = gm->regCallback(TEST_APP_ID, &callback);
392 ASSERT_EQ(ret, HC_SUCCESS);
393 }
394
395 HWTEST_F(GmRegCallbackTest, GmRegCallbackTest002, TestSize.Level0)
396 {
397 const DeviceGroupManager *gm = GetGmInstance();
398 ASSERT_NE(gm, nullptr);
399 DeviceAuthCallback callback;
400 int32_t ret = gm->regCallback(TEST_APP_ID, &callback);
401 ASSERT_EQ(ret, HC_SUCCESS);
402 DeviceAuthCallback callback2;
403 ret = gm->regCallback(TEST_APP_ID, &callback2);
404 ASSERT_EQ(ret, HC_SUCCESS);
405 }
406
407 HWTEST_F(GmRegCallbackTest, GmRegCallbackTest003, TestSize.Level0)
408 {
409 const DeviceGroupManager *gm = GetGmInstance();
410 ASSERT_NE(gm, nullptr);
411 DeviceAuthCallback callback;
412 int32_t ret = gm->regCallback(nullptr, &callback);
413 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
414 }
415
416 HWTEST_F(GmRegCallbackTest, GmRegCallbackTest004, TestSize.Level0)
417 {
418 const DeviceGroupManager *gm = GetGmInstance();
419 ASSERT_NE(gm, nullptr);
420 int32_t ret = gm->regCallback(TEST_APP_ID, nullptr);
421 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
422 }
423
424 class GmRegDataChangeListenerTest : public testing::Test {
425 public:
426 static void SetUpTestCase();
427 static void TearDownTestCase();
428 void SetUp();
429 void TearDown();
430 };
431
SetUpTestCase()432 void GmRegDataChangeListenerTest::SetUpTestCase() {}
TearDownTestCase()433 void GmRegDataChangeListenerTest::TearDownTestCase() {}
434
SetUp()435 void GmRegDataChangeListenerTest::SetUp()
436 {
437 NativeTokenSet(PROC_NAME_SOFT_BUS);
438 int ret = InitDeviceAuthService();
439 EXPECT_EQ(ret, HC_SUCCESS);
440 }
441
TearDown()442 void GmRegDataChangeListenerTest::TearDown()
443 {
444 DestroyDeviceAuthService();
445 }
446
447 HWTEST_F(GmRegDataChangeListenerTest, GmRegDataChangeListenerTest001, TestSize.Level0)
448 {
449 const DeviceGroupManager *gm = GetGmInstance();
450 ASSERT_NE(gm, nullptr);
451 int32_t ret = gm->regDataChangeListener(TEST_APP_ID, &g_listener);
452 ASSERT_EQ(ret, HC_SUCCESS);
453 }
454
455 HWTEST_F(GmRegDataChangeListenerTest, GmRegDataChangeListenerTest002, TestSize.Level0)
456 {
457 const DeviceGroupManager *gm = GetGmInstance();
458 ASSERT_NE(gm, nullptr);
459 int32_t ret = gm->regDataChangeListener(TEST_APP_ID, &g_listener);
460 ASSERT_EQ(ret, HC_SUCCESS);
461 ret = gm->regDataChangeListener(TEST_APP_ID, &g_listener);
462 ASSERT_EQ(ret, HC_SUCCESS);
463 }
464
465 HWTEST_F(GmRegDataChangeListenerTest, GmRegDataChangeListenerTest003, TestSize.Level0)
466 {
467 const DeviceGroupManager *gm = GetGmInstance();
468 ASSERT_NE(gm, nullptr);
469 int32_t ret = gm->regDataChangeListener(nullptr, &g_listener);
470 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
471 }
472
473 HWTEST_F(GmRegDataChangeListenerTest, GmRegDataChangeListenerTest004, TestSize.Level0)
474 {
475 const DeviceGroupManager *gm = GetGmInstance();
476 ASSERT_NE(gm, nullptr);
477 int32_t ret = gm->regDataChangeListener(TEST_APP_ID, nullptr);
478 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
479 }
480
481 class GmCreateGroupTest : public testing::Test {
482 public:
483 static void SetUpTestCase();
484 static void TearDownTestCase();
485 void SetUp();
486 void TearDown();
487 };
488
SetUpTestCase()489 void GmCreateGroupTest::SetUpTestCase()
490 {
491 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
492 int ret = InitDeviceAuthService();
493 ASSERT_EQ(ret, HC_SUCCESS);
494 const DeviceGroupManager *gm = GetGmInstance();
495 ASSERT_NE(gm, nullptr);
496 ret = gm->unRegCallback(TEST_APP_ID);
497 ASSERT_EQ(ret, HC_SUCCESS);
498 }
499
TearDownTestCase()500 void GmCreateGroupTest::TearDownTestCase()
501 {
502 DestroyDeviceAuthService();
503 }
504
SetUp()505 void GmCreateGroupTest::SetUp() {}
TearDown()506 void GmCreateGroupTest::TearDown() {}
507
508 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest001, TestSize.Level0)
509 {
510 const DeviceGroupManager *gm = GetGmInstance();
511 ASSERT_NE(gm, nullptr);
512 int32_t ret = gm->createGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, nullptr, g_createParams);
513 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
514 }
515
516 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest002, TestSize.Level0)
517 {
518 const DeviceGroupManager *gm = GetGmInstance();
519 ASSERT_NE(gm, nullptr);
520 int32_t ret = gm->createGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, nullptr);
521 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
522 }
523
524 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest003, TestSize.Level0)
525 {
526 const DeviceGroupManager *gm = GetGmInstance();
527 ASSERT_NE(gm, nullptr);
528 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
529 ASSERT_EQ(ret, HC_SUCCESS);
530 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
531 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
532 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams2);
533 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
534 }
535
536 class GmDestroyInfoTest : public testing::Test {
537 public:
538 static void SetUpTestCase();
539 static void TearDownTestCase();
540 void SetUp();
541 void TearDown();
542 };
543
SetUpTestCase()544 void GmDestroyInfoTest::SetUpTestCase()
545 {
546 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
547 int ret = InitDeviceAuthService();
548 ASSERT_EQ(ret, HC_SUCCESS);
549 }
550
TearDownTestCase()551 void GmDestroyInfoTest::TearDownTestCase()
552 {
553 DestroyDeviceAuthService();
554 }
555
SetUp()556 void GmDestroyInfoTest::SetUp() {}
TearDown()557 void GmDestroyInfoTest::TearDown() {}
558
559 HWTEST_F(GmDestroyInfoTest, GmDestroyInfoTest001, TestSize.Level0)
560 {
561 const DeviceGroupManager *gm = GetGmInstance();
562 ASSERT_NE(gm, nullptr);
563 gm->destroyInfo(nullptr);
564 }
565
566 HWTEST_F(GmDestroyInfoTest, GmDestroyInfoTest002, TestSize.Level0)
567 {
568 const DeviceGroupManager *gm = GetGmInstance();
569 ASSERT_NE(gm, nullptr);
570 char *str = nullptr;
571 gm->destroyInfo(&str);
572 }
573
574 class GmCheckAccessToGroupTest : public testing::Test {
575 public:
576 static void SetUpTestCase();
577 static void TearDownTestCase();
578 void SetUp();
579 void TearDown();
580 };
581
SetUpTestCase()582 void GmCheckAccessToGroupTest::SetUpTestCase()
583 {
584 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
585 int ret = InitDeviceAuthService();
586 ASSERT_EQ(ret, HC_SUCCESS);
587 }
588
TearDownTestCase()589 void GmCheckAccessToGroupTest::TearDownTestCase()
590 {
591 DestroyDeviceAuthService();
592 }
593
SetUp()594 void GmCheckAccessToGroupTest::SetUp() {}
595
TearDown()596 void GmCheckAccessToGroupTest::TearDown() {}
597
598 HWTEST_F(GmCheckAccessToGroupTest, GmCheckAccessToGroupTest001, TestSize.Level0)
599 {
600 const DeviceGroupManager *gm = GetGmInstance();
601 ASSERT_NE(gm, nullptr);
602 int32_t ret = gm->checkAccessToGroup(DEFAULT_OS_ACCOUNT, nullptr, TEST_GROUP_ID);
603 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
604 }
605
606 HWTEST_F(GmCheckAccessToGroupTest, GmCheckAccessToGroupTest002, TestSize.Level0)
607 {
608 const DeviceGroupManager *gm = GetGmInstance();
609 ASSERT_NE(gm, nullptr);
610 int32_t ret = gm->checkAccessToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, nullptr);
611 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
612 }
613
614 HWTEST_F(GmCheckAccessToGroupTest, GmCheckAccessToGroupTest003, TestSize.Level0)
615 {
616 const DeviceGroupManager *gm = GetGmInstance();
617 ASSERT_NE(gm, nullptr);
618 int32_t ret = gm->checkAccessToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID);
619 ASSERT_EQ(ret, HC_SUCCESS);
620 }
621
622 HWTEST_F(GmCheckAccessToGroupTest, GmCheckAccessToGroupTest004, TestSize.Level0)
623 {
624 const DeviceGroupManager *gm = GetGmInstance();
625 ASSERT_NE(gm, nullptr);
626 int32_t ret = gm->checkAccessToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID2, TEST_GROUP_ID2);
627 ASSERT_NE(ret, HC_SUCCESS);
628 }
629
630 HWTEST_F(GmCheckAccessToGroupTest, GmCheckAccessToGroupTest005, TestSize.Level0)
631 {
632 const DeviceGroupManager *gm = GetGmInstance();
633 ASSERT_NE(gm, nullptr);
634 int32_t ret = gm->checkAccessToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID3);
635 ASSERT_NE(ret, HC_SUCCESS);
636 }
637
638 class GmGetPkInfoListTest : public testing::Test {
639 public:
640 static void SetUpTestCase();
641 static void TearDownTestCase();
642 void SetUp();
643 void TearDown();
644 };
645
SetUpTestCase()646 void GmGetPkInfoListTest::SetUpTestCase() {}
TearDownTestCase()647 void GmGetPkInfoListTest::TearDownTestCase() {}
648
SetUp()649 void GmGetPkInfoListTest::SetUp()
650 {
651 NativeTokenSet(PROC_NAME_DEVICE_SECURITY_LEVEL);
652 int ret = InitDeviceAuthService();
653 EXPECT_EQ(ret, HC_SUCCESS);
654 }
655
TearDown()656 void GmGetPkInfoListTest::TearDown()
657 {
658 DestroyDeviceAuthService();
659 }
660
661 HWTEST_F(GmGetPkInfoListTest, GmGetPkInfoListTest001, TestSize.Level0)
662 {
663 const DeviceGroupManager *gm = GetGmInstance();
664 ASSERT_NE(gm, nullptr);
665 char *returnData = nullptr;
666 uint32_t returnNum = 0;
667 int32_t ret = gm->getPkInfoList(DEFAULT_OS_ACCOUNT, nullptr, TEST_QUERY_PARAMS, &returnData, &returnNum);
668 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
669 }
670
671 HWTEST_F(GmGetPkInfoListTest, GmGetPkInfoListTest002, TestSize.Level0)
672 {
673 const DeviceGroupManager *gm = GetGmInstance();
674 ASSERT_NE(gm, nullptr);
675 char *returnData = nullptr;
676 uint32_t returnNum = 0;
677 int32_t ret = gm->getPkInfoList(DEFAULT_OS_ACCOUNT, TEST_APP_ID, nullptr, &returnData, &returnNum);
678 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
679 }
680
681 HWTEST_F(GmGetPkInfoListTest, GmGetPkInfoListTest003, TestSize.Level0)
682 {
683 const DeviceGroupManager *gm = GetGmInstance();
684 ASSERT_NE(gm, nullptr);
685 uint32_t returnNum = 0;
686 int32_t ret = gm->getPkInfoList(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_QUERY_PARAMS, nullptr, &returnNum);
687 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
688 }
689
690 HWTEST_F(GmGetPkInfoListTest, GmGetPkInfoListTest004, TestSize.Level0)
691 {
692 const DeviceGroupManager *gm = GetGmInstance();
693 ASSERT_NE(gm, nullptr);
694 char *returnData = nullptr;
695 int32_t ret = gm->getPkInfoList(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_QUERY_PARAMS, &returnData, nullptr);
696 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
697 }
698
699 HWTEST_F(GmGetPkInfoListTest, GmGetPkInfoListTest005, TestSize.Level0)
700 {
701 const DeviceGroupManager *gm = GetGmInstance();
702 EXPECT_NE(gm, nullptr);
703 char *returnData = nullptr;
704 uint32_t returnNum = 0;
705 const char *queryParams = "{\"udid\":\"5420459D93FE773F9945FD64277FBA2CAB8FB996DDC1D0B97676FBB1242"
706 "B3930\",\"isSelfPk\":true}";
707 int32_t ret = gm->getPkInfoList(DEFAULT_OS_ACCOUNT, TEST_APP_ID, queryParams, &returnData, &returnNum);
708 ASSERT_EQ(ret, HC_SUCCESS);
709 ASSERT_NE(returnData, nullptr);
710 ASSERT_EQ(returnNum, 0);
711 gm->destroyInfo(&returnData);
712 }
713
714 HWTEST_F(GmGetPkInfoListTest, GmGetPkInfoListTest006, TestSize.Level0)
715 {
716 const DeviceGroupManager *gm = GetGmInstance();
717 EXPECT_NE(gm, nullptr);
718 char *returnData = nullptr;
719 uint32_t returnNum = 0;
720 const char *queryParams = "{\"udid\":\"ABCD\",\"isSelfPk\":true}";
721 int32_t ret = gm->getPkInfoList(DEFAULT_OS_ACCOUNT, TEST_APP_ID, queryParams, &returnData, &returnNum);
722 ASSERT_EQ(ret, HC_SUCCESS);
723 ASSERT_NE(returnData, nullptr);
724 gm->destroyInfo(&returnData);
725 }
726
727 class GmGetGroupInfoByIdTest : public testing::Test {
728 public:
729 static void SetUpTestCase();
730 static void TearDownTestCase();
731 void SetUp();
732 void TearDown();
733 };
734
SetUpTestCase()735 void GmGetGroupInfoByIdTest::SetUpTestCase() {}
TearDownTestCase()736 void GmGetGroupInfoByIdTest::TearDownTestCase() {}
737
SetUp()738 void GmGetGroupInfoByIdTest::SetUp()
739 {
740 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
741 int ret = InitDeviceAuthService();
742 EXPECT_EQ(ret, HC_SUCCESS);
743 }
744
TearDown()745 void GmGetGroupInfoByIdTest::TearDown()
746 {
747 DestroyDeviceAuthService();
748 }
749
750 HWTEST_F(GmGetGroupInfoByIdTest, GmGetGroupInfoByIdTest001, TestSize.Level0)
751 {
752 const DeviceGroupManager *gm = GetGmInstance();
753 ASSERT_NE(gm, nullptr);
754 char *returnData = nullptr;
755 int32_t ret = gm->getGroupInfoById(DEFAULT_OS_ACCOUNT, nullptr, TEST_GROUP_ID, &returnData);
756 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
757 }
758
759 HWTEST_F(GmGetGroupInfoByIdTest, GmGetGroupInfoByIdTest002, TestSize.Level0)
760 {
761 const DeviceGroupManager *gm = GetGmInstance();
762 ASSERT_NE(gm, nullptr);
763 char *returnData = nullptr;
764 int32_t ret = gm->getGroupInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID, nullptr, &returnData);
765 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
766 }
767
768 HWTEST_F(GmGetGroupInfoByIdTest, GmGetGroupInfoByIdTest003, TestSize.Level0)
769 {
770 const DeviceGroupManager *gm = GetGmInstance();
771 ASSERT_NE(gm, nullptr);
772 int32_t ret = gm->getGroupInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID, nullptr);
773 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
774 }
775
776 HWTEST_F(GmGetGroupInfoByIdTest, GmGetGroupInfoByIdTest004, TestSize.Level0)
777 {
778 const DeviceGroupManager *gm = GetGmInstance();
779 ASSERT_NE(gm, nullptr);
780 char *returnData = nullptr;
781 int32_t ret = gm->getGroupInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID, &returnData);
782 ASSERT_EQ(ret, HC_SUCCESS);
783 ASSERT_NE(returnData, nullptr);
784 gm->destroyInfo(&returnData);
785 }
786
787 HWTEST_F(GmGetGroupInfoByIdTest, GmGetGroupInfoByIdTest005, TestSize.Level0)
788 {
789 const DeviceGroupManager *gm = GetGmInstance();
790 ASSERT_NE(gm, nullptr);
791 char *returnData = nullptr;
792 int32_t ret = gm->getGroupInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID2, TEST_GROUP_ID2, &returnData);
793 ASSERT_NE(ret, HC_SUCCESS);
794 }
795
796 HWTEST_F(GmGetGroupInfoByIdTest, GmGetGroupInfoByIdTest006, TestSize.Level0)
797 {
798 const DeviceGroupManager *gm = GetGmInstance();
799 ASSERT_NE(gm, nullptr);
800 char *returnData = nullptr;
801 int32_t ret = gm->getGroupInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID3, &returnData);
802 ASSERT_NE(ret, HC_SUCCESS);
803 }
804
805 class GmGetGroupInfoTest : public testing::Test {
806 public:
807 static void SetUpTestCase();
808 static void TearDownTestCase();
809 void SetUp();
810 void TearDown();
811 };
812
SetUpTestCase()813 void GmGetGroupInfoTest::SetUpTestCase() {}
TearDownTestCase()814 void GmGetGroupInfoTest::TearDownTestCase() {}
815
SetUp()816 void GmGetGroupInfoTest::SetUp()
817 {
818 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
819 int ret = InitDeviceAuthService();
820 EXPECT_EQ(ret, HC_SUCCESS);
821 }
822
TearDown()823 void GmGetGroupInfoTest::TearDown()
824 {
825 DestroyDeviceAuthService();
826 }
827
828 HWTEST_F(GmGetGroupInfoTest, GmGetGroupInfoTest001, TestSize.Level0)
829 {
830 const DeviceGroupManager *gm = GetGmInstance();
831 ASSERT_NE(gm, nullptr);
832 char *returnData = nullptr;
833 uint32_t returnNum = 0;
834 int32_t ret = gm->getGroupInfo(DEFAULT_OS_ACCOUNT, nullptr, TEST_QUERY_PARAMS, &returnData, &returnNum);
835 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
836 }
837
838 HWTEST_F(GmGetGroupInfoTest, GmGetGroupInfoTest002, TestSize.Level0)
839 {
840 const DeviceGroupManager *gm = GetGmInstance();
841 ASSERT_NE(gm, nullptr);
842 char *returnData = nullptr;
843 uint32_t returnNum = 0;
844 int32_t ret = gm->getGroupInfo(DEFAULT_OS_ACCOUNT, TEST_APP_ID, nullptr, &returnData, &returnNum);
845 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
846 }
847
848 HWTEST_F(GmGetGroupInfoTest, GmGetGroupInfoTest003, TestSize.Level0)
849 {
850 const DeviceGroupManager *gm = GetGmInstance();
851 ASSERT_NE(gm, nullptr);
852 uint32_t returnNum = 0;
853 int32_t ret = gm->getGroupInfo(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_QUERY_PARAMS, nullptr, &returnNum);
854 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
855 }
856
857 HWTEST_F(GmGetGroupInfoTest, GmGetGroupInfoTest004, TestSize.Level0)
858 {
859 const DeviceGroupManager *gm = GetGmInstance();
860 ASSERT_NE(gm, nullptr);
861 char *returnData = nullptr;
862 int32_t ret = gm->getGroupInfo(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_QUERY_PARAMS, &returnData, nullptr);
863 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
864 }
865
866 HWTEST_F(GmGetGroupInfoTest, GmGetGroupInfoTest005, TestSize.Level0)
867 {
868 const DeviceGroupManager *gm = GetGmInstance();
869 ASSERT_NE(gm, nullptr);
870 char *returnData = nullptr;
871 uint32_t returnNum = 0;
872 const char *queryParams = "{\"groupOwner\":\"TestAppId\"}";
873 int32_t ret = gm->getGroupInfo(DEFAULT_OS_ACCOUNT, TEST_APP_ID, queryParams, &returnData, &returnNum);
874 ASSERT_EQ(ret, HC_SUCCESS);
875 ASSERT_NE(returnData, nullptr);
876 gm->destroyInfo(&returnData);
877 }
878
879 HWTEST_F(GmGetGroupInfoTest, GmGetGroupInfoTest006, TestSize.Level0)
880 {
881 const DeviceGroupManager *gm = GetGmInstance();
882 ASSERT_NE(gm, nullptr);
883 char *returnData = nullptr;
884 uint32_t returnNum = 0;
885 const char *queryParams = "{\"groupOwner\":\"TestAppId2\"}";
886 int32_t ret = gm->getGroupInfo(DEFAULT_OS_ACCOUNT, TEST_APP_ID, queryParams, &returnData, &returnNum);
887 ASSERT_EQ(ret, HC_SUCCESS);
888 ASSERT_NE(returnData, nullptr);
889 gm->destroyInfo(&returnData);
890 }
891
892 class GmGetJoinedGroupsTest : public testing::Test {
893 public:
894 static void SetUpTestCase();
895 static void TearDownTestCase();
896 void SetUp();
897 void TearDown();
898 };
899
SetUpTestCase()900 void GmGetJoinedGroupsTest::SetUpTestCase() {}
TearDownTestCase()901 void GmGetJoinedGroupsTest::TearDownTestCase() {}
902
SetUp()903 void GmGetJoinedGroupsTest::SetUp()
904 {
905 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
906 int ret = InitDeviceAuthService();
907 EXPECT_EQ(ret, HC_SUCCESS);
908 }
909
TearDown()910 void GmGetJoinedGroupsTest::TearDown()
911 {
912 DestroyDeviceAuthService();
913 }
914
915 HWTEST_F(GmGetJoinedGroupsTest, GmGetJoinedGroupsTest001, TestSize.Level0)
916 {
917 const DeviceGroupManager *gm = GetGmInstance();
918 ASSERT_NE(gm, nullptr);
919 char *returnData = nullptr;
920 uint32_t returnNum = 0;
921 int32_t ret = gm->getJoinedGroups(DEFAULT_OS_ACCOUNT, nullptr, PEER_TO_PEER_GROUP, &returnData, &returnNum);
922 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
923 }
924
925 HWTEST_F(GmGetJoinedGroupsTest, GmGetJoinedGroupsTest002, TestSize.Level0)
926 {
927 const DeviceGroupManager *gm = GetGmInstance();
928 ASSERT_NE(gm, nullptr);
929 uint32_t returnNum = 0;
930 int32_t ret = gm->getJoinedGroups(DEFAULT_OS_ACCOUNT, TEST_APP_ID, PEER_TO_PEER_GROUP, nullptr, &returnNum);
931 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
932 }
933
934 HWTEST_F(GmGetJoinedGroupsTest, GmGetJoinedGroupsTest003, TestSize.Level0)
935 {
936 const DeviceGroupManager *gm = GetGmInstance();
937 ASSERT_NE(gm, nullptr);
938 char *returnData = nullptr;
939 int32_t ret = gm->getJoinedGroups(DEFAULT_OS_ACCOUNT, nullptr, PEER_TO_PEER_GROUP, &returnData, nullptr);
940 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
941 }
942
943 HWTEST_F(GmGetJoinedGroupsTest, GmGetJoinedGroupsTest004, TestSize.Level0)
944 {
945 const DeviceGroupManager *gm = GetGmInstance();
946 ASSERT_NE(gm, nullptr);
947 char *returnData = nullptr;
948 uint32_t returnNum = 0;
949 int32_t ret = gm->getJoinedGroups(DEFAULT_OS_ACCOUNT, TEST_APP_ID, PEER_TO_PEER_GROUP, &returnData, &returnNum);
950 ASSERT_EQ(ret, HC_SUCCESS);
951 ASSERT_NE(returnData, nullptr);
952 ASSERT_NE(returnNum, 0);
953 gm->destroyInfo(&returnData);
954 }
955
956 HWTEST_F(GmGetJoinedGroupsTest, GmGetJoinedGroupsTest005, TestSize.Level0)
957 {
958 const DeviceGroupManager *gm = GetGmInstance();
959 ASSERT_NE(gm, nullptr);
960 char *returnData = nullptr;
961 uint32_t returnNum = 0;
962 int32_t ret = gm->getJoinedGroups(DEFAULT_OS_ACCOUNT, TEST_APP_ID2, PEER_TO_PEER_GROUP, &returnData, &returnNum);
963 ASSERT_EQ(ret, HC_SUCCESS);
964 ASSERT_NE(returnData, nullptr);
965 gm->destroyInfo(&returnData);
966 }
967
968 class GmGetRelatedGroupsTest : public testing::Test {
969 public:
970 static void SetUpTestCase();
971 static void TearDownTestCase();
972 void SetUp();
973 void TearDown();
974 };
975
SetUpTestCase()976 void GmGetRelatedGroupsTest::SetUpTestCase() {}
TearDownTestCase()977 void GmGetRelatedGroupsTest::TearDownTestCase() {}
978
SetUp()979 void GmGetRelatedGroupsTest::SetUp()
980 {
981 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
982 int ret = InitDeviceAuthService();
983 EXPECT_EQ(ret, HC_SUCCESS);
984 }
985
TearDown()986 void GmGetRelatedGroupsTest::TearDown()
987 {
988 DestroyDeviceAuthService();
989 }
990
991 HWTEST_F(GmGetRelatedGroupsTest, GmGetRelatedGroupsTest001, TestSize.Level0)
992 {
993 const DeviceGroupManager *gm = GetGmInstance();
994 ASSERT_NE(gm, nullptr);
995 char *returnData = nullptr;
996 uint32_t returnNum = 0;
997 int32_t ret = gm->getRelatedGroups(DEFAULT_OS_ACCOUNT, nullptr, TEST_AUTH_ID, &returnData, &returnNum);
998 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
999 }
1000
1001 HWTEST_F(GmGetRelatedGroupsTest, GmGetRelatedGroupsTest002, TestSize.Level0)
1002 {
1003 const DeviceGroupManager *gm = GetGmInstance();
1004 ASSERT_NE(gm, nullptr);
1005 char *returnData = nullptr;
1006 uint32_t returnNum = 0;
1007 int32_t ret = gm->getRelatedGroups(DEFAULT_OS_ACCOUNT, TEST_APP_ID, nullptr, &returnData, &returnNum);
1008 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1009 }
1010
1011 HWTEST_F(GmGetRelatedGroupsTest, GmGetRelatedGroupsTest003, TestSize.Level0)
1012 {
1013 const DeviceGroupManager *gm = GetGmInstance();
1014 ASSERT_NE(gm, nullptr);
1015 uint32_t returnNum = 0;
1016 int32_t ret = gm->getRelatedGroups(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_AUTH_ID, nullptr, &returnNum);
1017 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1018 }
1019
1020 HWTEST_F(GmGetRelatedGroupsTest, GmGetRelatedGroupsTest004, TestSize.Level0)
1021 {
1022 const DeviceGroupManager *gm = GetGmInstance();
1023 ASSERT_NE(gm, nullptr);
1024 char *returnData = nullptr;
1025 int32_t ret = gm->getRelatedGroups(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_AUTH_ID, &returnData, nullptr);
1026 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1027 }
1028
1029 HWTEST_F(GmGetRelatedGroupsTest, GmGetRelatedGroupsTest005, TestSize.Level0)
1030 {
1031 const DeviceGroupManager *gm = GetGmInstance();
1032 ASSERT_NE(gm, nullptr);
1033 char *returnData = nullptr;
1034 uint32_t returnNum = 0;
1035 int32_t ret = gm->getRelatedGroups(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_AUTH_ID, &returnData, &returnNum);
1036 ASSERT_EQ(ret, HC_SUCCESS);
1037 ASSERT_NE(returnData, nullptr);
1038 ASSERT_NE(returnNum, 0);
1039 gm->destroyInfo(&returnData);
1040 }
1041
1042 HWTEST_F(GmGetRelatedGroupsTest, GmGetRelatedGroupsTest006, TestSize.Level0)
1043 {
1044 const DeviceGroupManager *gm = GetGmInstance();
1045 ASSERT_NE(gm, nullptr);
1046 char *returnData = nullptr;
1047 uint32_t returnNum = 0;
1048 int32_t ret = gm->getRelatedGroups(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_AUTH_ID2, &returnData, &returnNum);
1049 ASSERT_EQ(ret, HC_SUCCESS);
1050 ASSERT_NE(returnData, nullptr);
1051 gm->destroyInfo(&returnData);
1052 }
1053
1054 class GmGetDeviceInfoByIdTest : public testing::Test {
1055 public:
1056 static void SetUpTestCase();
1057 static void TearDownTestCase();
1058 void SetUp();
1059 void TearDown();
1060 };
1061
SetUpTestCase()1062 void GmGetDeviceInfoByIdTest::SetUpTestCase() {}
TearDownTestCase()1063 void GmGetDeviceInfoByIdTest::TearDownTestCase() {}
1064
SetUp()1065 void GmGetDeviceInfoByIdTest::SetUp()
1066 {
1067 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
1068 int ret = InitDeviceAuthService();
1069 EXPECT_EQ(ret, HC_SUCCESS);
1070 }
1071
TearDown()1072 void GmGetDeviceInfoByIdTest::TearDown()
1073 {
1074 DestroyDeviceAuthService();
1075 }
1076
1077 HWTEST_F(GmGetDeviceInfoByIdTest, GmGetDeviceInfoByIdTest001, TestSize.Level0)
1078 {
1079 const DeviceGroupManager *gm = GetGmInstance();
1080 ASSERT_NE(gm, nullptr);
1081 char *returnData = nullptr;
1082 int32_t ret = gm->getDeviceInfoById(DEFAULT_OS_ACCOUNT, nullptr, TEST_AUTH_ID, TEST_GROUP_ID, &returnData);
1083 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1084 }
1085
1086 HWTEST_F(GmGetDeviceInfoByIdTest, GmGetDeviceInfoByIdTest002, TestSize.Level0)
1087 {
1088 const DeviceGroupManager *gm = GetGmInstance();
1089 ASSERT_NE(gm, nullptr);
1090 char *returnData = nullptr;
1091 int32_t ret = gm->getDeviceInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID, nullptr, TEST_GROUP_ID, &returnData);
1092 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1093 }
1094
1095 HWTEST_F(GmGetDeviceInfoByIdTest, GmGetDeviceInfoByIdTest003, TestSize.Level0)
1096 {
1097 const DeviceGroupManager *gm = GetGmInstance();
1098 ASSERT_NE(gm, nullptr);
1099 char *returnData = nullptr;
1100 int32_t ret = gm->getDeviceInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_AUTH_ID, nullptr, &returnData);
1101 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1102 }
1103
1104 HWTEST_F(GmGetDeviceInfoByIdTest, GmGetDeviceInfoByIdTest004, TestSize.Level0)
1105 {
1106 const DeviceGroupManager *gm = GetGmInstance();
1107 ASSERT_NE(gm, nullptr);
1108 int32_t ret = gm->getDeviceInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_AUTH_ID, TEST_GROUP_ID, nullptr);
1109 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1110 }
1111
1112 HWTEST_F(GmGetDeviceInfoByIdTest, GmGetDeviceInfoByIdTest005, TestSize.Level0)
1113 {
1114 const DeviceGroupManager *gm = GetGmInstance();
1115 ASSERT_NE(gm, nullptr);
1116 char *returnData = nullptr;
1117 int32_t ret = gm->getDeviceInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_AUTH_ID, TEST_GROUP_ID, &returnData);
1118 ASSERT_EQ(ret, HC_SUCCESS);
1119 ASSERT_NE(returnData, nullptr);
1120 gm->destroyInfo(&returnData);
1121 }
1122
1123 HWTEST_F(GmGetDeviceInfoByIdTest, GmGetDeviceInfoByIdTest006, TestSize.Level0)
1124 {
1125 const DeviceGroupManager *gm = GetGmInstance();
1126 ASSERT_NE(gm, nullptr);
1127 char *returnData = nullptr;
1128 int32_t ret = gm->getDeviceInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID2, TEST_AUTH_ID, TEST_GROUP_ID2, &returnData);
1129 ASSERT_NE(ret, HC_SUCCESS);
1130 }
1131
1132 HWTEST_F(GmGetDeviceInfoByIdTest, GmGetDeviceInfoByIdTest007, TestSize.Level0)
1133 {
1134 const DeviceGroupManager *gm = GetGmInstance();
1135 ASSERT_NE(gm, nullptr);
1136 char *returnData = nullptr;
1137 int32_t ret = gm->getDeviceInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_AUTH_ID, TEST_GROUP_ID3, &returnData);
1138 ASSERT_NE(ret, HC_SUCCESS);
1139 }
1140
1141 class GmGetTrustedDevicesTest : public testing::Test {
1142 public:
1143 static void SetUpTestCase();
1144 static void TearDownTestCase();
1145 void SetUp();
1146 void TearDown();
1147 };
1148
SetUpTestCase()1149 void GmGetTrustedDevicesTest::SetUpTestCase() {}
TearDownTestCase()1150 void GmGetTrustedDevicesTest::TearDownTestCase() {}
1151
SetUp()1152 void GmGetTrustedDevicesTest::SetUp()
1153 {
1154 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
1155 int ret = InitDeviceAuthService();
1156 EXPECT_EQ(ret, HC_SUCCESS);
1157 }
1158
TearDown()1159 void GmGetTrustedDevicesTest::TearDown()
1160 {
1161 DestroyDeviceAuthService();
1162 }
1163
1164 HWTEST_F(GmGetTrustedDevicesTest, GmGetTrustedDevicesTest001, TestSize.Level0)
1165 {
1166 const DeviceGroupManager *gm = GetGmInstance();
1167 ASSERT_NE(gm, nullptr);
1168 char *returnData = nullptr;
1169 uint32_t returnNum = 0;
1170 int32_t ret = gm->getTrustedDevices(DEFAULT_OS_ACCOUNT, nullptr, TEST_GROUP_ID, &returnData, &returnNum);
1171 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1172 }
1173
1174 HWTEST_F(GmGetTrustedDevicesTest, GmGetTrustedDevicesTest002, TestSize.Level0)
1175 {
1176 const DeviceGroupManager *gm = GetGmInstance();
1177 ASSERT_NE(gm, nullptr);
1178 char *returnData = nullptr;
1179 uint32_t returnNum = 0;
1180 int32_t ret = gm->getTrustedDevices(DEFAULT_OS_ACCOUNT, TEST_APP_ID, nullptr, &returnData, &returnNum);
1181 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1182 }
1183
1184 HWTEST_F(GmGetTrustedDevicesTest, GmGetTrustedDevicesTest003, TestSize.Level0)
1185 {
1186 const DeviceGroupManager *gm = GetGmInstance();
1187 ASSERT_NE(gm, nullptr);
1188 uint32_t returnNum = 0;
1189 int32_t ret = gm->getTrustedDevices(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID, nullptr, &returnNum);
1190 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1191 }
1192
1193 HWTEST_F(GmGetTrustedDevicesTest, GmGetTrustedDevicesTest004, TestSize.Level0)
1194 {
1195 const DeviceGroupManager *gm = GetGmInstance();
1196 ASSERT_NE(gm, nullptr);
1197 char *returnData = nullptr;
1198 int32_t ret = gm->getTrustedDevices(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID, &returnData, nullptr);
1199 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1200 }
1201
1202 HWTEST_F(GmGetTrustedDevicesTest, GmGetTrustedDevicesTest005, TestSize.Level0)
1203 {
1204 const DeviceGroupManager *gm = GetGmInstance();
1205 ASSERT_NE(gm, nullptr);
1206 char *returnData = nullptr;
1207 uint32_t returnNum = 0;
1208 int32_t ret = gm->getTrustedDevices(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID, &returnData, &returnNum);
1209 ASSERT_EQ(ret, HC_SUCCESS);
1210 ASSERT_NE(returnData, nullptr);
1211 ASSERT_NE(returnNum, 0);
1212 gm->destroyInfo(&returnData);
1213 }
1214
1215 HWTEST_F(GmGetTrustedDevicesTest, GmGetTrustedDevicesTest006, TestSize.Level0)
1216 {
1217 const DeviceGroupManager *gm = GetGmInstance();
1218 ASSERT_NE(gm, nullptr);
1219 char *returnData = nullptr;
1220 uint32_t returnNum = 0;
1221 int32_t ret = gm->getTrustedDevices(DEFAULT_OS_ACCOUNT, TEST_APP_ID2, TEST_GROUP_ID2, &returnData, &returnNum);
1222 ASSERT_NE(ret, HC_SUCCESS);
1223 }
1224
1225 HWTEST_F(GmGetTrustedDevicesTest, GmGetTrustedDevicesTest007, TestSize.Level0)
1226 {
1227 const DeviceGroupManager *gm = GetGmInstance();
1228 ASSERT_NE(gm, nullptr);
1229 char *returnData = nullptr;
1230 uint32_t returnNum = 0;
1231 int32_t ret = gm->getTrustedDevices(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID3, &returnData, &returnNum);
1232 ASSERT_NE(ret, HC_SUCCESS);
1233 }
1234
1235 class GmIsDeviceInGroupTest : public testing::Test {
1236 public:
1237 static void SetUpTestCase();
1238 static void TearDownTestCase();
1239 void SetUp();
1240 void TearDown();
1241 };
1242
SetUpTestCase()1243 void GmIsDeviceInGroupTest::SetUpTestCase() {}
TearDownTestCase()1244 void GmIsDeviceInGroupTest::TearDownTestCase() {}
1245
SetUp()1246 void GmIsDeviceInGroupTest::SetUp()
1247 {
1248 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
1249 int ret = InitDeviceAuthService();
1250 EXPECT_EQ(ret, HC_SUCCESS);
1251 }
1252
TearDown()1253 void GmIsDeviceInGroupTest::TearDown()
1254 {
1255 DestroyDeviceAuthService();
1256 }
1257
1258 HWTEST_F(GmIsDeviceInGroupTest, GmIsDeviceInGroupTest001, TestSize.Level0)
1259 {
1260 const DeviceGroupManager *gm = GetGmInstance();
1261 ASSERT_NE(gm, nullptr);
1262 bool ret = gm->isDeviceInGroup(DEFAULT_OS_ACCOUNT, nullptr, TEST_GROUP_ID, TEST_AUTH_ID);
1263 ASSERT_EQ(ret, false);
1264 }
1265
1266 HWTEST_F(GmIsDeviceInGroupTest, GmIsDeviceInGroupTest002, TestSize.Level0)
1267 {
1268 const DeviceGroupManager *gm = GetGmInstance();
1269 ASSERT_NE(gm, nullptr);
1270 bool ret = gm->isDeviceInGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, nullptr, TEST_AUTH_ID);
1271 ASSERT_EQ(ret, false);
1272 }
1273
1274 HWTEST_F(GmIsDeviceInGroupTest, GmIsDeviceInGroupTest003, TestSize.Level0)
1275 {
1276 const DeviceGroupManager *gm = GetGmInstance();
1277 ASSERT_NE(gm, nullptr);
1278 bool ret = gm->isDeviceInGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID, nullptr);
1279 ASSERT_EQ(ret, false);
1280 }
1281
1282 HWTEST_F(GmIsDeviceInGroupTest, GmIsDeviceInGroupTest004, TestSize.Level0)
1283 {
1284 const DeviceGroupManager *gm = GetGmInstance();
1285 ASSERT_NE(gm, nullptr);
1286 bool ret = gm->isDeviceInGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID, TEST_AUTH_ID);
1287 ASSERT_EQ(ret, true);
1288 }
1289
1290 HWTEST_F(GmIsDeviceInGroupTest, GmIsDeviceInGroupTest005, TestSize.Level0)
1291 {
1292 const DeviceGroupManager *gm = GetGmInstance();
1293 ASSERT_NE(gm, nullptr);
1294 bool ret = gm->isDeviceInGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID2, TEST_GROUP_ID2, TEST_AUTH_ID);
1295 ASSERT_NE(ret, true);
1296 }
1297
1298 HWTEST_F(GmIsDeviceInGroupTest, GmIsDeviceInGroupTest006, TestSize.Level0)
1299 {
1300 const DeviceGroupManager *gm = GetGmInstance();
1301 ASSERT_NE(gm, nullptr);
1302 bool ret = gm->isDeviceInGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID3, TEST_AUTH_ID);
1303 ASSERT_EQ(ret, false);
1304 }
1305
1306 class GmAddMemberToGroupTest : public testing::Test {
1307 public:
1308 static void SetUpTestCase();
1309 static void TearDownTestCase();
1310 void SetUp();
1311 void TearDown();
1312 };
1313
SetUpTestCase()1314 void GmAddMemberToGroupTest::SetUpTestCase()
1315 {
1316 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
1317 int ret = InitDeviceAuthService();
1318 ASSERT_EQ(ret, HC_SUCCESS);
1319 const DeviceGroupManager *gm = GetGmInstance();
1320 ASSERT_NE(gm, nullptr);
1321 ret = gm->unRegCallback(TEST_APP_ID);
1322 ASSERT_EQ(ret, HC_SUCCESS);
1323 }
1324
TearDownTestCase()1325 void GmAddMemberToGroupTest::TearDownTestCase()
1326 {
1327 DestroyDeviceAuthService();
1328 }
1329
SetUp()1330 void GmAddMemberToGroupTest::SetUp() {}
TearDown()1331 void GmAddMemberToGroupTest::TearDown() {}
1332
1333 HWTEST_F(GmAddMemberToGroupTest, GmAddMemberToGroupTest001, TestSize.Level0)
1334 {
1335 const DeviceGroupManager *gm = GetGmInstance();
1336 ASSERT_NE(gm, nullptr);
1337 int32_t ret = gm->addMemberToGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, nullptr, TEST_QUERY_PARAMS);
1338 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1339 }
1340
1341 HWTEST_F(GmAddMemberToGroupTest, GmAddMemberToGroupTest002, TestSize.Level0)
1342 {
1343 const DeviceGroupManager *gm = GetGmInstance();
1344 ASSERT_NE(gm, nullptr);
1345 int32_t ret = gm->addMemberToGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, nullptr);
1346 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1347 }
1348
1349 HWTEST_F(GmAddMemberToGroupTest, GmAddMemberToGroupTest003, TestSize.Level0)
1350 {
1351 const DeviceGroupManager *gm = GetGmInstance();
1352 ASSERT_NE(gm, nullptr);
1353 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1354 ASSERT_EQ(ret, HC_SUCCESS);
1355 ret = gm->addMemberToGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID2, TEST_APP_ID, g_addParams);
1356 ASSERT_EQ(ret, HC_SUCCESS);
1357 }
1358
1359 class GmDeleteMemberFromGroupTest : public testing::Test {
1360 public:
1361 static void SetUpTestCase();
1362 static void TearDownTestCase();
1363 void SetUp();
1364 void TearDown();
1365 };
1366
SetUpTestCase()1367 void GmDeleteMemberFromGroupTest::SetUpTestCase()
1368 {
1369 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
1370 int ret = InitDeviceAuthService();
1371 ASSERT_EQ(ret, HC_SUCCESS);
1372 const DeviceGroupManager *gm = GetGmInstance();
1373 ASSERT_NE(gm, nullptr);
1374 ret = gm->unRegCallback(TEST_APP_ID);
1375 ASSERT_EQ(ret, HC_SUCCESS);
1376 }
1377
TearDownTestCase()1378 void GmDeleteMemberFromGroupTest::TearDownTestCase()
1379 {
1380 DestroyDeviceAuthService();
1381 }
1382
SetUp()1383 void GmDeleteMemberFromGroupTest::SetUp() {}
TearDown()1384 void GmDeleteMemberFromGroupTest::TearDown() {}
1385
1386 HWTEST_F(GmDeleteMemberFromGroupTest, GmDeleteMemberFromGroupTest001, TestSize.Level0)
1387 {
1388 const DeviceGroupManager *gm = GetGmInstance();
1389 ASSERT_NE(gm, nullptr);
1390 int32_t ret = gm->deleteMemberFromGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, nullptr, TEST_QUERY_PARAMS);
1391 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1392 }
1393
1394 HWTEST_F(GmDeleteMemberFromGroupTest, GmDeleteMemberFromGroupTest002, TestSize.Level0)
1395 {
1396 const DeviceGroupManager *gm = GetGmInstance();
1397 ASSERT_NE(gm, nullptr);
1398 int32_t ret = gm->deleteMemberFromGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, nullptr);
1399 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1400 }
1401
1402 HWTEST_F(GmDeleteMemberFromGroupTest, GmDeleteMemberFromGroupTest003, TestSize.Level0)
1403 {
1404 const DeviceGroupManager *gm = GetGmInstance();
1405 ASSERT_NE(gm, nullptr);
1406 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1407 ASSERT_EQ(ret, HC_SUCCESS);
1408 ret = gm->deleteMemberFromGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID3, TEST_APP_ID, g_deleteParams);
1409 ASSERT_EQ(ret, HC_SUCCESS);
1410 }
1411
1412 class GmProcessDataTest : public testing::Test {
1413 public:
1414 static void SetUpTestCase();
1415 static void TearDownTestCase();
1416 void SetUp();
1417 void TearDown();
1418 };
1419
SetUpTestCase()1420 void GmProcessDataTest::SetUpTestCase()
1421 {
1422 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
1423 int ret = InitDeviceAuthService();
1424 ASSERT_EQ(ret, HC_SUCCESS);
1425 const DeviceGroupManager *gm = GetGmInstance();
1426 ASSERT_NE(gm, nullptr);
1427 ret = gm->unRegCallback(TEST_APP_ID);
1428 ASSERT_EQ(ret, HC_SUCCESS);
1429 }
1430
TearDownTestCase()1431 void GmProcessDataTest::TearDownTestCase()
1432 {
1433 DestroyDeviceAuthService();
1434 }
1435
SetUp()1436 void GmProcessDataTest::SetUp() {}
TearDown()1437 void GmProcessDataTest::TearDown() {}
1438
1439 HWTEST_F(GmProcessDataTest, GmProcessDataTest001, TestSize.Level0)
1440 {
1441 const DeviceGroupManager *gm = GetGmInstance();
1442 ASSERT_NE(gm, nullptr);
1443 int32_t ret = gm->processData(TEST_REQ_ID, nullptr, 0);
1444 ASSERT_NE(ret, HC_SUCCESS);
1445 }
1446
1447 HWTEST_F(GmProcessDataTest, GmProcessDataTest002, TestSize.Level0)
1448 {
1449 const DeviceGroupManager *gm = GetGmInstance();
1450 ASSERT_NE(gm, nullptr);
1451 int32_t ret = gm->processData(TEST_REQ_ID, (const uint8_t *)g_processData, 0);
1452 ASSERT_NE(ret, HC_SUCCESS);
1453 }
1454
1455 HWTEST_F(GmProcessDataTest, GmProcessDataTest003, TestSize.Level0)
1456 {
1457 const DeviceGroupManager *gm = GetGmInstance();
1458 ASSERT_NE(gm, nullptr);
1459 int32_t ret = gm->processData(TEST_REQ_ID, (const uint8_t *)g_processData, 4097);
1460 ASSERT_NE(ret, HC_SUCCESS);
1461 }
1462
1463 HWTEST_F(GmProcessDataTest, GmProcessDataTest004, TestSize.Level0)
1464 {
1465 const DeviceGroupManager *gm = GetGmInstance();
1466 ASSERT_NE(gm, nullptr);
1467 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1468 ASSERT_EQ(ret, HC_SUCCESS);
1469 ret = gm->processData(TEST_REQ_ID, (const uint8_t *)g_processData, strlen(g_processData) + 1);
1470 ASSERT_NE(ret, HC_SUCCESS);
1471 }
1472
1473 class GmAddMultiMembersToGroupTest : public testing::Test {
1474 public:
1475 static void SetUpTestCase();
1476 static void TearDownTestCase();
1477 void SetUp();
1478 void TearDown();
1479 };
1480
SetUpTestCase()1481 void GmAddMultiMembersToGroupTest::SetUpTestCase() {}
TearDownTestCase()1482 void GmAddMultiMembersToGroupTest::TearDownTestCase() {}
1483
SetUp()1484 void GmAddMultiMembersToGroupTest::SetUp()
1485 {
1486 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
1487 int ret = InitDeviceAuthService();
1488 ASSERT_EQ(ret, HC_SUCCESS);
1489 const DeviceGroupManager *gm = GetGmInstance();
1490 ASSERT_NE(gm, nullptr);
1491 ret = gm->unRegCallback(TEST_APP_ID);
1492 ASSERT_EQ(ret, HC_SUCCESS);
1493 }
1494
TearDown()1495 void GmAddMultiMembersToGroupTest::TearDown()
1496 {
1497 DestroyDeviceAuthService();
1498 }
1499
1500 HWTEST_F(GmAddMultiMembersToGroupTest, GmAddMultiMembersToGroupTest001, TestSize.Level0)
1501 {
1502 const DeviceGroupManager *gm = GetGmInstance();
1503 ASSERT_NE(gm, nullptr);
1504 int32_t ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, nullptr, TEST_QUERY_PARAMS);
1505 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1506 }
1507
1508 HWTEST_F(GmAddMultiMembersToGroupTest, GmAddMultiMembersToGroupTest002, TestSize.Level0)
1509 {
1510 const DeviceGroupManager *gm = GetGmInstance();
1511 ASSERT_NE(gm, nullptr);
1512 int32_t ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, nullptr);
1513 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1514 }
1515
1516 HWTEST_F(GmAddMultiMembersToGroupTest, GmAddMultiMembersToGroupTest003, TestSize.Level0)
1517 {
1518 const DeviceGroupManager *gm = GetGmInstance();
1519 ASSERT_NE(gm, nullptr);
1520 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1521 ASSERT_EQ(ret, HC_SUCCESS);
1522 ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, g_addParams2);
1523 ASSERT_NE(ret, HC_SUCCESS);
1524 }
1525
1526 class GmDelMultiMembersFromGroupTest : public testing::Test {
1527 public:
1528 static void SetUpTestCase();
1529 static void TearDownTestCase();
1530 void SetUp();
1531 void TearDown();
1532 };
1533
SetUpTestCase()1534 void GmDelMultiMembersFromGroupTest::SetUpTestCase() {}
TearDownTestCase()1535 void GmDelMultiMembersFromGroupTest::TearDownTestCase() {}
1536
SetUp()1537 void GmDelMultiMembersFromGroupTest::SetUp()
1538 {
1539 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
1540 int ret = InitDeviceAuthService();
1541 ASSERT_EQ(ret, HC_SUCCESS);
1542 const DeviceGroupManager *gm = GetGmInstance();
1543 ASSERT_NE(gm, nullptr);
1544 ret = gm->unRegCallback(TEST_APP_ID);
1545 ASSERT_EQ(ret, HC_SUCCESS);
1546 }
1547
TearDown()1548 void GmDelMultiMembersFromGroupTest::TearDown()
1549 {
1550 DestroyDeviceAuthService();
1551 }
1552
1553 HWTEST_F(GmDelMultiMembersFromGroupTest, GmDelMultiMembersFromGroupTest001, TestSize.Level0)
1554 {
1555 const DeviceGroupManager *gm = GetGmInstance();
1556 ASSERT_NE(gm, nullptr);
1557 int32_t ret = gm->delMultiMembersFromGroup(DEFAULT_OS_ACCOUNT, nullptr, TEST_QUERY_PARAMS);
1558 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1559 }
1560
1561 HWTEST_F(GmDelMultiMembersFromGroupTest, GmDelMultiMembersFromGroupTest002, TestSize.Level0)
1562 {
1563 const DeviceGroupManager *gm = GetGmInstance();
1564 ASSERT_NE(gm, nullptr);
1565 int32_t ret = gm->delMultiMembersFromGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, nullptr);
1566 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1567 }
1568
1569 HWTEST_F(GmDelMultiMembersFromGroupTest, GmDelMultiMembersFromGroupTest003, TestSize.Level0)
1570 {
1571 const DeviceGroupManager *gm = GetGmInstance();
1572 ASSERT_NE(gm, nullptr);
1573 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1574 ASSERT_EQ(ret, HC_SUCCESS);
1575 ret = gm->delMultiMembersFromGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, g_deleteParams2);
1576 ASSERT_NE(ret, HC_SUCCESS);
1577 }
1578
1579 class GmGetRegisterInfoTest : public testing::Test {
1580 public:
1581 static void SetUpTestCase();
1582 static void TearDownTestCase();
1583 void SetUp();
1584 void TearDown();
1585 };
1586
SetUpTestCase()1587 void GmGetRegisterInfoTest::SetUpTestCase() {}
TearDownTestCase()1588 void GmGetRegisterInfoTest::TearDownTestCase() {}
1589
SetUp()1590 void GmGetRegisterInfoTest::SetUp()
1591 {
1592 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
1593 int ret = InitDeviceAuthService();
1594 EXPECT_EQ(ret, HC_SUCCESS);
1595 }
1596
TearDown()1597 void GmGetRegisterInfoTest::TearDown()
1598 {
1599 DestroyDeviceAuthService();
1600 }
1601
1602 HWTEST_F(GmGetRegisterInfoTest, GmGetRegisterInfoTest001, TestSize.Level0)
1603 {
1604 const DeviceGroupManager *gm = GetGmInstance();
1605 ASSERT_NE(gm, nullptr);
1606 char *returnData = nullptr;
1607 int32_t ret = gm->getRegisterInfo(nullptr, &returnData);
1608 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1609 }
1610
1611 HWTEST_F(GmGetRegisterInfoTest, GmGetRegisterInfoTest002, TestSize.Level0)
1612 {
1613 const DeviceGroupManager *gm = GetGmInstance();
1614 ASSERT_NE(gm, nullptr);
1615 int32_t ret = gm->getRegisterInfo(TEST_QUERY_PARAMS, nullptr);
1616 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1617 }
1618
1619 HWTEST_F(GmGetRegisterInfoTest, GmGetRegisterInfoTest003, TestSize.Level0)
1620 {
1621 const DeviceGroupManager *gm = GetGmInstance();
1622 ASSERT_NE(gm, nullptr);
1623 char *returnData = nullptr;
1624 int32_t ret = gm->getRegisterInfo(g_getRegisterInfoParams, &returnData);
1625 ASSERT_EQ(ret, HC_SUCCESS);
1626 ASSERT_NE(returnData, nullptr);
1627 gm->destroyInfo(&returnData);
1628 }
1629
1630 class GaAuthDeviceTest : public testing::Test {
1631 public:
1632 static void SetUpTestCase();
1633 static void TearDownTestCase();
1634 void SetUp();
1635 void TearDown();
1636 };
1637
SetUpTestCase()1638 void GaAuthDeviceTest::SetUpTestCase()
1639 {
1640 NativeTokenSet(PROC_NAME_SOFT_BUS);
1641 int ret = InitDeviceAuthService();
1642 ASSERT_EQ(ret, HC_SUCCESS);
1643 }
1644
TearDownTestCase()1645 void GaAuthDeviceTest::TearDownTestCase()
1646 {
1647 DestroyDeviceAuthService();
1648 }
1649
SetUp()1650 void GaAuthDeviceTest::SetUp() {}
TearDown()1651 void GaAuthDeviceTest::TearDown() {}
1652
1653 HWTEST_F(GaAuthDeviceTest, GaAuthDeviceTest001, TestSize.Level0)
1654 {
1655 const GroupAuthManager *ga = GetGaInstance();
1656 ASSERT_NE(ga, nullptr);
1657 int32_t ret = ga->authDevice(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, nullptr, &g_gmCallback);
1658 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1659 }
1660
1661 HWTEST_F(GaAuthDeviceTest, GaAuthDeviceTest002, TestSize.Level0)
1662 {
1663 const GroupAuthManager *ga = GetGaInstance();
1664 ASSERT_NE(ga, nullptr);
1665 int32_t ret = ga->authDevice(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, g_authParams, nullptr);
1666 ASSERT_NE(ret, HC_SUCCESS);
1667 }
1668
1669 HWTEST_F(GaAuthDeviceTest, GaAuthDeviceTest003, TestSize.Level0)
1670 {
1671 const GroupAuthManager *ga = GetGaInstance();
1672 ASSERT_NE(ga, nullptr);
1673 int32_t ret = ga->authDevice(DEFAULT_OS_ACCOUNT, TEST_REQ_ID4, g_authParams, &g_gaCallback);
1674 ASSERT_EQ(ret, HC_SUCCESS);
1675 }
1676
1677 class GaProcessDataTest : public testing::Test {
1678 public:
1679 static void SetUpTestCase();
1680 static void TearDownTestCase();
1681 void SetUp();
1682 void TearDown();
1683 };
1684
SetUpTestCase()1685 void GaProcessDataTest::SetUpTestCase()
1686 {
1687 NativeTokenSet(PROC_NAME_SOFT_BUS);
1688 int ret = InitDeviceAuthService();
1689 ASSERT_EQ(ret, HC_SUCCESS);
1690 }
1691
TearDownTestCase()1692 void GaProcessDataTest::TearDownTestCase()
1693 {
1694 DestroyDeviceAuthService();
1695 }
1696
SetUp()1697 void GaProcessDataTest::SetUp() {}
TearDown()1698 void GaProcessDataTest::TearDown() {}
1699
1700 HWTEST_F(GaProcessDataTest, GaProcessDataTest001, TestSize.Level0)
1701 {
1702 const GroupAuthManager *ga = GetGaInstance();
1703 ASSERT_NE(ga, nullptr);
1704 int32_t ret = ga->processData(TEST_REQ_ID, nullptr, 0, &g_gaCallback);
1705 ASSERT_NE(ret, HC_SUCCESS);
1706 }
1707
1708 HWTEST_F(GaProcessDataTest, GaProcessDataTest002, TestSize.Level0)
1709 {
1710 const GroupAuthManager *ga = GetGaInstance();
1711 ASSERT_NE(ga, nullptr);
1712 int32_t ret = ga->processData(TEST_REQ_ID, (const uint8_t *)g_processData, 0, &g_gaCallback);
1713 ASSERT_NE(ret, HC_SUCCESS);
1714 }
1715
1716 HWTEST_F(GaProcessDataTest, GaProcessDataTest003, TestSize.Level0)
1717 {
1718 const GroupAuthManager *ga = GetGaInstance();
1719 ASSERT_NE(ga, nullptr);
1720 int32_t ret = ga->processData(TEST_REQ_ID, (const uint8_t *)g_processData, 4097, &g_gaCallback);
1721 ASSERT_NE(ret, HC_SUCCESS);
1722 }
1723
1724 HWTEST_F(GaProcessDataTest, GaProcessDataTest004, TestSize.Level0)
1725 {
1726 const GroupAuthManager *ga = GetGaInstance();
1727 ASSERT_NE(ga, nullptr);
1728 int32_t ret = ga->processData(TEST_REQ_ID, (const uint8_t *)g_processData, strlen(g_processData) + 1, nullptr);
1729 ASSERT_NE(ret, HC_SUCCESS);
1730 }
1731
1732 HWTEST_F(GaProcessDataTest, GaProcessDataTest005, TestSize.Level0)
1733 {
1734 const GroupAuthManager *ga = GetGaInstance();
1735 ASSERT_NE(ga, nullptr);
1736 int32_t ret = ga->processData(TEST_REQ_ID, (const uint8_t *)g_processData,
1737 strlen(g_processData) + 1, &g_gaCallback);
1738 ASSERT_NE(ret, HC_SUCCESS);
1739 }
1740
1741 class GmDeleteGroupTest : public testing::Test {
1742 public:
1743 static void SetUpTestCase();
1744 static void TearDownTestCase();
1745 void SetUp();
1746 void TearDown();
1747 };
1748
SetUpTestCase()1749 void GmDeleteGroupTest::SetUpTestCase() {}
TearDownTestCase()1750 void GmDeleteGroupTest::TearDownTestCase() {}
1751
SetUp()1752 void GmDeleteGroupTest::SetUp()
1753 {
1754 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
1755 int ret = InitDeviceAuthService();
1756 ASSERT_EQ(ret, HC_SUCCESS);
1757 const DeviceGroupManager *gm = GetGmInstance();
1758 ASSERT_NE(gm, nullptr);
1759 ret = gm->unRegCallback(TEST_APP_ID);
1760 ASSERT_EQ(ret, HC_SUCCESS);
1761 }
1762
TearDown()1763 void GmDeleteGroupTest::TearDown()
1764 {
1765 DestroyDeviceAuthService();
1766 }
1767
1768 HWTEST_F(GmDeleteGroupTest, GmDeleteGroupTest001, TestSize.Level0)
1769 {
1770 const DeviceGroupManager *gm = GetGmInstance();
1771 ASSERT_NE(gm, nullptr);
1772 int32_t ret = gm->deleteGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, nullptr, g_disbandParams);
1773 ASSERT_NE(ret, HC_SUCCESS);
1774 }
1775
1776 HWTEST_F(GmDeleteGroupTest, GmDeleteGroupTest002, TestSize.Level0)
1777 {
1778 const DeviceGroupManager *gm = GetGmInstance();
1779 ASSERT_NE(gm, nullptr);
1780 int32_t ret = gm->deleteGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, nullptr);
1781 ASSERT_NE(ret, HC_SUCCESS);
1782 }
1783
1784 HWTEST_F(GmDeleteGroupTest, GmDeleteGroupTest003, TestSize.Level0)
1785 {
1786 const DeviceGroupManager *gm = GetGmInstance();
1787 ASSERT_NE(gm, nullptr);
1788 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1789 ASSERT_EQ(ret, HC_SUCCESS);
1790 DeleteDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_disbandParams);
1791 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1792 DeleteDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_disbandParams2);
1793 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1794 }
1795
1796 class GmUnRegCallbackTest : public testing::Test {
1797 public:
1798 static void SetUpTestCase();
1799 static void TearDownTestCase();
1800 void SetUp();
1801 void TearDown();
1802 };
1803
SetUpTestCase()1804 void GmUnRegCallbackTest::SetUpTestCase() {}
TearDownTestCase()1805 void GmUnRegCallbackTest::TearDownTestCase() {}
1806
SetUp()1807 void GmUnRegCallbackTest::SetUp()
1808 {
1809 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
1810 int ret = InitDeviceAuthService();
1811 EXPECT_EQ(ret, HC_SUCCESS);
1812 }
1813
TearDown()1814 void GmUnRegCallbackTest::TearDown()
1815 {
1816 DestroyDeviceAuthService();
1817 }
1818
1819 HWTEST_F(GmUnRegCallbackTest, GmUnRegCallbackTest001, TestSize.Level0)
1820 {
1821 const DeviceGroupManager *gm = GetGmInstance();
1822 ASSERT_NE(gm, nullptr);
1823 DeviceAuthCallback callback;
1824 int32_t ret = gm->regCallback(TEST_APP_ID, &callback);
1825 ASSERT_EQ(ret, HC_SUCCESS);
1826 ret = gm->unRegCallback(TEST_APP_ID);
1827 ASSERT_EQ(ret, HC_SUCCESS);
1828 }
1829
1830 HWTEST_F(GmUnRegCallbackTest, GmUnRegCallbackTest002, TestSize.Level0)
1831 {
1832 const DeviceGroupManager *gm = GetGmInstance();
1833 ASSERT_NE(gm, nullptr);
1834 int32_t ret = gm->unRegCallback(TEST_APP_ID);
1835 ASSERT_EQ(ret, HC_SUCCESS);
1836 }
1837
1838 HWTEST_F(GmUnRegCallbackTest, GmUnRegCallbackTest003, TestSize.Level0)
1839 {
1840 const DeviceGroupManager *gm = GetGmInstance();
1841 ASSERT_NE(gm, nullptr);
1842 int32_t ret = gm->unRegCallback(nullptr);
1843 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1844 }
1845
1846 class GmUnRegDataChangeListenerTest : public testing::Test {
1847 public:
1848 static void SetUpTestCase();
1849 static void TearDownTestCase();
1850 void SetUp();
1851 void TearDown();
1852 };
1853
SetUpTestCase()1854 void GmUnRegDataChangeListenerTest::SetUpTestCase() {}
TearDownTestCase()1855 void GmUnRegDataChangeListenerTest::TearDownTestCase() {}
1856
SetUp()1857 void GmUnRegDataChangeListenerTest::SetUp()
1858 {
1859 NativeTokenSet(PROC_NAME_SOFT_BUS);
1860 int ret = InitDeviceAuthService();
1861 EXPECT_EQ(ret, HC_SUCCESS);
1862 }
1863
TearDown()1864 void GmUnRegDataChangeListenerTest::TearDown()
1865 {
1866 DestroyDeviceAuthService();
1867 }
1868
1869 HWTEST_F(GmUnRegDataChangeListenerTest, GmUnRegDataChangeListenerTest001, TestSize.Level0)
1870 {
1871 const DeviceGroupManager *gm = GetGmInstance();
1872 ASSERT_NE(gm, nullptr);
1873 int32_t ret = gm->regDataChangeListener(TEST_APP_ID, &g_listener);
1874 ASSERT_EQ(ret, HC_SUCCESS);
1875 ret = gm->unRegDataChangeListener(TEST_APP_ID);
1876 ASSERT_EQ(ret, HC_SUCCESS);
1877 }
1878
1879 HWTEST_F(GmUnRegDataChangeListenerTest, GmUnRegDataChangeListenerTest002, TestSize.Level0)
1880 {
1881 const DeviceGroupManager *gm = GetGmInstance();
1882 ASSERT_NE(gm, nullptr);
1883 int32_t ret = gm->unRegDataChangeListener(TEST_APP_ID);
1884 ASSERT_EQ(ret, HC_SUCCESS);
1885 }
1886
1887 HWTEST_F(GmUnRegDataChangeListenerTest, GmUnRegDataChangeListenerTest003, TestSize.Level0)
1888 {
1889 const DeviceGroupManager *gm = GetGmInstance();
1890 ASSERT_NE(gm, nullptr);
1891 int32_t ret = gm->unRegDataChangeListener(nullptr);
1892 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1893 }
1894
1895 class GmCancelRequestTest : public testing::Test {
1896 public:
1897 static void SetUpTestCase();
1898 static void TearDownTestCase();
1899 void SetUp();
1900 void TearDown();
1901 };
1902
SetUpTestCase()1903 void GmCancelRequestTest::SetUpTestCase()
1904 {
1905 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
1906 int ret = InitDeviceAuthService();
1907 EXPECT_EQ(ret, HC_SUCCESS);
1908 }
1909
TearDownTestCase()1910 void GmCancelRequestTest::TearDownTestCase()
1911 {
1912 DestroyDeviceAuthService();
1913 }
1914
SetUp()1915 void GmCancelRequestTest::SetUp() {}
TearDown()1916 void GmCancelRequestTest::TearDown() {}
1917
1918 HWTEST_F(GmCancelRequestTest, GmCancelRequestTest001, TestSize.Level0)
1919 {
1920 const DeviceGroupManager *gm = GetGmInstance();
1921 ASSERT_NE(gm, nullptr);
1922 gm->cancelRequest(TEST_REQ_ID, nullptr);
1923 }
1924
1925 HWTEST_F(GmCancelRequestTest, GmCancelRequestTest002, TestSize.Level0)
1926 {
1927 const DeviceGroupManager *gm = GetGmInstance();
1928 ASSERT_NE(gm, nullptr);
1929 gm->cancelRequest(TEST_REQ_ID, TEST_APP_ID);
1930 }
1931
1932 class GaCancelRequestTest : public testing::Test {
1933 public:
1934 static void SetUpTestCase();
1935 static void TearDownTestCase();
1936 void SetUp();
1937 void TearDown();
1938 };
1939
SetUpTestCase()1940 void GaCancelRequestTest::SetUpTestCase()
1941 {
1942 NativeTokenSet(PROC_NAME_SOFT_BUS);
1943 int ret = InitDeviceAuthService();
1944 EXPECT_EQ(ret, HC_SUCCESS);
1945 }
1946
TearDownTestCase()1947 void GaCancelRequestTest::TearDownTestCase()
1948 {
1949 DestroyDeviceAuthService();
1950 }
1951
SetUp()1952 void GaCancelRequestTest::SetUp() {}
TearDown()1953 void GaCancelRequestTest::TearDown() {}
1954
1955 HWTEST_F(GaCancelRequestTest, GaCancelRequestTest001, TestSize.Level0)
1956 {
1957 const GroupAuthManager *ga = GetGaInstance();
1958 ASSERT_NE(ga, nullptr);
1959 ga->cancelRequest(TEST_REQ_ID, nullptr);
1960 }
1961
1962 HWTEST_F(GaCancelRequestTest, GaCancelRequestTest002, TestSize.Level0)
1963 {
1964 const GroupAuthManager *ga = GetGaInstance();
1965 ASSERT_NE(ga, nullptr);
1966 ga->cancelRequest(TEST_REQ_ID, TEST_APP_ID);
1967 }
1968 }
1969