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