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 }
454
455 HWTEST_F(GmRegCallbackTest, GmRegCallbackTest003, TestSize.Level0)
456 {
457 const DeviceGroupManager *gm = GetGmInstance();
458 ASSERT_NE(gm, nullptr);
459 DeviceAuthCallback callback;
460 int32_t ret = gm->regCallback(nullptr, &callback);
461 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
462 }
463
464 HWTEST_F(GmRegCallbackTest, GmRegCallbackTest004, TestSize.Level0)
465 {
466 const DeviceGroupManager *gm = GetGmInstance();
467 ASSERT_NE(gm, nullptr);
468 int32_t ret = gm->regCallback(TEST_APP_ID, nullptr);
469 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
470 }
471
472 class GmRegDataChangeListenerTest : public testing::Test {
473 public:
474 static void SetUpTestCase();
475 static void TearDownTestCase();
476 void SetUp();
477 void TearDown();
478 };
479
SetUpTestCase()480 void GmRegDataChangeListenerTest::SetUpTestCase() {}
TearDownTestCase()481 void GmRegDataChangeListenerTest::TearDownTestCase() {}
482
SetUp()483 void GmRegDataChangeListenerTest::SetUp()
484 {
485 NativeTokenSet(PROC_NAME_SOFT_BUS);
486 int ret = InitDeviceAuthService();
487 EXPECT_EQ(ret, HC_SUCCESS);
488 }
489
TearDown()490 void GmRegDataChangeListenerTest::TearDown()
491 {
492 DestroyDeviceAuthService();
493 }
494
495 HWTEST_F(GmRegDataChangeListenerTest, GmRegDataChangeListenerTest001, TestSize.Level0)
496 {
497 const DeviceGroupManager *gm = GetGmInstance();
498 ASSERT_NE(gm, nullptr);
499 int32_t ret = gm->regDataChangeListener(TEST_APP_ID, &g_listener);
500 ASSERT_EQ(ret, HC_SUCCESS);
501 }
502
503 HWTEST_F(GmRegDataChangeListenerTest, GmRegDataChangeListenerTest002, TestSize.Level0)
504 {
505 const DeviceGroupManager *gm = GetGmInstance();
506 ASSERT_NE(gm, nullptr);
507 int32_t ret = gm->regDataChangeListener(TEST_APP_ID, &g_listener);
508 ASSERT_EQ(ret, HC_SUCCESS);
509 ret = gm->regDataChangeListener(TEST_APP_ID, &g_listener);
510 ASSERT_EQ(ret, HC_SUCCESS);
511 }
512
513 HWTEST_F(GmRegDataChangeListenerTest, GmRegDataChangeListenerTest003, TestSize.Level0)
514 {
515 const DeviceGroupManager *gm = GetGmInstance();
516 ASSERT_NE(gm, nullptr);
517 int32_t ret = gm->regDataChangeListener(nullptr, &g_listener);
518 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
519 }
520
521 HWTEST_F(GmRegDataChangeListenerTest, GmRegDataChangeListenerTest004, TestSize.Level0)
522 {
523 const DeviceGroupManager *gm = GetGmInstance();
524 ASSERT_NE(gm, nullptr);
525 int32_t ret = gm->regDataChangeListener(TEST_APP_ID, nullptr);
526 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
527 }
528
529 class GmCreateGroupTest : public testing::Test {
530 public:
531 static void SetUpTestCase();
532 static void TearDownTestCase();
533 void SetUp();
534 void TearDown();
535 };
536
SetUpTestCase()537 void GmCreateGroupTest::SetUpTestCase()
538 {
539 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
540 int ret = InitDeviceAuthService();
541 ASSERT_EQ(ret, HC_SUCCESS);
542 const DeviceGroupManager *gm = GetGmInstance();
543 ASSERT_NE(gm, nullptr);
544 ret = gm->unRegCallback(TEST_APP_ID);
545 ASSERT_EQ(ret, HC_SUCCESS);
546 }
547
TearDownTestCase()548 void GmCreateGroupTest::TearDownTestCase()
549 {
550 DestroyDeviceAuthService();
551 }
552
SetUp()553 void GmCreateGroupTest::SetUp() {}
TearDown()554 void GmCreateGroupTest::TearDown() {}
555
556 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest001, TestSize.Level0)
557 {
558 const DeviceGroupManager *gm = GetGmInstance();
559 ASSERT_NE(gm, nullptr);
560 int32_t ret = gm->createGroup(TEST_OS_ACCOUNT_ID, TEST_REQ_ID, nullptr, CREATE_PARAMS);
561 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
562 }
563
564 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest002, TestSize.Level0)
565 {
566 const DeviceGroupManager *gm = GetGmInstance();
567 ASSERT_NE(gm, nullptr);
568 int32_t ret = gm->createGroup(TEST_OS_ACCOUNT_ID, TEST_REQ_ID, TEST_APP_ID, nullptr);
569 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
570 }
571
572 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest003, TestSize.Level0)
573 {
574 const DeviceGroupManager *gm = GetGmInstance();
575 ASSERT_NE(gm, nullptr);
576 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
577 ASSERT_EQ(ret, HC_SUCCESS);
578 CreateDemoGroup(TEST_OS_ACCOUNT_ID, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
579 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
580 CreateDemoGroup(TEST_OS_ACCOUNT_ID, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS2);
581 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
582 }
583
584 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest004, TestSize.Level0)
585 {
586 const DeviceGroupManager *gm = GetGmInstance();
587 ASSERT_NE(gm, nullptr);
588 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
589 ASSERT_EQ(ret, HC_SUCCESS);
590 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
591 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_ERROR);
592 }
593
594 class GmDestroyInfoTest : public testing::Test {
595 public:
596 static void SetUpTestCase();
597 static void TearDownTestCase();
598 void SetUp();
599 void TearDown();
600 };
601
SetUpTestCase()602 void GmDestroyInfoTest::SetUpTestCase()
603 {
604 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
605 int ret = InitDeviceAuthService();
606 ASSERT_EQ(ret, HC_SUCCESS);
607 }
608
TearDownTestCase()609 void GmDestroyInfoTest::TearDownTestCase()
610 {
611 DestroyDeviceAuthService();
612 }
613
SetUp()614 void GmDestroyInfoTest::SetUp() {}
TearDown()615 void GmDestroyInfoTest::TearDown() {}
616
617 HWTEST_F(GmDestroyInfoTest, GmDestroyInfoTest001, TestSize.Level0)
618 {
619 const DeviceGroupManager *gm = GetGmInstance();
620 ASSERT_NE(gm, nullptr);
621 gm->destroyInfo(nullptr);
622 }
623
624 HWTEST_F(GmDestroyInfoTest, GmDestroyInfoTest002, TestSize.Level0)
625 {
626 const DeviceGroupManager *gm = GetGmInstance();
627 ASSERT_NE(gm, nullptr);
628 char *str = nullptr;
629 gm->destroyInfo(&str);
630 }
631
632 class GmCheckAccessToGroupTest : public testing::Test {
633 public:
634 static void SetUpTestCase();
635 static void TearDownTestCase();
636 void SetUp();
637 void TearDown();
638 };
639
SetUpTestCase()640 void GmCheckAccessToGroupTest::SetUpTestCase()
641 {
642 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
643 int ret = InitDeviceAuthService();
644 ASSERT_EQ(ret, HC_SUCCESS);
645 }
646
TearDownTestCase()647 void GmCheckAccessToGroupTest::TearDownTestCase()
648 {
649 DestroyDeviceAuthService();
650 }
651
SetUp()652 void GmCheckAccessToGroupTest::SetUp() {}
653
TearDown()654 void GmCheckAccessToGroupTest::TearDown() {}
655
656 HWTEST_F(GmCheckAccessToGroupTest, GmCheckAccessToGroupTest001, TestSize.Level0)
657 {
658 const DeviceGroupManager *gm = GetGmInstance();
659 ASSERT_NE(gm, nullptr);
660 int32_t ret = gm->checkAccessToGroup(TEST_OS_ACCOUNT_ID, nullptr, TEST_GROUP_ID);
661 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
662 }
663
664 HWTEST_F(GmCheckAccessToGroupTest, GmCheckAccessToGroupTest002, TestSize.Level0)
665 {
666 const DeviceGroupManager *gm = GetGmInstance();
667 ASSERT_NE(gm, nullptr);
668 int32_t ret = gm->checkAccessToGroup(TEST_OS_ACCOUNT_ID, TEST_APP_ID, nullptr);
669 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
670 }
671
672 HWTEST_F(GmCheckAccessToGroupTest, GmCheckAccessToGroupTest003, TestSize.Level0)
673 {
674 const DeviceGroupManager *gm = GetGmInstance();
675 ASSERT_NE(gm, nullptr);
676 int32_t ret = gm->checkAccessToGroup(TEST_OS_ACCOUNT_ID, TEST_APP_ID, TEST_GROUP_ID);
677 ASSERT_EQ(ret, HC_SUCCESS);
678 }
679
680 HWTEST_F(GmCheckAccessToGroupTest, GmCheckAccessToGroupTest004, TestSize.Level0)
681 {
682 const DeviceGroupManager *gm = GetGmInstance();
683 ASSERT_NE(gm, nullptr);
684 int32_t ret = gm->checkAccessToGroup(TEST_OS_ACCOUNT_ID, TEST_APP_ID2, TEST_GROUP_ID2);
685 ASSERT_NE(ret, HC_SUCCESS);
686 }
687
688 HWTEST_F(GmCheckAccessToGroupTest, GmCheckAccessToGroupTest005, TestSize.Level0)
689 {
690 const DeviceGroupManager *gm = GetGmInstance();
691 ASSERT_NE(gm, nullptr);
692 int32_t ret = gm->checkAccessToGroup(TEST_OS_ACCOUNT_ID, TEST_APP_ID, TEST_GROUP_ID3);
693 ASSERT_NE(ret, HC_SUCCESS);
694 }
695
696 HWTEST_F(GmCheckAccessToGroupTest, GmCheckAccessToGroupTest006, TestSize.Level0)
697 {
698 const DeviceGroupManager *gm = GetGmInstance();
699 ASSERT_NE(gm, nullptr);
700 int32_t ret = gm->checkAccessToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID3);
701 ASSERT_NE(ret, HC_SUCCESS);
702 }
703
704 class GmGetPkInfoListTest : public testing::Test {
705 public:
706 static void SetUpTestCase();
707 static void TearDownTestCase();
708 void SetUp();
709 void TearDown();
710 };
711
SetUpTestCase()712 void GmGetPkInfoListTest::SetUpTestCase() {}
TearDownTestCase()713 void GmGetPkInfoListTest::TearDownTestCase() {}
714
SetUp()715 void GmGetPkInfoListTest::SetUp()
716 {
717 NativeTokenSet(PROC_NAME_DEVICE_SECURITY_LEVEL);
718 int ret = InitDeviceAuthService();
719 EXPECT_EQ(ret, HC_SUCCESS);
720 }
721
TearDown()722 void GmGetPkInfoListTest::TearDown()
723 {
724 DestroyDeviceAuthService();
725 }
726
727 HWTEST_F(GmGetPkInfoListTest, GmGetPkInfoListTest001, TestSize.Level0)
728 {
729 const DeviceGroupManager *gm = GetGmInstance();
730 ASSERT_NE(gm, nullptr);
731 char *returnData = nullptr;
732 uint32_t returnNum = 0;
733 int32_t ret = gm->getPkInfoList(TEST_OS_ACCOUNT_ID, nullptr, TEST_QUERY_PARAMS, &returnData, &returnNum);
734 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
735 }
736
737 HWTEST_F(GmGetPkInfoListTest, GmGetPkInfoListTest002, TestSize.Level0)
738 {
739 const DeviceGroupManager *gm = GetGmInstance();
740 ASSERT_NE(gm, nullptr);
741 char *returnData = nullptr;
742 uint32_t returnNum = 0;
743 int32_t ret = gm->getPkInfoList(TEST_OS_ACCOUNT_ID, TEST_APP_ID, nullptr, &returnData, &returnNum);
744 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
745 }
746
747 HWTEST_F(GmGetPkInfoListTest, GmGetPkInfoListTest003, TestSize.Level0)
748 {
749 const DeviceGroupManager *gm = GetGmInstance();
750 ASSERT_NE(gm, nullptr);
751 uint32_t returnNum = 0;
752 int32_t ret = gm->getPkInfoList(TEST_OS_ACCOUNT_ID, TEST_APP_ID, TEST_QUERY_PARAMS, nullptr, &returnNum);
753 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
754 }
755
756 HWTEST_F(GmGetPkInfoListTest, GmGetPkInfoListTest004, TestSize.Level0)
757 {
758 const DeviceGroupManager *gm = GetGmInstance();
759 ASSERT_NE(gm, nullptr);
760 char *returnData = nullptr;
761 int32_t ret = gm->getPkInfoList(TEST_OS_ACCOUNT_ID, TEST_APP_ID, TEST_QUERY_PARAMS, &returnData, nullptr);
762 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
763 }
764
765 HWTEST_F(GmGetPkInfoListTest, GmGetPkInfoListTest005, TestSize.Level0)
766 {
767 const DeviceGroupManager *gm = GetGmInstance();
768 EXPECT_NE(gm, nullptr);
769 char *returnData = nullptr;
770 uint32_t returnNum = 0;
771 const char *queryParams = "{\"udid\":\"5420459D93FE773F9945FD64277FBA2CAB8FB996DDC1D0B97676FBB1242"
772 "B3930\",\"isSelfPk\":true}";
773 int32_t ret = gm->getPkInfoList(TEST_OS_ACCOUNT_ID, TEST_APP_ID, queryParams, &returnData, &returnNum);
774 ASSERT_EQ(ret, HC_SUCCESS);
775 ASSERT_NE(returnData, nullptr);
776 ASSERT_EQ(returnNum, 0);
777 gm->destroyInfo(&returnData);
778 }
779
780 HWTEST_F(GmGetPkInfoListTest, GmGetPkInfoListTest006, TestSize.Level0)
781 {
782 const DeviceGroupManager *gm = GetGmInstance();
783 EXPECT_NE(gm, nullptr);
784 char *returnData = nullptr;
785 uint32_t returnNum = 0;
786 const char *queryParams = "{\"udid\":\"ABCD\",\"isSelfPk\":true}";
787 int32_t ret = gm->getPkInfoList(TEST_OS_ACCOUNT_ID, TEST_APP_ID, queryParams, &returnData, &returnNum);
788 ASSERT_EQ(ret, HC_SUCCESS);
789 ASSERT_NE(returnData, nullptr);
790 gm->destroyInfo(&returnData);
791 }
792
793 HWTEST_F(GmGetPkInfoListTest, GmGetPkInfoListTest007, TestSize.Level0)
794 {
795 const DeviceGroupManager *gm = GetGmInstance();
796 EXPECT_NE(gm, nullptr);
797 char *returnData = nullptr;
798 uint32_t returnNum = 0;
799 const char *queryParams = "{\"udid\":\"ABCD\",\"isSelfPk\":true}";
800 int32_t ret = gm->getPkInfoList(DEFAULT_OS_ACCOUNT, TEST_APP_ID, queryParams, &returnData, &returnNum);
801 ASSERT_NE(ret, HC_SUCCESS);
802 }
803
804 class GmGetGroupInfoByIdTest : public testing::Test {
805 public:
806 static void SetUpTestCase();
807 static void TearDownTestCase();
808 void SetUp();
809 void TearDown();
810 };
811
SetUpTestCase()812 void GmGetGroupInfoByIdTest::SetUpTestCase() {}
TearDownTestCase()813 void GmGetGroupInfoByIdTest::TearDownTestCase() {}
814
SetUp()815 void GmGetGroupInfoByIdTest::SetUp()
816 {
817 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
818 int ret = InitDeviceAuthService();
819 EXPECT_EQ(ret, HC_SUCCESS);
820 }
821
TearDown()822 void GmGetGroupInfoByIdTest::TearDown()
823 {
824 DestroyDeviceAuthService();
825 }
826
827 HWTEST_F(GmGetGroupInfoByIdTest, GmGetGroupInfoByIdTest001, TestSize.Level0)
828 {
829 const DeviceGroupManager *gm = GetGmInstance();
830 ASSERT_NE(gm, nullptr);
831 char *returnData = nullptr;
832 int32_t ret = gm->getGroupInfoById(TEST_OS_ACCOUNT_ID, nullptr, TEST_GROUP_ID, &returnData);
833 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
834 }
835
836 HWTEST_F(GmGetGroupInfoByIdTest, GmGetGroupInfoByIdTest002, TestSize.Level0)
837 {
838 const DeviceGroupManager *gm = GetGmInstance();
839 ASSERT_NE(gm, nullptr);
840 char *returnData = nullptr;
841 int32_t ret = gm->getGroupInfoById(TEST_OS_ACCOUNT_ID, TEST_APP_ID, nullptr, &returnData);
842 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
843 }
844
845 HWTEST_F(GmGetGroupInfoByIdTest, GmGetGroupInfoByIdTest003, TestSize.Level0)
846 {
847 const DeviceGroupManager *gm = GetGmInstance();
848 ASSERT_NE(gm, nullptr);
849 int32_t ret = gm->getGroupInfoById(TEST_OS_ACCOUNT_ID, TEST_APP_ID, TEST_GROUP_ID, nullptr);
850 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
851 }
852
853 HWTEST_F(GmGetGroupInfoByIdTest, GmGetGroupInfoByIdTest004, TestSize.Level0)
854 {
855 const DeviceGroupManager *gm = GetGmInstance();
856 ASSERT_NE(gm, nullptr);
857 char *returnData = nullptr;
858 int32_t ret = gm->getGroupInfoById(TEST_OS_ACCOUNT_ID, TEST_APP_ID, TEST_GROUP_ID, &returnData);
859 ASSERT_EQ(ret, HC_SUCCESS);
860 ASSERT_NE(returnData, nullptr);
861 gm->destroyInfo(&returnData);
862 }
863
864 HWTEST_F(GmGetGroupInfoByIdTest, GmGetGroupInfoByIdTest005, TestSize.Level0)
865 {
866 const DeviceGroupManager *gm = GetGmInstance();
867 ASSERT_NE(gm, nullptr);
868 char *returnData = nullptr;
869 int32_t ret = gm->getGroupInfoById(TEST_OS_ACCOUNT_ID, TEST_APP_ID2, TEST_GROUP_ID2, &returnData);
870 ASSERT_NE(ret, HC_SUCCESS);
871 }
872
873 HWTEST_F(GmGetGroupInfoByIdTest, GmGetGroupInfoByIdTest006, TestSize.Level0)
874 {
875 const DeviceGroupManager *gm = GetGmInstance();
876 ASSERT_NE(gm, nullptr);
877 char *returnData = nullptr;
878 int32_t ret = gm->getGroupInfoById(TEST_OS_ACCOUNT_ID, TEST_APP_ID, TEST_GROUP_ID3, &returnData);
879 ASSERT_NE(ret, HC_SUCCESS);
880 }
881
882 HWTEST_F(GmGetGroupInfoByIdTest, GmGetGroupInfoByIdTest007, TestSize.Level0)
883 {
884 const DeviceGroupManager *gm = GetGmInstance();
885 ASSERT_NE(gm, nullptr);
886 char *returnData = nullptr;
887 int32_t ret = gm->getGroupInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID3, &returnData);
888 ASSERT_NE(ret, HC_SUCCESS);
889 }
890
891 class GmGetGroupInfoTest : public testing::Test {
892 public:
893 static void SetUpTestCase();
894 static void TearDownTestCase();
895 void SetUp();
896 void TearDown();
897 };
898
SetUpTestCase()899 void GmGetGroupInfoTest::SetUpTestCase() {}
TearDownTestCase()900 void GmGetGroupInfoTest::TearDownTestCase() {}
901
SetUp()902 void GmGetGroupInfoTest::SetUp()
903 {
904 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
905 int ret = InitDeviceAuthService();
906 EXPECT_EQ(ret, HC_SUCCESS);
907 }
908
TearDown()909 void GmGetGroupInfoTest::TearDown()
910 {
911 DestroyDeviceAuthService();
912 }
913
914 HWTEST_F(GmGetGroupInfoTest, GmGetGroupInfoTest001, TestSize.Level0)
915 {
916 const DeviceGroupManager *gm = GetGmInstance();
917 ASSERT_NE(gm, nullptr);
918 char *returnData = nullptr;
919 uint32_t returnNum = 0;
920 int32_t ret = gm->getGroupInfo(TEST_OS_ACCOUNT_ID, nullptr, TEST_QUERY_PARAMS, &returnData, &returnNum);
921 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
922 }
923
924 HWTEST_F(GmGetGroupInfoTest, GmGetGroupInfoTest002, TestSize.Level0)
925 {
926 const DeviceGroupManager *gm = GetGmInstance();
927 ASSERT_NE(gm, nullptr);
928 char *returnData = nullptr;
929 uint32_t returnNum = 0;
930 int32_t ret = gm->getGroupInfo(TEST_OS_ACCOUNT_ID, TEST_APP_ID, nullptr, &returnData, &returnNum);
931 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
932 }
933
934 HWTEST_F(GmGetGroupInfoTest, GmGetGroupInfoTest003, TestSize.Level0)
935 {
936 const DeviceGroupManager *gm = GetGmInstance();
937 ASSERT_NE(gm, nullptr);
938 uint32_t returnNum = 0;
939 int32_t ret = gm->getGroupInfo(TEST_OS_ACCOUNT_ID, TEST_APP_ID, TEST_QUERY_PARAMS, nullptr, &returnNum);
940 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
941 }
942
943 HWTEST_F(GmGetGroupInfoTest, GmGetGroupInfoTest004, TestSize.Level0)
944 {
945 const DeviceGroupManager *gm = GetGmInstance();
946 ASSERT_NE(gm, nullptr);
947 char *returnData = nullptr;
948 int32_t ret = gm->getGroupInfo(TEST_OS_ACCOUNT_ID, TEST_APP_ID, TEST_QUERY_PARAMS, &returnData, nullptr);
949 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
950 }
951
952 HWTEST_F(GmGetGroupInfoTest, GmGetGroupInfoTest005, TestSize.Level0)
953 {
954 const DeviceGroupManager *gm = GetGmInstance();
955 ASSERT_NE(gm, nullptr);
956 char *returnData = nullptr;
957 uint32_t returnNum = 0;
958 const char *queryParams = "{\"groupOwner\":\"TestAppId\"}";
959 int32_t ret = gm->getGroupInfo(TEST_OS_ACCOUNT_ID, TEST_APP_ID, queryParams, &returnData, &returnNum);
960 ASSERT_EQ(ret, HC_SUCCESS);
961 ASSERT_NE(returnData, nullptr);
962 gm->destroyInfo(&returnData);
963 }
964
965 HWTEST_F(GmGetGroupInfoTest, GmGetGroupInfoTest006, TestSize.Level0)
966 {
967 const DeviceGroupManager *gm = GetGmInstance();
968 ASSERT_NE(gm, nullptr);
969 char *returnData = nullptr;
970 uint32_t returnNum = 0;
971 const char *queryParams = "{\"groupOwner\":\"TestAppId2\"}";
972 int32_t ret = gm->getGroupInfo(TEST_OS_ACCOUNT_ID, TEST_APP_ID, queryParams, &returnData, &returnNum);
973 ASSERT_EQ(ret, HC_SUCCESS);
974 ASSERT_NE(returnData, nullptr);
975 gm->destroyInfo(&returnData);
976 }
977
978 HWTEST_F(GmGetGroupInfoTest, GmGetGroupInfoTest007, TestSize.Level0)
979 {
980 const DeviceGroupManager *gm = GetGmInstance();
981 ASSERT_NE(gm, nullptr);
982 char *returnData = nullptr;
983 uint32_t returnNum = 0;
984 const char *queryParams = "{\"groupOwner\":\"TestAppId2\"}";
985 int32_t ret = gm->getGroupInfo(DEFAULT_OS_ACCOUNT, TEST_APP_ID, queryParams, &returnData, &returnNum);
986 ASSERT_NE(ret, HC_SUCCESS);
987 }
988
989 class GmGetJoinedGroupsTest : public testing::Test {
990 public:
991 static void SetUpTestCase();
992 static void TearDownTestCase();
993 void SetUp();
994 void TearDown();
995 };
996
SetUpTestCase()997 void GmGetJoinedGroupsTest::SetUpTestCase() {}
TearDownTestCase()998 void GmGetJoinedGroupsTest::TearDownTestCase() {}
999
SetUp()1000 void GmGetJoinedGroupsTest::SetUp()
1001 {
1002 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
1003 int ret = InitDeviceAuthService();
1004 EXPECT_EQ(ret, HC_SUCCESS);
1005 }
1006
TearDown()1007 void GmGetJoinedGroupsTest::TearDown()
1008 {
1009 DestroyDeviceAuthService();
1010 }
1011
1012 HWTEST_F(GmGetJoinedGroupsTest, GmGetJoinedGroupsTest001, TestSize.Level0)
1013 {
1014 const DeviceGroupManager *gm = GetGmInstance();
1015 ASSERT_NE(gm, nullptr);
1016 char *returnData = nullptr;
1017 uint32_t returnNum = 0;
1018 int32_t ret = gm->getJoinedGroups(TEST_OS_ACCOUNT_ID, nullptr, PEER_TO_PEER_GROUP, &returnData, &returnNum);
1019 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1020 }
1021
1022 HWTEST_F(GmGetJoinedGroupsTest, GmGetJoinedGroupsTest002, TestSize.Level0)
1023 {
1024 const DeviceGroupManager *gm = GetGmInstance();
1025 ASSERT_NE(gm, nullptr);
1026 uint32_t returnNum = 0;
1027 int32_t ret = gm->getJoinedGroups(TEST_OS_ACCOUNT_ID, TEST_APP_ID, PEER_TO_PEER_GROUP, nullptr, &returnNum);
1028 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1029 }
1030
1031 HWTEST_F(GmGetJoinedGroupsTest, GmGetJoinedGroupsTest003, TestSize.Level0)
1032 {
1033 const DeviceGroupManager *gm = GetGmInstance();
1034 ASSERT_NE(gm, nullptr);
1035 char *returnData = nullptr;
1036 int32_t ret = gm->getJoinedGroups(TEST_OS_ACCOUNT_ID, nullptr, PEER_TO_PEER_GROUP, &returnData, nullptr);
1037 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1038 }
1039
1040 HWTEST_F(GmGetJoinedGroupsTest, GmGetJoinedGroupsTest004, TestSize.Level0)
1041 {
1042 const DeviceGroupManager *gm = GetGmInstance();
1043 ASSERT_NE(gm, nullptr);
1044 char *returnData = nullptr;
1045 uint32_t returnNum = 0;
1046 int32_t ret = gm->getJoinedGroups(TEST_OS_ACCOUNT_ID, TEST_APP_ID, PEER_TO_PEER_GROUP, &returnData, &returnNum);
1047 ASSERT_EQ(ret, HC_SUCCESS);
1048 ASSERT_NE(returnData, nullptr);
1049 ASSERT_NE(returnNum, 0);
1050 gm->destroyInfo(&returnData);
1051 }
1052
1053 HWTEST_F(GmGetJoinedGroupsTest, GmGetJoinedGroupsTest005, TestSize.Level0)
1054 {
1055 const DeviceGroupManager *gm = GetGmInstance();
1056 ASSERT_NE(gm, nullptr);
1057 char *returnData = nullptr;
1058 uint32_t returnNum = 0;
1059 int32_t ret = gm->getJoinedGroups(TEST_OS_ACCOUNT_ID, TEST_APP_ID2, PEER_TO_PEER_GROUP, &returnData, &returnNum);
1060 ASSERT_EQ(ret, HC_SUCCESS);
1061 ASSERT_NE(returnData, nullptr);
1062 gm->destroyInfo(&returnData);
1063 }
1064
1065 HWTEST_F(GmGetJoinedGroupsTest, GmGetJoinedGroupsTest006, TestSize.Level0)
1066 {
1067 const DeviceGroupManager *gm = GetGmInstance();
1068 ASSERT_NE(gm, nullptr);
1069 char *returnData = nullptr;
1070 uint32_t returnNum = 0;
1071 int32_t ret = gm->getJoinedGroups(DEFAULT_OS_ACCOUNT, TEST_APP_ID2, PEER_TO_PEER_GROUP, &returnData, &returnNum);
1072 ASSERT_NE(ret, HC_SUCCESS);
1073 }
1074
1075 class GmGetRelatedGroupsTest : public testing::Test {
1076 public:
1077 static void SetUpTestCase();
1078 static void TearDownTestCase();
1079 void SetUp();
1080 void TearDown();
1081 };
1082
SetUpTestCase()1083 void GmGetRelatedGroupsTest::SetUpTestCase() {}
TearDownTestCase()1084 void GmGetRelatedGroupsTest::TearDownTestCase() {}
1085
SetUp()1086 void GmGetRelatedGroupsTest::SetUp()
1087 {
1088 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
1089 int ret = InitDeviceAuthService();
1090 EXPECT_EQ(ret, HC_SUCCESS);
1091 }
1092
TearDown()1093 void GmGetRelatedGroupsTest::TearDown()
1094 {
1095 DestroyDeviceAuthService();
1096 }
1097
1098 HWTEST_F(GmGetRelatedGroupsTest, GmGetRelatedGroupsTest001, TestSize.Level0)
1099 {
1100 const DeviceGroupManager *gm = GetGmInstance();
1101 ASSERT_NE(gm, nullptr);
1102 char *returnData = nullptr;
1103 uint32_t returnNum = 0;
1104 int32_t ret = gm->getRelatedGroups(TEST_OS_ACCOUNT_ID, nullptr, TEST_AUTH_ID, &returnData, &returnNum);
1105 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1106 }
1107
1108 HWTEST_F(GmGetRelatedGroupsTest, GmGetRelatedGroupsTest002, TestSize.Level0)
1109 {
1110 const DeviceGroupManager *gm = GetGmInstance();
1111 ASSERT_NE(gm, nullptr);
1112 char *returnData = nullptr;
1113 uint32_t returnNum = 0;
1114 int32_t ret = gm->getRelatedGroups(TEST_OS_ACCOUNT_ID, TEST_APP_ID, nullptr, &returnData, &returnNum);
1115 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1116 }
1117
1118 HWTEST_F(GmGetRelatedGroupsTest, GmGetRelatedGroupsTest003, TestSize.Level0)
1119 {
1120 const DeviceGroupManager *gm = GetGmInstance();
1121 ASSERT_NE(gm, nullptr);
1122 uint32_t returnNum = 0;
1123 int32_t ret = gm->getRelatedGroups(TEST_OS_ACCOUNT_ID, TEST_APP_ID, TEST_AUTH_ID, nullptr, &returnNum);
1124 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1125 }
1126
1127 HWTEST_F(GmGetRelatedGroupsTest, GmGetRelatedGroupsTest004, TestSize.Level0)
1128 {
1129 const DeviceGroupManager *gm = GetGmInstance();
1130 ASSERT_NE(gm, nullptr);
1131 char *returnData = nullptr;
1132 int32_t ret = gm->getRelatedGroups(TEST_OS_ACCOUNT_ID, TEST_APP_ID, TEST_AUTH_ID, &returnData, nullptr);
1133 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1134 }
1135
1136 HWTEST_F(GmGetRelatedGroupsTest, GmGetRelatedGroupsTest005, TestSize.Level0)
1137 {
1138 const DeviceGroupManager *gm = GetGmInstance();
1139 ASSERT_NE(gm, nullptr);
1140 char *returnData = nullptr;
1141 uint32_t returnNum = 0;
1142 int32_t ret = gm->getRelatedGroups(TEST_OS_ACCOUNT_ID, TEST_APP_ID, TEST_AUTH_ID, &returnData, &returnNum);
1143 ASSERT_EQ(ret, HC_SUCCESS);
1144 ASSERT_NE(returnData, nullptr);
1145 ASSERT_NE(returnNum, 0);
1146 gm->destroyInfo(&returnData);
1147 }
1148
1149 HWTEST_F(GmGetRelatedGroupsTest, GmGetRelatedGroupsTest006, TestSize.Level0)
1150 {
1151 const DeviceGroupManager *gm = GetGmInstance();
1152 ASSERT_NE(gm, nullptr);
1153 char *returnData = nullptr;
1154 uint32_t returnNum = 0;
1155 int32_t ret = gm->getRelatedGroups(TEST_OS_ACCOUNT_ID, TEST_APP_ID, TEST_AUTH_ID2, &returnData, &returnNum);
1156 ASSERT_EQ(ret, HC_SUCCESS);
1157 ASSERT_NE(returnData, nullptr);
1158 gm->destroyInfo(&returnData);
1159 }
1160
1161 HWTEST_F(GmGetRelatedGroupsTest, GmGetRelatedGroupsTest007, TestSize.Level0)
1162 {
1163 const DeviceGroupManager *gm = GetGmInstance();
1164 ASSERT_NE(gm, nullptr);
1165 char *returnData = nullptr;
1166 uint32_t returnNum = 0;
1167 int32_t ret = gm->getRelatedGroups(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_AUTH_ID2, &returnData, &returnNum);
1168 ASSERT_NE(ret, HC_SUCCESS);
1169 }
1170
1171 class GmGetDeviceInfoByIdTest : public testing::Test {
1172 public:
1173 static void SetUpTestCase();
1174 static void TearDownTestCase();
1175 void SetUp();
1176 void TearDown();
1177 };
1178
SetUpTestCase()1179 void GmGetDeviceInfoByIdTest::SetUpTestCase() {}
TearDownTestCase()1180 void GmGetDeviceInfoByIdTest::TearDownTestCase() {}
1181
SetUp()1182 void GmGetDeviceInfoByIdTest::SetUp()
1183 {
1184 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
1185 int ret = InitDeviceAuthService();
1186 EXPECT_EQ(ret, HC_SUCCESS);
1187 }
1188
TearDown()1189 void GmGetDeviceInfoByIdTest::TearDown()
1190 {
1191 DestroyDeviceAuthService();
1192 }
1193
1194 HWTEST_F(GmGetDeviceInfoByIdTest, GmGetDeviceInfoByIdTest001, TestSize.Level0)
1195 {
1196 const DeviceGroupManager *gm = GetGmInstance();
1197 ASSERT_NE(gm, nullptr);
1198 char *returnData = nullptr;
1199 int32_t ret = gm->getDeviceInfoById(TEST_OS_ACCOUNT_ID, nullptr, TEST_AUTH_ID, TEST_GROUP_ID, &returnData);
1200 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1201 }
1202
1203 HWTEST_F(GmGetDeviceInfoByIdTest, GmGetDeviceInfoByIdTest002, TestSize.Level0)
1204 {
1205 const DeviceGroupManager *gm = GetGmInstance();
1206 ASSERT_NE(gm, nullptr);
1207 char *returnData = nullptr;
1208 int32_t ret = gm->getDeviceInfoById(TEST_OS_ACCOUNT_ID, TEST_APP_ID, nullptr, TEST_GROUP_ID, &returnData);
1209 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1210 }
1211
1212 HWTEST_F(GmGetDeviceInfoByIdTest, GmGetDeviceInfoByIdTest003, TestSize.Level0)
1213 {
1214 const DeviceGroupManager *gm = GetGmInstance();
1215 ASSERT_NE(gm, nullptr);
1216 char *returnData = nullptr;
1217 int32_t ret = gm->getDeviceInfoById(TEST_OS_ACCOUNT_ID, TEST_APP_ID, TEST_AUTH_ID, nullptr, &returnData);
1218 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1219 }
1220
1221 HWTEST_F(GmGetDeviceInfoByIdTest, GmGetDeviceInfoByIdTest004, TestSize.Level0)
1222 {
1223 const DeviceGroupManager *gm = GetGmInstance();
1224 ASSERT_NE(gm, nullptr);
1225 int32_t ret = gm->getDeviceInfoById(TEST_OS_ACCOUNT_ID, TEST_APP_ID, TEST_AUTH_ID, TEST_GROUP_ID, nullptr);
1226 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1227 }
1228
1229 HWTEST_F(GmGetDeviceInfoByIdTest, GmGetDeviceInfoByIdTest005, TestSize.Level0)
1230 {
1231 const DeviceGroupManager *gm = GetGmInstance();
1232 ASSERT_NE(gm, nullptr);
1233 char *returnData = nullptr;
1234 int32_t ret = gm->getDeviceInfoById(TEST_OS_ACCOUNT_ID, TEST_APP_ID, TEST_AUTH_ID, TEST_GROUP_ID, &returnData);
1235 ASSERT_EQ(ret, HC_SUCCESS);
1236 ASSERT_NE(returnData, nullptr);
1237 gm->destroyInfo(&returnData);
1238 }
1239
1240 HWTEST_F(GmGetDeviceInfoByIdTest, GmGetDeviceInfoByIdTest006, TestSize.Level0)
1241 {
1242 const DeviceGroupManager *gm = GetGmInstance();
1243 ASSERT_NE(gm, nullptr);
1244 char *returnData = nullptr;
1245 int32_t ret = gm->getDeviceInfoById(TEST_OS_ACCOUNT_ID, TEST_APP_ID2, TEST_AUTH_ID, TEST_GROUP_ID2, &returnData);
1246 ASSERT_NE(ret, HC_SUCCESS);
1247 }
1248
1249 HWTEST_F(GmGetDeviceInfoByIdTest, GmGetDeviceInfoByIdTest007, TestSize.Level0)
1250 {
1251 const DeviceGroupManager *gm = GetGmInstance();
1252 ASSERT_NE(gm, nullptr);
1253 char *returnData = nullptr;
1254 int32_t ret = gm->getDeviceInfoById(TEST_OS_ACCOUNT_ID, TEST_APP_ID, TEST_AUTH_ID, TEST_GROUP_ID3, &returnData);
1255 ASSERT_NE(ret, HC_SUCCESS);
1256 }
1257
1258 HWTEST_F(GmGetDeviceInfoByIdTest, GmGetDeviceInfoByIdTest008, TestSize.Level0)
1259 {
1260 const DeviceGroupManager *gm = GetGmInstance();
1261 ASSERT_NE(gm, nullptr);
1262 char *returnData = nullptr;
1263 int32_t ret = gm->getDeviceInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_AUTH_ID, TEST_GROUP_ID3, &returnData);
1264 ASSERT_NE(ret, HC_SUCCESS);
1265 }
1266
1267 class GmGetTrustedDevicesTest : public testing::Test {
1268 public:
1269 static void SetUpTestCase();
1270 static void TearDownTestCase();
1271 void SetUp();
1272 void TearDown();
1273 };
1274
SetUpTestCase()1275 void GmGetTrustedDevicesTest::SetUpTestCase() {}
TearDownTestCase()1276 void GmGetTrustedDevicesTest::TearDownTestCase() {}
1277
SetUp()1278 void GmGetTrustedDevicesTest::SetUp()
1279 {
1280 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
1281 int ret = InitDeviceAuthService();
1282 EXPECT_EQ(ret, HC_SUCCESS);
1283 }
1284
TearDown()1285 void GmGetTrustedDevicesTest::TearDown()
1286 {
1287 DestroyDeviceAuthService();
1288 }
1289
1290 HWTEST_F(GmGetTrustedDevicesTest, GmGetTrustedDevicesTest001, TestSize.Level0)
1291 {
1292 const DeviceGroupManager *gm = GetGmInstance();
1293 ASSERT_NE(gm, nullptr);
1294 char *returnData = nullptr;
1295 uint32_t returnNum = 0;
1296 int32_t ret = gm->getTrustedDevices(TEST_OS_ACCOUNT_ID, nullptr, TEST_GROUP_ID, &returnData, &returnNum);
1297 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1298 }
1299
1300 HWTEST_F(GmGetTrustedDevicesTest, GmGetTrustedDevicesTest002, TestSize.Level0)
1301 {
1302 const DeviceGroupManager *gm = GetGmInstance();
1303 ASSERT_NE(gm, nullptr);
1304 char *returnData = nullptr;
1305 uint32_t returnNum = 0;
1306 int32_t ret = gm->getTrustedDevices(TEST_OS_ACCOUNT_ID, TEST_APP_ID, nullptr, &returnData, &returnNum);
1307 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1308 }
1309
1310 HWTEST_F(GmGetTrustedDevicesTest, GmGetTrustedDevicesTest003, TestSize.Level0)
1311 {
1312 const DeviceGroupManager *gm = GetGmInstance();
1313 ASSERT_NE(gm, nullptr);
1314 uint32_t returnNum = 0;
1315 int32_t ret = gm->getTrustedDevices(TEST_OS_ACCOUNT_ID, TEST_APP_ID, TEST_GROUP_ID, nullptr, &returnNum);
1316 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1317 }
1318
1319 HWTEST_F(GmGetTrustedDevicesTest, GmGetTrustedDevicesTest004, TestSize.Level0)
1320 {
1321 const DeviceGroupManager *gm = GetGmInstance();
1322 ASSERT_NE(gm, nullptr);
1323 char *returnData = nullptr;
1324 int32_t ret = gm->getTrustedDevices(TEST_OS_ACCOUNT_ID, TEST_APP_ID, TEST_GROUP_ID, &returnData, nullptr);
1325 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1326 }
1327
1328 HWTEST_F(GmGetTrustedDevicesTest, GmGetTrustedDevicesTest005, TestSize.Level0)
1329 {
1330 const DeviceGroupManager *gm = GetGmInstance();
1331 ASSERT_NE(gm, nullptr);
1332 char *returnData = nullptr;
1333 uint32_t returnNum = 0;
1334 int32_t ret = gm->getTrustedDevices(TEST_OS_ACCOUNT_ID, TEST_APP_ID, TEST_GROUP_ID, &returnData, &returnNum);
1335 ASSERT_EQ(ret, HC_SUCCESS);
1336 ASSERT_NE(returnData, nullptr);
1337 ASSERT_NE(returnNum, 0);
1338 gm->destroyInfo(&returnData);
1339 }
1340
1341 HWTEST_F(GmGetTrustedDevicesTest, GmGetTrustedDevicesTest006, TestSize.Level0)
1342 {
1343 const DeviceGroupManager *gm = GetGmInstance();
1344 ASSERT_NE(gm, nullptr);
1345 char *returnData = nullptr;
1346 uint32_t returnNum = 0;
1347 int32_t ret = gm->getTrustedDevices(TEST_OS_ACCOUNT_ID, TEST_APP_ID2, TEST_GROUP_ID2, &returnData, &returnNum);
1348 ASSERT_NE(ret, HC_SUCCESS);
1349 }
1350
1351 HWTEST_F(GmGetTrustedDevicesTest, GmGetTrustedDevicesTest007, TestSize.Level0)
1352 {
1353 const DeviceGroupManager *gm = GetGmInstance();
1354 ASSERT_NE(gm, nullptr);
1355 char *returnData = nullptr;
1356 uint32_t returnNum = 0;
1357 int32_t ret = gm->getTrustedDevices(TEST_OS_ACCOUNT_ID, TEST_APP_ID, TEST_GROUP_ID3, &returnData, &returnNum);
1358 ASSERT_NE(ret, HC_SUCCESS);
1359 }
1360
1361 HWTEST_F(GmGetTrustedDevicesTest, GmGetTrustedDevicesTest008, TestSize.Level0)
1362 {
1363 const DeviceGroupManager *gm = GetGmInstance();
1364 ASSERT_NE(gm, nullptr);
1365 char *returnData = nullptr;
1366 uint32_t returnNum = 0;
1367 int32_t ret = gm->getTrustedDevices(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID3, &returnData, &returnNum);
1368 ASSERT_NE(ret, HC_SUCCESS);
1369 }
1370
1371 class GmIsDeviceInGroupTest : public testing::Test {
1372 public:
1373 static void SetUpTestCase();
1374 static void TearDownTestCase();
1375 void SetUp();
1376 void TearDown();
1377 };
1378
SetUpTestCase()1379 void GmIsDeviceInGroupTest::SetUpTestCase() {}
TearDownTestCase()1380 void GmIsDeviceInGroupTest::TearDownTestCase() {}
1381
SetUp()1382 void GmIsDeviceInGroupTest::SetUp()
1383 {
1384 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
1385 int ret = InitDeviceAuthService();
1386 EXPECT_EQ(ret, HC_SUCCESS);
1387 }
1388
TearDown()1389 void GmIsDeviceInGroupTest::TearDown()
1390 {
1391 DestroyDeviceAuthService();
1392 }
1393
1394 HWTEST_F(GmIsDeviceInGroupTest, GmIsDeviceInGroupTest001, TestSize.Level0)
1395 {
1396 const DeviceGroupManager *gm = GetGmInstance();
1397 ASSERT_NE(gm, nullptr);
1398 bool ret = gm->isDeviceInGroup(TEST_OS_ACCOUNT_ID, nullptr, TEST_GROUP_ID, TEST_AUTH_ID);
1399 ASSERT_EQ(ret, false);
1400 }
1401
1402 HWTEST_F(GmIsDeviceInGroupTest, GmIsDeviceInGroupTest002, TestSize.Level0)
1403 {
1404 const DeviceGroupManager *gm = GetGmInstance();
1405 ASSERT_NE(gm, nullptr);
1406 bool ret = gm->isDeviceInGroup(TEST_OS_ACCOUNT_ID, TEST_APP_ID, nullptr, TEST_AUTH_ID);
1407 ASSERT_EQ(ret, false);
1408 }
1409
1410 HWTEST_F(GmIsDeviceInGroupTest, GmIsDeviceInGroupTest003, TestSize.Level0)
1411 {
1412 const DeviceGroupManager *gm = GetGmInstance();
1413 ASSERT_NE(gm, nullptr);
1414 bool ret = gm->isDeviceInGroup(TEST_OS_ACCOUNT_ID, TEST_APP_ID, TEST_GROUP_ID, nullptr);
1415 ASSERT_EQ(ret, false);
1416 }
1417
1418 HWTEST_F(GmIsDeviceInGroupTest, GmIsDeviceInGroupTest004, TestSize.Level0)
1419 {
1420 const DeviceGroupManager *gm = GetGmInstance();
1421 ASSERT_NE(gm, nullptr);
1422 bool ret = gm->isDeviceInGroup(TEST_OS_ACCOUNT_ID, TEST_APP_ID, TEST_GROUP_ID, TEST_AUTH_ID);
1423 ASSERT_EQ(ret, true);
1424 }
1425
1426 HWTEST_F(GmIsDeviceInGroupTest, GmIsDeviceInGroupTest005, TestSize.Level0)
1427 {
1428 const DeviceGroupManager *gm = GetGmInstance();
1429 ASSERT_NE(gm, nullptr);
1430 bool ret = gm->isDeviceInGroup(TEST_OS_ACCOUNT_ID, TEST_APP_ID2, TEST_GROUP_ID2, TEST_AUTH_ID);
1431 ASSERT_NE(ret, true);
1432 }
1433
1434 HWTEST_F(GmIsDeviceInGroupTest, GmIsDeviceInGroupTest006, TestSize.Level0)
1435 {
1436 const DeviceGroupManager *gm = GetGmInstance();
1437 ASSERT_NE(gm, nullptr);
1438 bool ret = gm->isDeviceInGroup(TEST_OS_ACCOUNT_ID, TEST_APP_ID, TEST_GROUP_ID3, TEST_AUTH_ID);
1439 ASSERT_EQ(ret, false);
1440 }
1441
1442 HWTEST_F(GmIsDeviceInGroupTest, GmIsDeviceInGroupTest007, TestSize.Level0)
1443 {
1444 const DeviceGroupManager *gm = GetGmInstance();
1445 ASSERT_NE(gm, nullptr);
1446 bool ret = gm->isDeviceInGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID3, TEST_AUTH_ID);
1447 ASSERT_EQ(ret, false);
1448 }
1449
1450 class GmAddMemberToGroupTest : public testing::Test {
1451 public:
1452 static void SetUpTestCase();
1453 static void TearDownTestCase();
1454 void SetUp();
1455 void TearDown();
1456 };
1457
SetUpTestCase()1458 void GmAddMemberToGroupTest::SetUpTestCase()
1459 {
1460 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
1461 int ret = InitDeviceAuthService();
1462 ASSERT_EQ(ret, HC_SUCCESS);
1463 const DeviceGroupManager *gm = GetGmInstance();
1464 ASSERT_NE(gm, nullptr);
1465 ret = gm->unRegCallback(TEST_APP_ID);
1466 ASSERT_EQ(ret, HC_SUCCESS);
1467 }
1468
TearDownTestCase()1469 void GmAddMemberToGroupTest::TearDownTestCase()
1470 {
1471 DestroyDeviceAuthService();
1472 }
1473
SetUp()1474 void GmAddMemberToGroupTest::SetUp() {}
TearDown()1475 void GmAddMemberToGroupTest::TearDown() {}
1476
1477 HWTEST_F(GmAddMemberToGroupTest, GmAddMemberToGroupTest001, TestSize.Level0)
1478 {
1479 const DeviceGroupManager *gm = GetGmInstance();
1480 ASSERT_NE(gm, nullptr);
1481 int32_t ret = gm->addMemberToGroup(TEST_OS_ACCOUNT_ID, TEST_REQ_ID, nullptr, TEST_QUERY_PARAMS);
1482 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1483 }
1484
1485 HWTEST_F(GmAddMemberToGroupTest, GmAddMemberToGroupTest002, TestSize.Level0)
1486 {
1487 const DeviceGroupManager *gm = GetGmInstance();
1488 ASSERT_NE(gm, nullptr);
1489 int32_t ret = gm->addMemberToGroup(TEST_OS_ACCOUNT_ID, TEST_REQ_ID, TEST_APP_ID, nullptr);
1490 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1491 }
1492
1493 HWTEST_F(GmAddMemberToGroupTest, GmAddMemberToGroupTest003, TestSize.Level0)
1494 {
1495 const DeviceGroupManager *gm = GetGmInstance();
1496 ASSERT_NE(gm, nullptr);
1497 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1498 ASSERT_EQ(ret, HC_SUCCESS);
1499 ret = gm->addMemberToGroup(TEST_OS_ACCOUNT_ID, TEST_REQ_ID2, TEST_APP_ID, ADD_PARAMS);
1500 ASSERT_EQ(ret, HC_SUCCESS);
1501 }
1502
1503 HWTEST_F(GmAddMemberToGroupTest, GmAddMemberToGroupTest004, TestSize.Level0)
1504 {
1505 const DeviceGroupManager *gm = GetGmInstance();
1506 ASSERT_NE(gm, nullptr);
1507 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1508 ASSERT_EQ(ret, HC_SUCCESS);
1509 ret = gm->addMemberToGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID3, TEST_APP_ID, ADD_PARAMS);
1510 ASSERT_NE(ret, HC_SUCCESS);
1511 }
1512
1513 HWTEST_F(GmAddMemberToGroupTest, GmAddMemberToGroupTest005, TestSize.Level0)
1514 {
1515 const DeviceGroupManager *gm = GetGmInstance();
1516 ASSERT_NE(gm, nullptr);
1517 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1518 ASSERT_EQ(ret, HC_SUCCESS);
1519 ret = gm->addMemberToGroup(TEST_OS_ACCOUNT_ID, TEST_REQ_ID5, TEST_APP_ID, TEST_ADD_PARAMS3);
1520 ASSERT_EQ(ret, HC_SUCCESS);
1521 }
1522
1523 class GmDeleteMemberFromGroupTest : public testing::Test {
1524 public:
1525 static void SetUpTestCase();
1526 static void TearDownTestCase();
1527 void SetUp();
1528 void TearDown();
1529 };
1530
SetUpTestCase()1531 void GmDeleteMemberFromGroupTest::SetUpTestCase()
1532 {
1533 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
1534 int ret = InitDeviceAuthService();
1535 ASSERT_EQ(ret, HC_SUCCESS);
1536 const DeviceGroupManager *gm = GetGmInstance();
1537 ASSERT_NE(gm, nullptr);
1538 ret = gm->unRegCallback(TEST_APP_ID);
1539 ASSERT_EQ(ret, HC_SUCCESS);
1540 }
1541
TearDownTestCase()1542 void GmDeleteMemberFromGroupTest::TearDownTestCase()
1543 {
1544 DestroyDeviceAuthService();
1545 }
1546
SetUp()1547 void GmDeleteMemberFromGroupTest::SetUp() {}
TearDown()1548 void GmDeleteMemberFromGroupTest::TearDown() {}
1549
1550 HWTEST_F(GmDeleteMemberFromGroupTest, GmDeleteMemberFromGroupTest001, TestSize.Level0)
1551 {
1552 const DeviceGroupManager *gm = GetGmInstance();
1553 ASSERT_NE(gm, nullptr);
1554 int32_t ret = gm->deleteMemberFromGroup(TEST_OS_ACCOUNT_ID, TEST_REQ_ID, nullptr, TEST_QUERY_PARAMS);
1555 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1556 }
1557
1558 HWTEST_F(GmDeleteMemberFromGroupTest, GmDeleteMemberFromGroupTest002, TestSize.Level0)
1559 {
1560 const DeviceGroupManager *gm = GetGmInstance();
1561 ASSERT_NE(gm, nullptr);
1562 int32_t ret = gm->deleteMemberFromGroup(TEST_OS_ACCOUNT_ID, TEST_REQ_ID, TEST_APP_ID, nullptr);
1563 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1564 }
1565
1566 HWTEST_F(GmDeleteMemberFromGroupTest, GmDeleteMemberFromGroupTest003, TestSize.Level0)
1567 {
1568 const DeviceGroupManager *gm = GetGmInstance();
1569 ASSERT_NE(gm, nullptr);
1570 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1571 ASSERT_EQ(ret, HC_SUCCESS);
1572 ret = gm->deleteMemberFromGroup(TEST_OS_ACCOUNT_ID, TEST_REQ_ID3, TEST_APP_ID, DELETE_PARAMS);
1573 ASSERT_EQ(ret, HC_SUCCESS);
1574 }
1575
1576 HWTEST_F(GmDeleteMemberFromGroupTest, GmDeleteMemberFromGroupTest004, TestSize.Level0)
1577 {
1578 const DeviceGroupManager *gm = GetGmInstance();
1579 ASSERT_NE(gm, nullptr);
1580 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1581 ASSERT_EQ(ret, HC_SUCCESS);
1582 ret = gm->deleteMemberFromGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID4, TEST_APP_ID, DELETE_PARAMS);
1583 ASSERT_NE(ret, HC_SUCCESS);
1584 }
1585
1586 class GmProcessDataTest : public testing::Test {
1587 public:
1588 static void SetUpTestCase();
1589 static void TearDownTestCase();
1590 void SetUp();
1591 void TearDown();
1592 };
1593
SetUpTestCase()1594 void GmProcessDataTest::SetUpTestCase()
1595 {
1596 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
1597 int ret = InitDeviceAuthService();
1598 ASSERT_EQ(ret, HC_SUCCESS);
1599 const DeviceGroupManager *gm = GetGmInstance();
1600 ASSERT_NE(gm, nullptr);
1601 ret = gm->unRegCallback(TEST_APP_ID);
1602 ASSERT_EQ(ret, HC_SUCCESS);
1603 }
1604
TearDownTestCase()1605 void GmProcessDataTest::TearDownTestCase()
1606 {
1607 DestroyDeviceAuthService();
1608 }
1609
SetUp()1610 void GmProcessDataTest::SetUp() {}
TearDown()1611 void GmProcessDataTest::TearDown() {}
1612
1613 HWTEST_F(GmProcessDataTest, GmProcessDataTest001, TestSize.Level0)
1614 {
1615 const DeviceGroupManager *gm = GetGmInstance();
1616 ASSERT_NE(gm, nullptr);
1617 int32_t ret = gm->processData(TEST_REQ_ID, nullptr, 0);
1618 ASSERT_NE(ret, HC_SUCCESS);
1619 }
1620
1621 HWTEST_F(GmProcessDataTest, GmProcessDataTest002, TestSize.Level0)
1622 {
1623 const DeviceGroupManager *gm = GetGmInstance();
1624 ASSERT_NE(gm, nullptr);
1625 int32_t ret = gm->processData(TEST_REQ_ID, (const uint8_t *)PROCESS_DATA, 0);
1626 ASSERT_NE(ret, HC_SUCCESS);
1627 }
1628
1629 HWTEST_F(GmProcessDataTest, GmProcessDataTest003, TestSize.Level0)
1630 {
1631 const DeviceGroupManager *gm = GetGmInstance();
1632 ASSERT_NE(gm, nullptr);
1633 int32_t ret = gm->processData(TEST_REQ_ID, (const uint8_t *)PROCESS_DATA, 4097);
1634 ASSERT_NE(ret, HC_SUCCESS);
1635 }
1636
1637 HWTEST_F(GmProcessDataTest, GmProcessDataTest004, TestSize.Level0)
1638 {
1639 const DeviceGroupManager *gm = GetGmInstance();
1640 ASSERT_NE(gm, nullptr);
1641 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1642 ASSERT_EQ(ret, HC_SUCCESS);
1643 ret = gm->processData(TEST_REQ_ID, (const uint8_t *)PROCESS_DATA, strlen(PROCESS_DATA) + 1);
1644 ASSERT_NE(ret, HC_SUCCESS);
1645 }
1646
1647 HWTEST_F(GmProcessDataTest, GmProcessDataTest005, TestSize.Level0)
1648 {
1649 const DeviceGroupManager *gm = GetGmInstance();
1650 ASSERT_NE(gm, nullptr);
1651 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback2);
1652 ASSERT_EQ(ret, HC_SUCCESS);
1653 ret = gm->processData(TEST_REQ_ID, (const uint8_t *)PROCESS_DATA2, strlen(PROCESS_DATA2) + 1);
1654 ASSERT_NE(ret, HC_SUCCESS);
1655 }
1656
1657 class GmAddMultiMembersToGroupTest : public testing::Test {
1658 public:
1659 static void SetUpTestCase();
1660 static void TearDownTestCase();
1661 void SetUp();
1662 void TearDown();
1663 };
1664
SetUpTestCase()1665 void GmAddMultiMembersToGroupTest::SetUpTestCase() {}
TearDownTestCase()1666 void GmAddMultiMembersToGroupTest::TearDownTestCase() {}
1667
SetUp()1668 void GmAddMultiMembersToGroupTest::SetUp()
1669 {
1670 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
1671 int ret = InitDeviceAuthService();
1672 ASSERT_EQ(ret, HC_SUCCESS);
1673 const DeviceGroupManager *gm = GetGmInstance();
1674 ASSERT_NE(gm, nullptr);
1675 ret = gm->unRegCallback(TEST_APP_ID);
1676 ASSERT_EQ(ret, HC_SUCCESS);
1677 }
1678
TearDown()1679 void GmAddMultiMembersToGroupTest::TearDown()
1680 {
1681 DestroyDeviceAuthService();
1682 }
1683
1684 HWTEST_F(GmAddMultiMembersToGroupTest, GmAddMultiMembersToGroupTest001, TestSize.Level0)
1685 {
1686 const DeviceGroupManager *gm = GetGmInstance();
1687 ASSERT_NE(gm, nullptr);
1688 int32_t ret = gm->addMultiMembersToGroup(TEST_OS_ACCOUNT_ID, nullptr, TEST_QUERY_PARAMS);
1689 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1690 }
1691
1692 HWTEST_F(GmAddMultiMembersToGroupTest, GmAddMultiMembersToGroupTest002, TestSize.Level0)
1693 {
1694 const DeviceGroupManager *gm = GetGmInstance();
1695 ASSERT_NE(gm, nullptr);
1696 int32_t ret = gm->addMultiMembersToGroup(TEST_OS_ACCOUNT_ID, TEST_APP_ID, nullptr);
1697 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1698 }
1699
1700 HWTEST_F(GmAddMultiMembersToGroupTest, GmAddMultiMembersToGroupTest003, TestSize.Level0)
1701 {
1702 const DeviceGroupManager *gm = GetGmInstance();
1703 ASSERT_NE(gm, nullptr);
1704 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1705 ASSERT_EQ(ret, HC_SUCCESS);
1706 ret = gm->addMultiMembersToGroup(TEST_OS_ACCOUNT_ID, TEST_APP_ID, ADD_PARAMS2);
1707 ASSERT_NE(ret, HC_SUCCESS);
1708 }
1709
1710 HWTEST_F(GmAddMultiMembersToGroupTest, GmAddMultiMembersToGroupTest004, TestSize.Level0)
1711 {
1712 const DeviceGroupManager *gm = GetGmInstance();
1713 ASSERT_NE(gm, nullptr);
1714 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1715 ASSERT_EQ(ret, HC_SUCCESS);
1716 ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, ADD_PARAMS2);
1717 ASSERT_NE(ret, HC_SUCCESS);
1718 }
1719
1720 class GmDelMultiMembersFromGroupTest : public testing::Test {
1721 public:
1722 static void SetUpTestCase();
1723 static void TearDownTestCase();
1724 void SetUp();
1725 void TearDown();
1726 };
1727
SetUpTestCase()1728 void GmDelMultiMembersFromGroupTest::SetUpTestCase() {}
TearDownTestCase()1729 void GmDelMultiMembersFromGroupTest::TearDownTestCase() {}
1730
SetUp()1731 void GmDelMultiMembersFromGroupTest::SetUp()
1732 {
1733 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
1734 int ret = InitDeviceAuthService();
1735 ASSERT_EQ(ret, HC_SUCCESS);
1736 const DeviceGroupManager *gm = GetGmInstance();
1737 ASSERT_NE(gm, nullptr);
1738 ret = gm->unRegCallback(TEST_APP_ID);
1739 ASSERT_EQ(ret, HC_SUCCESS);
1740 }
1741
TearDown()1742 void GmDelMultiMembersFromGroupTest::TearDown()
1743 {
1744 DestroyDeviceAuthService();
1745 }
1746
1747 HWTEST_F(GmDelMultiMembersFromGroupTest, GmDelMultiMembersFromGroupTest001, TestSize.Level0)
1748 {
1749 const DeviceGroupManager *gm = GetGmInstance();
1750 ASSERT_NE(gm, nullptr);
1751 int32_t ret = gm->delMultiMembersFromGroup(TEST_OS_ACCOUNT_ID, nullptr, TEST_QUERY_PARAMS);
1752 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1753 }
1754
1755 HWTEST_F(GmDelMultiMembersFromGroupTest, GmDelMultiMembersFromGroupTest002, TestSize.Level0)
1756 {
1757 const DeviceGroupManager *gm = GetGmInstance();
1758 ASSERT_NE(gm, nullptr);
1759 int32_t ret = gm->delMultiMembersFromGroup(TEST_OS_ACCOUNT_ID, TEST_APP_ID, nullptr);
1760 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1761 }
1762
1763 HWTEST_F(GmDelMultiMembersFromGroupTest, GmDelMultiMembersFromGroupTest003, TestSize.Level0)
1764 {
1765 const DeviceGroupManager *gm = GetGmInstance();
1766 ASSERT_NE(gm, nullptr);
1767 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1768 ASSERT_EQ(ret, HC_SUCCESS);
1769 ret = gm->delMultiMembersFromGroup(TEST_OS_ACCOUNT_ID, TEST_APP_ID, DELETE_PARAMS2);
1770 ASSERT_NE(ret, HC_SUCCESS);
1771 }
1772
1773 HWTEST_F(GmDelMultiMembersFromGroupTest, GmDelMultiMembersFromGroupTest004, TestSize.Level0)
1774 {
1775 const DeviceGroupManager *gm = GetGmInstance();
1776 ASSERT_NE(gm, nullptr);
1777 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1778 ASSERT_EQ(ret, HC_SUCCESS);
1779 ret = gm->delMultiMembersFromGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, DELETE_PARAMS2);
1780 ASSERT_NE(ret, HC_SUCCESS);
1781 }
1782
1783 class GmGetRegisterInfoTest : public testing::Test {
1784 public:
1785 static void SetUpTestCase();
1786 static void TearDownTestCase();
1787 void SetUp();
1788 void TearDown();
1789 };
1790
SetUpTestCase()1791 void GmGetRegisterInfoTest::SetUpTestCase() {}
TearDownTestCase()1792 void GmGetRegisterInfoTest::TearDownTestCase() {}
1793
SetUp()1794 void GmGetRegisterInfoTest::SetUp()
1795 {
1796 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
1797 int ret = InitDeviceAuthService();
1798 EXPECT_EQ(ret, HC_SUCCESS);
1799 }
1800
TearDown()1801 void GmGetRegisterInfoTest::TearDown()
1802 {
1803 DestroyDeviceAuthService();
1804 }
1805
1806 HWTEST_F(GmGetRegisterInfoTest, GmGetRegisterInfoTest001, TestSize.Level0)
1807 {
1808 const DeviceGroupManager *gm = GetGmInstance();
1809 ASSERT_NE(gm, nullptr);
1810 char *returnData = nullptr;
1811 int32_t ret = gm->getRegisterInfo(nullptr, &returnData);
1812 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1813 }
1814
1815 HWTEST_F(GmGetRegisterInfoTest, GmGetRegisterInfoTest002, TestSize.Level0)
1816 {
1817 const DeviceGroupManager *gm = GetGmInstance();
1818 ASSERT_NE(gm, nullptr);
1819 int32_t ret = gm->getRegisterInfo(TEST_QUERY_PARAMS, nullptr);
1820 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1821 }
1822
1823 HWTEST_F(GmGetRegisterInfoTest, GmGetRegisterInfoTest003, TestSize.Level0)
1824 {
1825 const DeviceGroupManager *gm = GetGmInstance();
1826 ASSERT_NE(gm, nullptr);
1827 char *returnData = nullptr;
1828 int32_t ret = gm->getRegisterInfo(GET_REG_INFO_PARAMS, &returnData);
1829 ASSERT_EQ(ret, HC_SUCCESS);
1830 ASSERT_NE(returnData, nullptr);
1831 gm->destroyInfo(&returnData);
1832 }
1833
1834 class GaAuthDeviceTest : public testing::Test {
1835 public:
1836 static void SetUpTestCase();
1837 static void TearDownTestCase();
1838 void SetUp();
1839 void TearDown();
1840 };
1841
SetUpTestCase()1842 void GaAuthDeviceTest::SetUpTestCase()
1843 {
1844 NativeTokenSet(PROC_NAME_SOFT_BUS);
1845 int ret = InitDeviceAuthService();
1846 ASSERT_EQ(ret, HC_SUCCESS);
1847 }
1848
TearDownTestCase()1849 void GaAuthDeviceTest::TearDownTestCase()
1850 {
1851 DestroyDeviceAuthService();
1852 }
1853
SetUp()1854 void GaAuthDeviceTest::SetUp() {}
TearDown()1855 void GaAuthDeviceTest::TearDown() {}
1856
1857 HWTEST_F(GaAuthDeviceTest, GaAuthDeviceTest001, TestSize.Level0)
1858 {
1859 const GroupAuthManager *ga = GetGaInstance();
1860 ASSERT_NE(ga, nullptr);
1861 int32_t ret = ga->authDevice(TEST_OS_ACCOUNT_ID, TEST_REQ_ID, nullptr, &g_gmCallback);
1862 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1863 }
1864
1865 HWTEST_F(GaAuthDeviceTest, GaAuthDeviceTest002, TestSize.Level0)
1866 {
1867 const GroupAuthManager *ga = GetGaInstance();
1868 ASSERT_NE(ga, nullptr);
1869 int32_t ret = ga->authDevice(TEST_OS_ACCOUNT_ID, TEST_REQ_ID, AUTH_PARAMS, nullptr);
1870 ASSERT_NE(ret, HC_SUCCESS);
1871 }
1872
1873 HWTEST_F(GaAuthDeviceTest, GaAuthDeviceTest003, TestSize.Level0)
1874 {
1875 const GroupAuthManager *ga = GetGaInstance();
1876 ASSERT_NE(ga, nullptr);
1877 int32_t ret = ga->authDevice(TEST_OS_ACCOUNT_ID, TEST_REQ_ID4, AUTH_PARAMS, &g_gaCallback);
1878 ASSERT_EQ(ret, HC_SUCCESS);
1879 }
1880
1881 HWTEST_F(GaAuthDeviceTest, GaAuthDeviceTest004, TestSize.Level0)
1882 {
1883 const GroupAuthManager *ga = GetGaInstance();
1884 ASSERT_NE(ga, nullptr);
1885 int32_t ret = ga->authDevice(DEFAULT_OS_ACCOUNT, TEST_REQ_ID2, AUTH_PARAMS, &g_gaCallback);
1886 ASSERT_NE(ret, HC_SUCCESS);
1887 }
1888
1889 class GaProcessDataTest : public testing::Test {
1890 public:
1891 static void SetUpTestCase();
1892 static void TearDownTestCase();
1893 void SetUp();
1894 void TearDown();
1895 };
1896
SetUpTestCase()1897 void GaProcessDataTest::SetUpTestCase()
1898 {
1899 NativeTokenSet(PROC_NAME_SOFT_BUS);
1900 int ret = InitDeviceAuthService();
1901 ASSERT_EQ(ret, HC_SUCCESS);
1902 }
1903
TearDownTestCase()1904 void GaProcessDataTest::TearDownTestCase()
1905 {
1906 DestroyDeviceAuthService();
1907 }
1908
SetUp()1909 void GaProcessDataTest::SetUp() {}
TearDown()1910 void GaProcessDataTest::TearDown() {}
1911
1912 HWTEST_F(GaProcessDataTest, GaProcessDataTest001, TestSize.Level0)
1913 {
1914 const GroupAuthManager *ga = GetGaInstance();
1915 ASSERT_NE(ga, nullptr);
1916 int32_t ret = ga->processData(TEST_REQ_ID, nullptr, 0, &g_gaCallback);
1917 ASSERT_NE(ret, HC_SUCCESS);
1918 }
1919
1920 HWTEST_F(GaProcessDataTest, GaProcessDataTest002, TestSize.Level0)
1921 {
1922 const GroupAuthManager *ga = GetGaInstance();
1923 ASSERT_NE(ga, nullptr);
1924 int32_t ret = ga->processData(TEST_REQ_ID, (const uint8_t *)PROCESS_DATA, 0, &g_gaCallback);
1925 ASSERT_NE(ret, HC_SUCCESS);
1926 }
1927
1928 HWTEST_F(GaProcessDataTest, GaProcessDataTest003, TestSize.Level0)
1929 {
1930 const GroupAuthManager *ga = GetGaInstance();
1931 ASSERT_NE(ga, nullptr);
1932 int32_t ret = ga->processData(TEST_REQ_ID, (const uint8_t *)PROCESS_DATA, 4097, &g_gaCallback);
1933 ASSERT_NE(ret, HC_SUCCESS);
1934 }
1935
1936 HWTEST_F(GaProcessDataTest, GaProcessDataTest004, TestSize.Level0)
1937 {
1938 const GroupAuthManager *ga = GetGaInstance();
1939 ASSERT_NE(ga, nullptr);
1940 int32_t ret = ga->processData(TEST_REQ_ID, (const uint8_t *)PROCESS_DATA, strlen(PROCESS_DATA) + 1, nullptr);
1941 ASSERT_NE(ret, HC_SUCCESS);
1942 }
1943
1944 HWTEST_F(GaProcessDataTest, GaProcessDataTest005, TestSize.Level0)
1945 {
1946 const GroupAuthManager *ga = GetGaInstance();
1947 ASSERT_NE(ga, nullptr);
1948 int32_t ret = ga->processData(TEST_REQ_ID, (const uint8_t *)PROCESS_DATA,
1949 strlen(PROCESS_DATA) + 1, &g_gaCallback);
1950 ASSERT_NE(ret, HC_SUCCESS);
1951 }
1952
1953 HWTEST_F(GaProcessDataTest, GaProcessDataTest006, TestSize.Level0)
1954 {
1955 const GroupAuthManager *ga = GetGaInstance();
1956 ASSERT_NE(ga, nullptr);
1957 int32_t ret = ga->processData(TEST_REQ_ID, (const uint8_t *)PROCESS_DATA,
1958 strlen(PROCESS_DATA) + 1, &g_gaCallback2);
1959 ASSERT_NE(ret, HC_SUCCESS);
1960 }
1961
1962 class GmDeleteGroupTest : public testing::Test {
1963 public:
1964 static void SetUpTestCase();
1965 static void TearDownTestCase();
1966 void SetUp();
1967 void TearDown();
1968 };
1969
SetUpTestCase()1970 void GmDeleteGroupTest::SetUpTestCase() {}
TearDownTestCase()1971 void GmDeleteGroupTest::TearDownTestCase() {}
1972
SetUp()1973 void GmDeleteGroupTest::SetUp()
1974 {
1975 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
1976 int ret = InitDeviceAuthService();
1977 ASSERT_EQ(ret, HC_SUCCESS);
1978 const DeviceGroupManager *gm = GetGmInstance();
1979 ASSERT_NE(gm, nullptr);
1980 ret = gm->unRegCallback(TEST_APP_ID);
1981 ASSERT_EQ(ret, HC_SUCCESS);
1982 }
1983
TearDown()1984 void GmDeleteGroupTest::TearDown()
1985 {
1986 DestroyDeviceAuthService();
1987 }
1988
1989 HWTEST_F(GmDeleteGroupTest, GmDeleteGroupTest001, TestSize.Level0)
1990 {
1991 const DeviceGroupManager *gm = GetGmInstance();
1992 ASSERT_NE(gm, nullptr);
1993 int32_t ret = gm->deleteGroup(TEST_OS_ACCOUNT_ID, TEST_REQ_ID, nullptr, DISBAND_PARAMS);
1994 ASSERT_NE(ret, HC_SUCCESS);
1995 }
1996
1997 HWTEST_F(GmDeleteGroupTest, GmDeleteGroupTest002, TestSize.Level0)
1998 {
1999 const DeviceGroupManager *gm = GetGmInstance();
2000 ASSERT_NE(gm, nullptr);
2001 int32_t ret = gm->deleteGroup(TEST_OS_ACCOUNT_ID, TEST_REQ_ID, TEST_APP_ID, nullptr);
2002 ASSERT_NE(ret, HC_SUCCESS);
2003 }
2004
2005 HWTEST_F(GmDeleteGroupTest, GmDeleteGroupTest003, TestSize.Level0)
2006 {
2007 const DeviceGroupManager *gm = GetGmInstance();
2008 ASSERT_NE(gm, nullptr);
2009 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
2010 ASSERT_EQ(ret, HC_SUCCESS);
2011 DeleteDemoGroup(TEST_OS_ACCOUNT_ID, TEST_REQ_ID, TEST_APP_ID, DISBAND_PARAMS);
2012 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2013 DeleteDemoGroup(TEST_OS_ACCOUNT_ID, TEST_REQ_ID, TEST_APP_ID, DISBAND_PARAMS2);
2014 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2015 }
2016
2017 HWTEST_F(GmDeleteGroupTest, GmDeleteGroupTest004, TestSize.Level0)
2018 {
2019 const DeviceGroupManager *gm = GetGmInstance();
2020 ASSERT_NE(gm, nullptr);
2021 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
2022 ASSERT_EQ(ret, HC_SUCCESS);
2023 DeleteDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, DISBAND_PARAMS);
2024 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_ERROR);
2025 }
2026
2027 class GmUnRegCallbackTest : public testing::Test {
2028 public:
2029 static void SetUpTestCase();
2030 static void TearDownTestCase();
2031 void SetUp();
2032 void TearDown();
2033 };
2034
SetUpTestCase()2035 void GmUnRegCallbackTest::SetUpTestCase() {}
TearDownTestCase()2036 void GmUnRegCallbackTest::TearDownTestCase() {}
2037
SetUp()2038 void GmUnRegCallbackTest::SetUp()
2039 {
2040 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
2041 int ret = InitDeviceAuthService();
2042 EXPECT_EQ(ret, HC_SUCCESS);
2043 }
2044
TearDown()2045 void GmUnRegCallbackTest::TearDown()
2046 {
2047 DestroyDeviceAuthService();
2048 }
2049
2050 HWTEST_F(GmUnRegCallbackTest, GmUnRegCallbackTest001, TestSize.Level0)
2051 {
2052 const DeviceGroupManager *gm = GetGmInstance();
2053 ASSERT_NE(gm, nullptr);
2054 DeviceAuthCallback callback;
2055 int32_t ret = gm->regCallback(TEST_APP_ID, &callback);
2056 ASSERT_EQ(ret, HC_SUCCESS);
2057 ret = gm->unRegCallback(TEST_APP_ID);
2058 ASSERT_EQ(ret, HC_SUCCESS);
2059 }
2060
2061 HWTEST_F(GmUnRegCallbackTest, GmUnRegCallbackTest002, TestSize.Level0)
2062 {
2063 const DeviceGroupManager *gm = GetGmInstance();
2064 ASSERT_NE(gm, nullptr);
2065 int32_t ret = gm->unRegCallback(TEST_APP_ID);
2066 ASSERT_EQ(ret, HC_SUCCESS);
2067 }
2068
2069 HWTEST_F(GmUnRegCallbackTest, GmUnRegCallbackTest003, TestSize.Level0)
2070 {
2071 const DeviceGroupManager *gm = GetGmInstance();
2072 ASSERT_NE(gm, nullptr);
2073 int32_t ret = gm->unRegCallback(nullptr);
2074 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
2075 }
2076
2077 class GmUnRegDataChangeListenerTest : public testing::Test {
2078 public:
2079 static void SetUpTestCase();
2080 static void TearDownTestCase();
2081 void SetUp();
2082 void TearDown();
2083 };
2084
SetUpTestCase()2085 void GmUnRegDataChangeListenerTest::SetUpTestCase() {}
TearDownTestCase()2086 void GmUnRegDataChangeListenerTest::TearDownTestCase() {}
2087
SetUp()2088 void GmUnRegDataChangeListenerTest::SetUp()
2089 {
2090 NativeTokenSet(PROC_NAME_SOFT_BUS);
2091 int ret = InitDeviceAuthService();
2092 EXPECT_EQ(ret, HC_SUCCESS);
2093 }
2094
TearDown()2095 void GmUnRegDataChangeListenerTest::TearDown()
2096 {
2097 DestroyDeviceAuthService();
2098 }
2099
2100 HWTEST_F(GmUnRegDataChangeListenerTest, GmUnRegDataChangeListenerTest001, TestSize.Level0)
2101 {
2102 const DeviceGroupManager *gm = GetGmInstance();
2103 ASSERT_NE(gm, nullptr);
2104 int32_t ret = gm->regDataChangeListener(TEST_APP_ID, &g_listener);
2105 ASSERT_EQ(ret, HC_SUCCESS);
2106 ret = gm->unRegDataChangeListener(TEST_APP_ID);
2107 ASSERT_EQ(ret, HC_SUCCESS);
2108 }
2109
2110 HWTEST_F(GmUnRegDataChangeListenerTest, GmUnRegDataChangeListenerTest002, TestSize.Level0)
2111 {
2112 const DeviceGroupManager *gm = GetGmInstance();
2113 ASSERT_NE(gm, nullptr);
2114 int32_t ret = gm->unRegDataChangeListener(TEST_APP_ID);
2115 ASSERT_EQ(ret, HC_SUCCESS);
2116 }
2117
2118 HWTEST_F(GmUnRegDataChangeListenerTest, GmUnRegDataChangeListenerTest003, TestSize.Level0)
2119 {
2120 const DeviceGroupManager *gm = GetGmInstance();
2121 ASSERT_NE(gm, nullptr);
2122 int32_t ret = gm->unRegDataChangeListener(nullptr);
2123 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
2124 }
2125
2126 class GmCancelRequestTest : public testing::Test {
2127 public:
2128 static void SetUpTestCase();
2129 static void TearDownTestCase();
2130 void SetUp();
2131 void TearDown();
2132 };
2133
SetUpTestCase()2134 void GmCancelRequestTest::SetUpTestCase()
2135 {
2136 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
2137 int ret = InitDeviceAuthService();
2138 EXPECT_EQ(ret, HC_SUCCESS);
2139 }
2140
TearDownTestCase()2141 void GmCancelRequestTest::TearDownTestCase()
2142 {
2143 DestroyDeviceAuthService();
2144 }
2145
SetUp()2146 void GmCancelRequestTest::SetUp() {}
TearDown()2147 void GmCancelRequestTest::TearDown() {}
2148
2149 HWTEST_F(GmCancelRequestTest, GmCancelRequestTest001, TestSize.Level0)
2150 {
2151 const DeviceGroupManager *gm = GetGmInstance();
2152 ASSERT_NE(gm, nullptr);
2153 gm->cancelRequest(TEST_REQ_ID, nullptr);
2154 }
2155
2156 HWTEST_F(GmCancelRequestTest, GmCancelRequestTest002, TestSize.Level0)
2157 {
2158 const DeviceGroupManager *gm = GetGmInstance();
2159 ASSERT_NE(gm, nullptr);
2160 gm->cancelRequest(TEST_REQ_ID, TEST_APP_ID);
2161 }
2162
2163 class GaCancelRequestTest : public testing::Test {
2164 public:
2165 static void SetUpTestCase();
2166 static void TearDownTestCase();
2167 void SetUp();
2168 void TearDown();
2169 };
2170
SetUpTestCase()2171 void GaCancelRequestTest::SetUpTestCase()
2172 {
2173 NativeTokenSet(PROC_NAME_SOFT_BUS);
2174 int ret = InitDeviceAuthService();
2175 EXPECT_EQ(ret, HC_SUCCESS);
2176 }
2177
TearDownTestCase()2178 void GaCancelRequestTest::TearDownTestCase()
2179 {
2180 DestroyDeviceAuthService();
2181 }
2182
SetUp()2183 void GaCancelRequestTest::SetUp() {}
TearDown()2184 void GaCancelRequestTest::TearDown() {}
2185
2186 HWTEST_F(GaCancelRequestTest, GaCancelRequestTest001, TestSize.Level0)
2187 {
2188 const GroupAuthManager *ga = GetGaInstance();
2189 ASSERT_NE(ga, nullptr);
2190 ga->cancelRequest(TEST_REQ_ID, nullptr);
2191 }
2192
2193 HWTEST_F(GaCancelRequestTest, GaCancelRequestTest002, TestSize.Level0)
2194 {
2195 const GroupAuthManager *ga = GetGaInstance();
2196 ASSERT_NE(ga, nullptr);
2197 ga->cancelRequest(TEST_REQ_ID, TEST_APP_ID);
2198 }
2199
2200 }
2201