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