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