1 /*
2 * Copyright (C) 2021-2022 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 "deviceauth_standard_test.h"
17 #include <cinttypes>
18 #include <unistd.h>
19 #include <gtest/gtest.h>
20 #include "account_module_defines.h"
21 #include "alg_loader.h"
22 #include "common_defs.h"
23 #include "device_auth.h"
24 #include "device_auth_defines.h"
25 #include "device_auth_ext.h"
26 #include "hc_dev_info_mock.h"
27 #include "json_utils_mock.h"
28 #include "json_utils.h"
29 #include "protocol_task_main_mock.h"
30 #include "securec.h"
31
32 using namespace std;
33 using namespace testing::ext;
34
35 namespace {
36 #define TEST_REQ_ID 123
37 #define TEST_REQ_ID2 321
38 #define TEST_APP_ID "TestAppId"
39 #define TEST_APP_ID2 "TestAppId2"
40 #define TEST_GROUP_NAME "TestGroup"
41 #define TEST_AUTH_ID "TestAuthId"
42 #define TEST_AUTH_ID2 "TestAuthId2"
43 #define TEST_AUTH_ID3 "TestAuthId3"
44 #define TEST_UDID "TestUdid"
45 #define TEST_UDID2 "TestUdid2"
46 #define TEST_UDID_CLIENT "5420459D93FE773F9945FD64277FBA2CAB8FB996DDC1D0B97676FBB1242B3930"
47 #define TEST_UDID_SERVER "52E2706717D5C39D736E134CC1E3BE1BAA2AA52DB7C76A37C749558BD2E6492C"
48 #define TEST_USER_ID_AUTH "4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4"
49 #define TEST_USER_ID "1234ABCD"
50 #define TEST_USER_ID2 "DCBA4321"
51 #define TEST_GROUP_ID "E2EE6F830B176B2C96A9F99BFAE2A61F5D1490B9F4A090E9D8C2874C230C7C21"
52 #define TEST_GROUP_ID2 "F2AA208B1E010542B20A34B03B4B6289EA7C7F6DFE97DA2E370348B826682D3D"
53 #define TEST_GROUP_ID3 "1234ABCD"
54 #define TEST_GROUP_ID4 "6B7B805962B8EB8275D73128BFDAA7ECD755A2EC304E36543941874A277FA75F"
55 #define TEST_AUTH_CODE "37364761534f454d33567a73424e794f33573330507069434b31676f7254706b"
56 #define TEST_AUTH_CODE2 "2f7562744654535564586e665467546b322b4b506b65626373466f48766a4335"
57 #define TEST_AUTH_CODE3 "1234567812345678123456781234567812345678123456781234567812345678"
58 #define TEST_AUTH_TOKEN3 "10F9F0576E61730193D2052B7F771887124A68F1607EFCF7796C1491F834CD92"
59 #define TEST_QUERY_PARAMS "bac"
60 #define TEST_PIN_CODE "123456"
61 #define TEST_HKS_DATA_PATH DEVICE_AUTH_TEST_HKS_DATA_PATH "/maindata/+0+0+0+0"
62 #define TEST_DEV_AUTH_TEMP_KEY_PAIR_LEN 32
63 #define TEST_DEV_AUTH_SLEEP_TIME 50000
64 static const int32_t TEST_AUTH_OS_ACCOUNT_ID = 100;
65 static const int TEST_DEV_AUTH_BUFFER_SIZE = 128;
66 static const char *g_invalidJsonStr = "invalid json format";
67 static const char *g_createParams = "{\"groupName\":\"TestGroup\",\"deviceId\":\"TestAuthId\",\"groupType\":256,\"group"
68 "Visibility\":-1,\"userType\":0,\"expireTime\":-1}";
69 static const char *g_createParams2 = "{\"groupName\":\"TestPrivateGroup\",\"deviceId\":\"TestAuth"
70 "Id\",\"groupType\":256,\"groupVisibility\":0,\"userType\":0,\"expireTime\":-1}";
71 static const char *g_createParams3 = "{\"groupType\":1282,\"userId\":\"1234ABCD\",\"peerUserId\":\"DCBA4321\"}";
72 static const char *g_disbandParams =
73 "{\"groupId\":\"E2EE6F830B176B2C96A9F99BFAE2A61F5D1490B9F4A090E9D8C2874C230C7C21\"}";
74 static const char *g_disbandParams2 = "{\"groupId\":\"1234ABCD\"}";
75 static const char *g_disbandParams3 =
76 "{\"groupId\":\"6B7B805962B8EB8275D73128BFDAA7ECD755A2EC304E36543941874A277FA75F\"}";
77 static const char *g_addParams =
78 "{\"groupId\":\"E2EE6F830B176B2C96A9F99BFAE2A61F5D1490B9F4A090E9D8C2874C230C7C21\","
79 "\"groupType\":256,\"pinCode\":\"123456\"}";
80 static const char *g_addParams2 =
81 "{\"groupType\":1,\"groupId\":\"1234ABCD\","
82 "\"deviceList\":[{\"deviceId\":\"TestAuthId2\",\"udid\":\"TestUdid\",\"userId\":\"1234ABCD\","
83 "\"credential\":{\"credentialType\":1,"
84 "\"authCode\":\"37364761534f454d33567a73424e794f33573330507069434b31676f7254706b\"}},"
85 "{\"deviceId\":\"TestAuthId3\",\"udid\":\"TestUdid2\",\"userId\":\"1234ABCD\","
86 "\"credential\":{\"credentialType\":1,"
87 "\"authCode\":\"2f7562744654535564586e665467546b322b4b506b65626373466f48766a4335\"}}]}";
88 static const char *g_addParams3 =
89 "{\"groupType\":1282,\"groupId\":\"6B7B805962B8EB8275D73128BFDAA7ECD755A2EC304E36543941874A277FA75F\","
90 "\"deviceList\":[{\"deviceId\":\"TestAuthId2\",\"udid\":\"TestUdid\",\"userId\":\"DCBA4321\","
91 "\"credential\":{\"credentialType\":1,"
92 "\"authCode\":\"37364761534f454d33567a73424e794f33573330507069434b31676f7254706b\"}},"
93 "{\"deviceId\":\"TestAuthId3\",\"udid\":\"TestUdid2\",\"userId\":\"DCBA4321\","
94 "\"credential\":{\"credentialType\":1,"
95 "\"authCode\":\"2f7562744654535564586e665467546b322b4b506b65626373466f48766a4335\"}}]}";
96 static const char *g_addParams4 =
97 "{\"groupType\":1,\"groupId\":\"4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4\","
98 "\"deviceList\":[{\"deviceId\":\"52E2706717D5C39D736E134CC1E3BE1BAA2AA52DB7C76A37C749558BD2E6492C\","
99 "\"udid\":\"52E2706717D5C39D736E134CC1E3BE1BAA2AA52DB7C76A37C749558BD2E6492C\","
100 "\"userId\":\"4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4\","
101 "\"credential\":{\"credentialType\":1,"
102 "\"authCode\":\"10F9F0576E61730193D2052B7F771887124A68F1607EFCF7796C1491F834CD92\"}},"
103 "{\"deviceId\":\"TestAuthId3\",\"udid\":\"TestUdid2\","
104 "\"userId\":\"4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4\","
105 "\"credential\":{\"credentialType\":1,"
106 "\"authCode\":\"2f7562744654535564586e665467546b322b4b506b65626373466f48766a4335\"}}]}";
107 static const char *g_addParams5 =
108 "{\"groupType\":1,\"groupId\":\"4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4\","
109 "\"deviceList\":[{\"deviceId\":\"5420459D93FE773F9945FD64277FBA2CAB8FB996DDC1D0B97676FBB1242B3930\","
110 "\"udid\":\"5420459D93FE773F9945FD64277FBA2CAB8FB996DDC1D0B97676FBB1242B3930\","
111 "\"userId\":\"4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4\","
112 "\"credential\":{\"credentialType\":1,"
113 "\"authCode\":\"10F9F0576E61730193D2052B7F771887124A68F1607EFCF7796C1491F834CD92\"}},"
114 "{\"deviceId\":\"TestAuthId3\",\"udid\":\"TestUdid2\","
115 "\"userId\":\"4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4\","
116 "\"credential\":{\"credentialType\":1,"
117 "\"authCode\":\"2f7562744654535564586e665467546b322b4b506b65626373466f48766a4335\"}}]}";
118 static const char *g_deleteParams =
119 "{\"groupId\":\"E2EE6F830B176B2C96A9F99BFAE2A61F5D1490B9F4A090E9D8C2874C230C7C21\",\"deleteId\":\"TestAuthId2\"}";
120 static const char *g_deleteParams2 =
121 "{\"groupType\":1,\"groupId\":\"1234ABCD\","
122 "\"deviceList\":[{\"deviceId\":\"TestAuthId2\"},{\"deviceId\":\"TestAuthId3\"}]}";
123 static const char *g_deleteParams3 =
124 "{\"groupType\":1282,\"groupId\":\"6B7B805962B8EB8275D73128BFDAA7ECD755A2EC304E36543941874A277FA75F\","
125 "\"deviceList\":[{\"deviceId\":\"TestAuthId2\"},{\"deviceId\":\"TestAuthId3\"}]}";
126 static const char *g_deleteParams4 =
127 "{\"groupId\":\"E2EE6F830B176B2C96A9F99BFAE2A61F5D1490B9F4A090E9D8C2874C230C7C21\",\"deleteId\":\"Test"
128 "AuthId2\", \"isForceDelete\":true, \"isIgnoreChannel\":true}";
129 static const char *g_getRegisterInfoParams =
130 "{\"version\":\"1.0.0\",\"deviceId\":\"TestAuthId\",\"userId\":\"1234ABCD\"}";
131 static const char *g_authParams = "{\"peerConnDeviceId\":\"52E2706717D5C39D736E134CC1E3BE1BAA2AA52DB7C76A37C"
132 "749558BD2E6492C\",\"servicePkgName\":\"TestAppId\",\"isClient\":true}";
133
134 enum AsyncStatus {
135 ASYNC_STATUS_WAITING = 0,
136 ASYNC_STATUS_TRANSMIT = 1,
137 ASYNC_STATUS_FINISH = 2,
138 ASYNC_STATUS_ERROR = 3
139 };
140
141 static AsyncStatus volatile g_asyncStatus;
142 static uint32_t g_transmitDataMaxLen = 2048;
143 static uint8_t g_transmitData[2048] = { 0 };
144 static uint32_t g_transmitDataLen = 0;
145
OnTransmit(int64_t requestId,const uint8_t * data,uint32_t dataLen)146 static bool OnTransmit(int64_t requestId, const uint8_t *data, uint32_t dataLen)
147 {
148 if (memcpy_s(g_transmitData, g_transmitDataMaxLen, data, dataLen) != EOK) {
149 return false;
150 }
151 g_transmitDataLen = dataLen;
152 g_asyncStatus = ASYNC_STATUS_TRANSMIT;
153 return true;
154 }
155
OnSessionKeyReturned(int64_t requestId,const uint8_t * sessionKey,uint32_t sessionKeyLen)156 static void OnSessionKeyReturned(int64_t requestId, const uint8_t *sessionKey, uint32_t sessionKeyLen)
157 {
158 (void)requestId;
159 (void)sessionKey;
160 (void)sessionKeyLen;
161 return;
162 }
163
OnFinish(int64_t requestId,int operationCode,const char * authReturn)164 static void OnFinish(int64_t requestId, int operationCode, const char *authReturn)
165 {
166 g_asyncStatus = ASYNC_STATUS_FINISH;
167 }
168
OnError(int64_t requestId,int operationCode,int errorCode,const char * errorReturn)169 static void OnError(int64_t requestId, int operationCode, int errorCode, const char *errorReturn)
170 {
171 g_asyncStatus = ASYNC_STATUS_ERROR;
172 }
173
OnBindRequest(int64_t requestId,int operationCode,const char * reqParam)174 static char *OnBindRequest(int64_t requestId, int operationCode, const char* reqParam)
175 {
176 CJson *json = CreateJson();
177 AddIntToJson(json, FIELD_CONFIRMATION, REQUEST_ACCEPTED);
178 AddIntToJson(json, FIELD_OS_ACCOUNT_ID, TEST_AUTH_OS_ACCOUNT_ID);
179 AddStringToJson(json, FIELD_PIN_CODE, TEST_PIN_CODE);
180 AddStringToJson(json, FIELD_DEVICE_ID, TEST_AUTH_ID2);
181 char *returnDataStr = PackJsonToString(json);
182 FreeJson(json);
183 return returnDataStr;
184 }
185
OnAuthRequest(int64_t requestId,int operationCode,const char * reqParam)186 static char *OnAuthRequest(int64_t requestId, int operationCode, const char* reqParam)
187 {
188 CJson *json = CreateJson();
189 AddIntToJson(json, FIELD_CONFIRMATION, REQUEST_ACCEPTED);
190 AddIntToJson(json, FIELD_OS_ACCOUNT_ID, TEST_AUTH_OS_ACCOUNT_ID);
191 AddStringToJson(json, FIELD_PEER_CONN_DEVICE_ID, TEST_UDID_CLIENT);
192 AddStringToJson(json, FIELD_SERVICE_PKG_NAME, TEST_APP_ID);
193 char *returnDataStr = PackJsonToString(json);
194 FreeJson(json);
195 return returnDataStr;
196 }
197
198 static DeviceAuthCallback g_gmCallback = {
199 .onTransmit = OnTransmit,
200 .onSessionKeyReturned = OnSessionKeyReturned,
201 .onFinish = OnFinish,
202 .onError = OnError,
203 .onRequest = OnBindRequest
204 };
205
206 static DeviceAuthCallback g_gaCallback = {
207 .onTransmit = OnTransmit,
208 .onSessionKeyReturned = OnSessionKeyReturned,
209 .onFinish = OnFinish,
210 .onError = OnError,
211 .onRequest = OnAuthRequest
212 };
213
RemoveDir(const char * path)214 static void RemoveDir(const char *path)
215 {
216 char strBuf[TEST_DEV_AUTH_BUFFER_SIZE] = {0};
217 if (path == nullptr) {
218 return;
219 }
220 if (sprintf_s(strBuf, sizeof(strBuf) - 1, "rm -rf %s", path) < 0) {
221 return;
222 }
223 system(strBuf);
224 return;
225 }
226
RemoveHuks(void)227 static void RemoveHuks(void)
228 {
229 RemoveDir(TEST_HKS_DATA_PATH);
230 return;
231 }
232
DeleteDatabase()233 static void DeleteDatabase()
234 {
235 const char *groupPath = "/data/service/el1/public/deviceauthMock";
236 RemoveDir(groupPath);
237 RemoveHuks();
238 return;
239 }
240
GenerateTempKeyPair(Uint8Buff * keyAlias)241 static bool GenerateTempKeyPair(Uint8Buff *keyAlias)
242 {
243 int ret = GetLoaderInstance()->checkKeyExist(keyAlias);
244 if (ret != HC_SUCCESS) {
245 printf("Key pair not exist, start to generate\n");
246 int32_t authId = 0;
247 Uint8Buff authIdBuff = { reinterpret_cast<uint8_t *>(&authId), sizeof(int32_t)};
248 ExtraInfo extInfo = {authIdBuff, -1, -1};
249 ret = GetLoaderInstance()->generateKeyPairWithStorage(keyAlias, TEST_DEV_AUTH_TEMP_KEY_PAIR_LEN, P256,
250 KEY_PURPOSE_SIGN_VERIFY, &extInfo);
251 } else {
252 printf("Server key pair already exists\n");
253 }
254
255 if (ret != HC_SUCCESS) {
256 printf("Generate key pair failed\n");
257 return false;
258 } else {
259 printf("Generate key pair for server success\n");
260 }
261 return true;
262 }
263
GetAsyCredentialJson(string registerInfo)264 static CJson *GetAsyCredentialJson(string registerInfo)
265 {
266 uint8_t keyAliasValue[] = "TestServerKeyPair";
267 int32_t keyAliasLen = 18;
268 Uint8Buff keyAlias = {
269 .val = keyAliasValue,
270 .length = keyAliasLen
271 };
272 if (!GenerateTempKeyPair(&keyAlias)) {
273 return nullptr;
274 }
275 uint8_t *serverPkVal = reinterpret_cast<uint8_t *>(HcMalloc(SERVER_PK_SIZE, 0));
276 Uint8Buff serverPk = {
277 .val = serverPkVal,
278 .length = SERVER_PK_SIZE
279 };
280
281 int32_t ret = GetLoaderInstance()->exportPublicKey(&keyAlias, &serverPk);
282 if (ret != HC_SUCCESS) {
283 printf("export PublicKey failed\n");
284 HcFree(serverPkVal);
285 return nullptr;
286 }
287
288 Uint8Buff messageBuff = {
289 .val = reinterpret_cast<uint8_t *>(const_cast<char *>(registerInfo.c_str())),
290 .length = registerInfo.length() + 1
291 };
292 uint8_t *signatureValue = reinterpret_cast<uint8_t *>(HcMalloc(SIGNATURE_SIZE, 0));
293 Uint8Buff signature = {
294 .val = signatureValue,
295 .length = SIGNATURE_SIZE
296 };
297 ret = GetLoaderInstance()->sign(&keyAlias, &messageBuff, P256, &signature, true);
298 if (ret != HC_SUCCESS) {
299 printf("Sign pkInfo failed.\n");
300 HcFree(serverPkVal);
301 HcFree(signatureValue);
302 return nullptr;
303 }
304
305 CJson *pkInfoJson = CreateJsonFromString(registerInfo.c_str());
306 CJson *credentialJson = CreateJson();
307 (void)AddIntToJson(credentialJson, FIELD_CREDENTIAL_TYPE, ASYMMETRIC_CRED);
308 (void)AddByteToJson(credentialJson, FIELD_SERVER_PK, serverPkVal, serverPk.length);
309 (void)AddByteToJson(credentialJson, FIELD_PK_INFO_SIGNATURE, signatureValue, signature.length);
310 (void)AddObjToJson(credentialJson, FIELD_PK_INFO, pkInfoJson);
311 FreeJson(pkInfoJson);
312 return credentialJson;
313 }
314
CreateDemoGroup(int32_t osAccountId,int64_t reqId,const char * appId,const char * createParams)315 static void CreateDemoGroup(int32_t osAccountId, int64_t reqId, const char *appId, const char *createParams)
316 {
317 g_asyncStatus = ASYNC_STATUS_WAITING;
318 const DeviceGroupManager *gm = GetGmInstance();
319 int32_t ret = gm->createGroup(osAccountId, reqId, appId, createParams);
320 if (ret != HC_SUCCESS) {
321 g_asyncStatus = ASYNC_STATUS_ERROR;
322 return;
323 }
324 while (g_asyncStatus == ASYNC_STATUS_WAITING) {
325 usleep(TEST_DEV_AUTH_SLEEP_TIME);
326 }
327 usleep(TEST_DEV_AUTH_SLEEP_TIME);
328 }
329
CreateDemoIdenticalAccountGroup()330 static void CreateDemoIdenticalAccountGroup()
331 {
332 g_asyncStatus = ASYNC_STATUS_WAITING;
333 const DeviceGroupManager *gm = GetGmInstance();
334 ASSERT_NE(gm, nullptr);
335 char *returnData = nullptr;
336 int32_t ret = gm->getRegisterInfo(g_getRegisterInfoParams, &returnData);
337 ASSERT_EQ(ret, HC_SUCCESS);
338 ASSERT_NE(returnData, nullptr);
339 string registerInfo(returnData);
340
341 CJson *credJson = GetAsyCredentialJson(registerInfo);
342 ASSERT_NE(credJson, nullptr);
343 CJson *json = CreateJson();
344 AddIntToJson(json, FIELD_GROUP_TYPE, IDENTICAL_ACCOUNT_GROUP);
345 AddStringToJson(json, FIELD_USER_ID, TEST_USER_ID);
346 AddObjToJson(json, FIELD_CREDENTIAL, credJson);
347 char *jsonStr = PackJsonToString(json);
348 FreeJson(credJson);
349 FreeJson(json);
350 gm->destroyInfo(&returnData);
351 ASSERT_NE(jsonStr, nullptr);
352 ret = gm->createGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, jsonStr);
353 FreeJsonString(jsonStr);
354 ASSERT_EQ(ret, HC_SUCCESS);
355 while (g_asyncStatus == ASYNC_STATUS_WAITING) {
356 usleep(TEST_DEV_AUTH_SLEEP_TIME);
357 }
358 }
359
CreateDemoSymClientIdenticalAccountGroup(void)360 static void CreateDemoSymClientIdenticalAccountGroup(void)
361 {
362 g_asyncStatus = ASYNC_STATUS_WAITING;
363 const DeviceGroupManager *gm = GetGmInstance();
364 ASSERT_NE(gm, nullptr);
365
366 CJson *credJson = CreateJson();
367 (void)AddIntToJson(credJson, FIELD_CREDENTIAL_TYPE, SYMMETRIC_CRED);
368 (void)AddStringToJson(credJson, FIELD_AUTH_CODE, TEST_AUTH_CODE3);
369 CJson *json = CreateJson();
370 AddIntToJson(json, FIELD_GROUP_TYPE, IDENTICAL_ACCOUNT_GROUP);
371 AddStringToJson(json, FIELD_USER_ID, TEST_USER_ID_AUTH);
372 AddObjToJson(json, FIELD_CREDENTIAL, credJson);
373 char *jsonStr = PackJsonToString(json);
374 FreeJson(credJson);
375 FreeJson(json);
376 if (jsonStr == nullptr) {
377 return;
378 }
379 int32_t ret = gm->createGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, jsonStr);
380 FreeJsonString(jsonStr);
381 ASSERT_EQ(ret, HC_SUCCESS);
382 while (g_asyncStatus == ASYNC_STATUS_WAITING) {
383 usleep(TEST_DEV_AUTH_SLEEP_TIME);
384 }
385 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
386 }
387
CreateDemoSymServerIdenticalAccountGroup(void)388 static void CreateDemoSymServerIdenticalAccountGroup(void)
389 {
390 g_asyncStatus = ASYNC_STATUS_WAITING;
391 const DeviceGroupManager *gm = GetGmInstance();
392 ASSERT_NE(gm, nullptr);
393
394 CJson *credJson = CreateJson();
395 (void)AddIntToJson(credJson, FIELD_CREDENTIAL_TYPE, SYMMETRIC_CRED);
396 (void)AddStringToJson(credJson, FIELD_AUTH_CODE, TEST_AUTH_CODE3);
397 CJson *json = CreateJson();
398 AddIntToJson(json, FIELD_GROUP_TYPE, IDENTICAL_ACCOUNT_GROUP);
399 AddStringToJson(json, FIELD_USER_ID, TEST_USER_ID_AUTH);
400 AddObjToJson(json, FIELD_CREDENTIAL, credJson);
401 char *jsonStr = PackJsonToString(json);
402 FreeJson(credJson);
403 FreeJson(json);
404 if (jsonStr == nullptr) {
405 return;
406 }
407
408 int32_t ret = gm->createGroup(TEST_AUTH_OS_ACCOUNT_ID, TEST_REQ_ID, TEST_APP_ID, jsonStr);
409 FreeJsonString(jsonStr);
410 ASSERT_EQ(ret, HC_SUCCESS);
411 while (g_asyncStatus == ASYNC_STATUS_WAITING) {
412 usleep(TEST_DEV_AUTH_SLEEP_TIME);
413 }
414 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
415 }
416
CreateDemoAcrossAccountGroup(int32_t osAccountId,int64_t reqId,const char * appId,const char * createParams)417 static void CreateDemoAcrossAccountGroup(int32_t osAccountId, int64_t reqId, const char *appId,
418 const char *createParams)
419 {
420 g_asyncStatus = ASYNC_STATUS_WAITING;
421 const DeviceGroupManager *gm = GetGmInstance();
422 ASSERT_NE(gm, nullptr);
423 int32_t ret = gm->createGroup(osAccountId, reqId, appId, createParams);
424 ASSERT_EQ(ret, HC_SUCCESS);
425 while (g_asyncStatus == ASYNC_STATUS_WAITING) {
426 usleep(TEST_DEV_AUTH_SLEEP_TIME);
427 }
428 }
429
DeleteDemoGroup(int32_t osAccountId,int64_t reqId,const char * appId,const char * disbandParams)430 static void DeleteDemoGroup(int32_t osAccountId, int64_t reqId, const char *appId,
431 const char *disbandParams)
432 {
433 g_asyncStatus = ASYNC_STATUS_WAITING;
434 const DeviceGroupManager *gm = GetGmInstance();
435 ASSERT_NE(gm, nullptr);
436 int32_t ret = gm->deleteGroup(osAccountId, reqId, appId, disbandParams);
437 ASSERT_EQ(ret, HC_SUCCESS);
438 while (g_asyncStatus == ASYNC_STATUS_WAITING) {
439 usleep(TEST_DEV_AUTH_SLEEP_TIME);
440 }
441 }
442
DeleteDemoIdenticalAccountGroup(void)443 static void DeleteDemoIdenticalAccountGroup(void)
444 {
445 g_asyncStatus = ASYNC_STATUS_WAITING;
446 const DeviceGroupManager *gm = GetGmInstance();
447 ASSERT_NE(gm, nullptr);
448 int32_t ret = gm->deleteGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_disbandParams2);
449 ASSERT_EQ(ret, HC_SUCCESS);
450 while (g_asyncStatus == ASYNC_STATUS_WAITING) {
451 usleep(TEST_DEV_AUTH_SLEEP_TIME);
452 }
453 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
454 }
455
DeleteDemoAcrossAccountGroup(void)456 static void DeleteDemoAcrossAccountGroup(void)
457 {
458 g_asyncStatus = ASYNC_STATUS_WAITING;
459 const DeviceGroupManager *gm = GetGmInstance();
460 ASSERT_NE(gm, nullptr);
461 int32_t ret = gm->deleteGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_disbandParams3);
462 ASSERT_EQ(ret, HC_SUCCESS);
463 while (g_asyncStatus == ASYNC_STATUS_WAITING) {
464 usleep(TEST_DEV_AUTH_SLEEP_TIME);
465 }
466 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
467 }
468
AddDemoMember(void)469 static void AddDemoMember(void)
470 {
471 g_asyncStatus = ASYNC_STATUS_WAITING;
472 bool isClient = true;
473 SetDeviceStatus(isClient);
474 const DeviceGroupManager *gm = GetGmInstance();
475 int32_t ret = gm->addMemberToGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_addParams);
476 if (ret != HC_SUCCESS) {
477 g_asyncStatus = ASYNC_STATUS_ERROR;
478 return;
479 }
480 while (g_asyncStatus == ASYNC_STATUS_WAITING) {
481 usleep(TEST_DEV_AUTH_SLEEP_TIME);
482 }
483 while (g_asyncStatus == ASYNC_STATUS_TRANSMIT) {
484 isClient = !isClient;
485 SetDeviceStatus(isClient);
486 g_asyncStatus = ASYNC_STATUS_WAITING;
487 if (isClient) {
488 ret = gm->processData(TEST_REQ_ID, g_transmitData, g_transmitDataLen);
489 } else {
490 ret = gm->processData(TEST_REQ_ID2, g_transmitData, g_transmitDataLen);
491 }
492 (void)memset_s(g_transmitData, g_transmitDataMaxLen, 0, g_transmitDataMaxLen);
493 g_transmitDataLen = 0;
494 if (ret != HC_SUCCESS) {
495 g_asyncStatus = ASYNC_STATUS_ERROR;
496 return;
497 }
498 while (g_asyncStatus == ASYNC_STATUS_WAITING) {
499 usleep(TEST_DEV_AUTH_SLEEP_TIME);
500 }
501 if (g_asyncStatus == ASYNC_STATUS_ERROR) {
502 break;
503 }
504 if (g_transmitDataLen > 0) {
505 g_asyncStatus = ASYNC_STATUS_TRANSMIT;
506 }
507 }
508 usleep(TEST_DEV_AUTH_SLEEP_TIME);
509 SetDeviceStatus(true);
510 }
511
DeleteDemoMember(int32_t osAccountId,int64_t reqId,const char * appId,const char * deleteParams)512 static void DeleteDemoMember(int32_t osAccountId, int64_t reqId, const char *appId, const char *deleteParams)
513 {
514 g_asyncStatus = ASYNC_STATUS_WAITING;
515 bool isClient = true;
516 SetDeviceStatus(isClient);
517 const DeviceGroupManager *gm = GetGmInstance();
518 ASSERT_NE(gm, nullptr);
519 int32_t ret = gm->deleteMemberFromGroup(osAccountId, reqId, appId, deleteParams);
520 ASSERT_EQ(ret, HC_SUCCESS);
521 while (g_asyncStatus == ASYNC_STATUS_WAITING) {
522 usleep(TEST_DEV_AUTH_SLEEP_TIME);
523 }
524 while (g_asyncStatus == ASYNC_STATUS_TRANSMIT) {
525 isClient = !isClient;
526 SetDeviceStatus(isClient);
527 g_asyncStatus = ASYNC_STATUS_WAITING;
528 if (isClient) {
529 ret = gm->processData(TEST_REQ_ID, g_transmitData, g_transmitDataLen);
530 } else {
531 ret = gm->processData(TEST_REQ_ID2, g_transmitData, g_transmitDataLen);
532 }
533 (void)memset_s(g_transmitData, g_transmitDataMaxLen, 0, g_transmitDataMaxLen);
534 g_transmitDataLen = 0;
535 ASSERT_EQ(ret, HC_SUCCESS);
536 while (g_asyncStatus == ASYNC_STATUS_WAITING) {
537 usleep(TEST_DEV_AUTH_SLEEP_TIME);
538 }
539 if (g_asyncStatus == ASYNC_STATUS_ERROR) {
540 break;
541 }
542 if (g_transmitDataLen > 0) {
543 g_asyncStatus = ASYNC_STATUS_TRANSMIT;
544 }
545 }
546 SetDeviceStatus(true);
547 }
548
AuthDemoMember(void)549 static void AuthDemoMember(void)
550 {
551 g_asyncStatus = ASYNC_STATUS_WAITING;
552 bool isClient = true;
553 SetDeviceStatus(isClient);
554 const GroupAuthManager *ga = GetGaInstance();
555 ASSERT_NE(ga, nullptr);
556 int32_t ret = ga->authDevice(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, g_authParams, &g_gaCallback);
557 if (ret != HC_SUCCESS) {
558 g_asyncStatus = ASYNC_STATUS_ERROR;
559 return;
560 }
561 while (g_asyncStatus == ASYNC_STATUS_WAITING) {
562 usleep(TEST_DEV_AUTH_SLEEP_TIME);
563 }
564 while (g_asyncStatus == ASYNC_STATUS_TRANSMIT) {
565 isClient = !isClient;
566 SetDeviceStatus(isClient);
567 g_asyncStatus = ASYNC_STATUS_WAITING;
568 if (isClient) {
569 ret = ga->processData(TEST_REQ_ID, g_transmitData, g_transmitDataLen, &g_gaCallback);
570 } else {
571 ret = ga->processData(TEST_REQ_ID2, g_transmitData, g_transmitDataLen, &g_gaCallback);
572 }
573 (void)memset_s(g_transmitData, g_transmitDataMaxLen, 0, g_transmitDataMaxLen);
574 g_transmitDataLen = 0;
575 if (ret != HC_SUCCESS) {
576 g_asyncStatus = ASYNC_STATUS_ERROR;
577 return;
578 }
579 while (g_asyncStatus == ASYNC_STATUS_WAITING) {
580 usleep(TEST_DEV_AUTH_SLEEP_TIME);
581 }
582 if (g_asyncStatus == ASYNC_STATUS_ERROR) {
583 break;
584 }
585 if (g_transmitDataLen > 0) {
586 g_asyncStatus = ASYNC_STATUS_TRANSMIT;
587 }
588 }
589 SetDeviceStatus(true);
590 }
591
592 class InitDeviceAuthServiceTest : public testing::Test {
593 public:
594 static void SetUpTestCase();
595 static void TearDownTestCase();
596 void SetUp();
597 void TearDown();
598 };
599
SetUpTestCase()600 void InitDeviceAuthServiceTest::SetUpTestCase() {}
TearDownTestCase()601 void InitDeviceAuthServiceTest::TearDownTestCase() {}
SetUp()602 void InitDeviceAuthServiceTest::SetUp() {}
TearDown()603 void InitDeviceAuthServiceTest::TearDown() {}
604
605 HWTEST_F(InitDeviceAuthServiceTest, InitDeviceAuthServiceTest001, TestSize.Level0)
606 {
607 int32_t ret = InitDeviceAuthService();
608 EXPECT_EQ(ret, HC_SUCCESS);
609 }
610
611 class DestroyDeviceAuthServiceTest : public testing::Test {
612 public:
613 static void SetUpTestCase();
614 static void TearDownTestCase();
615 void SetUp();
616 void TearDown();
617 };
618
SetUpTestCase()619 void DestroyDeviceAuthServiceTest::SetUpTestCase() {}
TearDownTestCase()620 void DestroyDeviceAuthServiceTest::TearDownTestCase() {}
SetUp()621 void DestroyDeviceAuthServiceTest::SetUp() {}
TearDown()622 void DestroyDeviceAuthServiceTest::TearDown() {}
623
624 HWTEST_F(DestroyDeviceAuthServiceTest, DestroyDeviceAuthServiceTest001, TestSize.Level0)
625 {
626 int32_t ret = InitDeviceAuthService();
627 EXPECT_EQ(ret, HC_SUCCESS);
628 DestroyDeviceAuthService();
629 }
630
631 class GetGmInstanceTest : public testing::Test {
632 public:
633 static void SetUpTestCase();
634 static void TearDownTestCase();
635 void SetUp();
636 void TearDown();
637 };
638
SetUpTestCase()639 void GetGmInstanceTest::SetUpTestCase() {}
TearDownTestCase()640 void GetGmInstanceTest::TearDownTestCase() {}
641
SetUp()642 void GetGmInstanceTest::SetUp()
643 {
644 int ret = InitDeviceAuthService();
645 EXPECT_EQ(ret, HC_SUCCESS);
646 }
647
TearDown()648 void GetGmInstanceTest::TearDown()
649 {
650 DestroyDeviceAuthService();
651 }
652
653 HWTEST_F(GetGmInstanceTest, GetGmInstanceTest001, TestSize.Level0)
654 {
655 const DeviceGroupManager *gm = GetGmInstance();
656 EXPECT_NE(gm, nullptr);
657 }
658
659 class GetGaInstanceTest : public testing::Test {
660 public:
661 static void SetUpTestCase();
662 static void TearDownTestCase();
663 void SetUp();
664 void TearDown();
665 };
666
SetUpTestCase()667 void GetGaInstanceTest::SetUpTestCase() {}
TearDownTestCase()668 void GetGaInstanceTest::TearDownTestCase() {}
669
SetUp()670 void GetGaInstanceTest::SetUp()
671 {
672 int ret = InitDeviceAuthService();
673 EXPECT_EQ(ret, HC_SUCCESS);
674 }
675
TearDown()676 void GetGaInstanceTest::TearDown()
677 {
678 DestroyDeviceAuthService();
679 }
680
681 HWTEST_F(GetGaInstanceTest, GetGaInstanceTest001, TestSize.Level0)
682 {
683 const GroupAuthManager *ga = GetGaInstance();
684 EXPECT_NE(ga, nullptr);
685 }
686
687 class GmRegCallbackTest : public testing::Test {
688 public:
689 static void SetUpTestCase();
690 static void TearDownTestCase();
691 void SetUp();
692 void TearDown();
693 };
694
SetUpTestCase()695 void GmRegCallbackTest::SetUpTestCase() {}
TearDownTestCase()696 void GmRegCallbackTest::TearDownTestCase() {}
697
SetUp()698 void GmRegCallbackTest::SetUp()
699 {
700 int ret = InitDeviceAuthService();
701 EXPECT_EQ(ret, HC_SUCCESS);
702 }
703
TearDown()704 void GmRegCallbackTest::TearDown()
705 {
706 DestroyDeviceAuthService();
707 }
708
709 HWTEST_F(GmRegCallbackTest, GmRegCallbackTest001, TestSize.Level0)
710 {
711 const DeviceGroupManager *gm = GetGmInstance();
712 ASSERT_NE(gm, nullptr);
713 DeviceAuthCallback callback;
714 int32_t ret = gm->regCallback(TEST_APP_ID, &callback);
715 ASSERT_EQ(ret, HC_SUCCESS);
716 }
717
718 HWTEST_F(GmRegCallbackTest, GmRegCallbackTest002, TestSize.Level0)
719 {
720 const DeviceGroupManager *gm = GetGmInstance();
721 ASSERT_NE(gm, nullptr);
722 DeviceAuthCallback callback;
723 int32_t ret = gm->regCallback(TEST_APP_ID, &callback);
724 ASSERT_EQ(ret, HC_SUCCESS);
725 DeviceAuthCallback callback2;
726 ret = gm->regCallback(TEST_APP_ID, &callback2);
727 ASSERT_EQ(ret, HC_SUCCESS);
728 }
729
730 HWTEST_F(GmRegCallbackTest, GmRegCallbackTest003, TestSize.Level0)
731 {
732 const DeviceGroupManager *gm = GetGmInstance();
733 ASSERT_NE(gm, nullptr);
734 DeviceAuthCallback callback;
735 int32_t ret = gm->regCallback(nullptr, &callback);
736 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
737 }
738
739 HWTEST_F(GmRegCallbackTest, GmRegCallbackTest004, TestSize.Level0)
740 {
741 const DeviceGroupManager *gm = GetGmInstance();
742 ASSERT_NE(gm, nullptr);
743 int32_t ret = gm->regCallback(TEST_APP_ID, nullptr);
744 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
745 }
746
747 class GmUnRegCallbackTest : public testing::Test {
748 public:
749 static void SetUpTestCase();
750 static void TearDownTestCase();
751 void SetUp();
752 void TearDown();
753 };
754
SetUpTestCase()755 void GmUnRegCallbackTest::SetUpTestCase() {}
TearDownTestCase()756 void GmUnRegCallbackTest::TearDownTestCase() {}
757
SetUp()758 void GmUnRegCallbackTest::SetUp()
759 {
760 int ret = InitDeviceAuthService();
761 EXPECT_EQ(ret, HC_SUCCESS);
762 }
763
TearDown()764 void GmUnRegCallbackTest::TearDown()
765 {
766 DestroyDeviceAuthService();
767 }
768
769 HWTEST_F(GmUnRegCallbackTest, GmUnRegCallbackTest001, TestSize.Level0)
770 {
771 const DeviceGroupManager *gm = GetGmInstance();
772 ASSERT_NE(gm, nullptr);
773 DeviceAuthCallback callback;
774 int32_t ret = gm->regCallback(TEST_APP_ID, &callback);
775 ASSERT_EQ(ret, HC_SUCCESS);
776 ret = gm->unRegCallback(TEST_APP_ID);
777 ASSERT_EQ(ret, HC_SUCCESS);
778 }
779
780 HWTEST_F(GmUnRegCallbackTest, GmUnRegCallbackTest002, TestSize.Level0)
781 {
782 const DeviceGroupManager *gm = GetGmInstance();
783 ASSERT_NE(gm, nullptr);
784 int32_t ret = gm->unRegCallback(TEST_APP_ID);
785 ASSERT_EQ(ret, HC_SUCCESS);
786 }
787
788 HWTEST_F(GmUnRegCallbackTest, GmUnRegCallbackTest003, TestSize.Level0)
789 {
790 const DeviceGroupManager *gm = GetGmInstance();
791 ASSERT_NE(gm, nullptr);
792 int32_t ret = gm->unRegCallback(nullptr);
793 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
794 }
795
796 class GmRegDataChangeListenerTest : public testing::Test {
797 public:
798 static void SetUpTestCase();
799 static void TearDownTestCase();
800 void SetUp();
801 void TearDown();
802 };
803
SetUpTestCase()804 void GmRegDataChangeListenerTest::SetUpTestCase() {}
TearDownTestCase()805 void GmRegDataChangeListenerTest::TearDownTestCase() {}
806
SetUp()807 void GmRegDataChangeListenerTest::SetUp()
808 {
809 int ret = InitDeviceAuthService();
810 EXPECT_EQ(ret, HC_SUCCESS);
811 }
812
TearDown()813 void GmRegDataChangeListenerTest::TearDown()
814 {
815 DestroyDeviceAuthService();
816 }
817
818 HWTEST_F(GmRegDataChangeListenerTest, GmRegDataChangeListenerTest001, TestSize.Level0)
819 {
820 const DeviceGroupManager *gm = GetGmInstance();
821 ASSERT_NE(gm, nullptr);
822 DataChangeListener listener;
823 int32_t ret = gm->regDataChangeListener(TEST_APP_ID, &listener);
824 ASSERT_EQ(ret, HC_SUCCESS);
825 }
826
827 HWTEST_F(GmRegDataChangeListenerTest, GmRegDataChangeListenerTest002, TestSize.Level0)
828 {
829 const DeviceGroupManager *gm = GetGmInstance();
830 ASSERT_NE(gm, nullptr);
831 DataChangeListener listener;
832 int32_t ret = gm->regDataChangeListener(TEST_APP_ID, &listener);
833 ASSERT_EQ(ret, HC_SUCCESS);
834 ret = gm->regDataChangeListener(TEST_APP_ID, &listener);
835 ASSERT_EQ(ret, HC_SUCCESS);
836 }
837
838 HWTEST_F(GmRegDataChangeListenerTest, GmRegDataChangeListenerTest003, TestSize.Level0)
839 {
840 const DeviceGroupManager *gm = GetGmInstance();
841 ASSERT_NE(gm, nullptr);
842 DataChangeListener listener;
843 int32_t ret = gm->regDataChangeListener(nullptr, &listener);
844 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
845 }
846
847 HWTEST_F(GmRegDataChangeListenerTest, GmRegDataChangeListenerTest004, TestSize.Level0)
848 {
849 const DeviceGroupManager *gm = GetGmInstance();
850 ASSERT_NE(gm, nullptr);
851 int32_t ret = gm->regDataChangeListener(TEST_APP_ID, nullptr);
852 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
853 }
854
855 class GmUnRegDataChangeListenerTest : public testing::Test {
856 public:
857 static void SetUpTestCase();
858 static void TearDownTestCase();
859 void SetUp();
860 void TearDown();
861 };
862
SetUpTestCase()863 void GmUnRegDataChangeListenerTest::SetUpTestCase() {}
TearDownTestCase()864 void GmUnRegDataChangeListenerTest::TearDownTestCase() {}
865
SetUp()866 void GmUnRegDataChangeListenerTest::SetUp()
867 {
868 int ret = InitDeviceAuthService();
869 EXPECT_EQ(ret, HC_SUCCESS);
870 }
871
TearDown()872 void GmUnRegDataChangeListenerTest::TearDown()
873 {
874 DestroyDeviceAuthService();
875 }
876
877 HWTEST_F(GmUnRegDataChangeListenerTest, GmUnRegDataChangeListenerTest001, TestSize.Level0)
878 {
879 const DeviceGroupManager *gm = GetGmInstance();
880 ASSERT_NE(gm, nullptr);
881 DataChangeListener listener;
882 int32_t ret = gm->regDataChangeListener(TEST_APP_ID, &listener);
883 ASSERT_EQ(ret, HC_SUCCESS);
884 ret = gm->unRegDataChangeListener(TEST_APP_ID);
885 ASSERT_EQ(ret, HC_SUCCESS);
886 }
887
888 HWTEST_F(GmUnRegDataChangeListenerTest, GmUnRegDataChangeListenerTest002, TestSize.Level0)
889 {
890 const DeviceGroupManager *gm = GetGmInstance();
891 ASSERT_NE(gm, nullptr);
892 int32_t ret = gm->unRegDataChangeListener(TEST_APP_ID);
893 ASSERT_EQ(ret, HC_SUCCESS);
894 }
895
896 HWTEST_F(GmUnRegDataChangeListenerTest, GmUnRegDataChangeListenerTest003, TestSize.Level0)
897 {
898 const DeviceGroupManager *gm = GetGmInstance();
899 ASSERT_NE(gm, nullptr);
900 int32_t ret = gm->unRegDataChangeListener(nullptr);
901 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
902 }
903
904 class GmCreateGroupTest : public testing::Test {
905 public:
906 static void SetUpTestCase();
907 static void TearDownTestCase();
908 void SetUp();
909 void TearDown();
910 };
911
SetUpTestCase()912 void GmCreateGroupTest::SetUpTestCase() {}
TearDownTestCase()913 void GmCreateGroupTest::TearDownTestCase() {}
914
SetUp()915 void GmCreateGroupTest::SetUp()
916 {
917 DeleteDatabase();
918 int ret = InitDeviceAuthService();
919 EXPECT_EQ(ret, HC_SUCCESS);
920 }
921
TearDown()922 void GmCreateGroupTest::TearDown()
923 {
924 DestroyDeviceAuthService();
925 }
926
927 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest001, TestSize.Level0)
928 {
929 const DeviceGroupManager *gm = GetGmInstance();
930 ASSERT_NE(gm, nullptr);
931 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
932 ASSERT_EQ(ret, HC_SUCCESS);
933 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
934 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
935 }
936
937 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest002, TestSize.Level0)
938 {
939 const DeviceGroupManager *gm = GetGmInstance();
940 ASSERT_NE(gm, nullptr);
941 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
942 ASSERT_EQ(ret, HC_SUCCESS);
943 CreateDemoIdenticalAccountGroup();
944 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
945 }
946
947 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest003, TestSize.Level0)
948 {
949 const DeviceGroupManager *gm = GetGmInstance();
950 ASSERT_NE(gm, nullptr);
951 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
952 ASSERT_EQ(ret, HC_SUCCESS);
953 CreateDemoIdenticalAccountGroup();
954 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
955 CreateDemoAcrossAccountGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams3);
956 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
957 }
958
959 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest101, TestSize.Level0)
960 {
961 const DeviceGroupManager *gm = GetGmInstance();
962 ASSERT_NE(gm, nullptr);
963 int32_t ret = gm->createGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, nullptr, g_createParams);
964 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
965 }
966
967 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest102, TestSize.Level0)
968 {
969 const DeviceGroupManager *gm = GetGmInstance();
970 ASSERT_NE(gm, nullptr);
971 int32_t ret = gm->createGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, nullptr);
972 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
973 }
974
975 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest103, TestSize.Level0)
976 {
977 const DeviceGroupManager *gm = GetGmInstance();
978 ASSERT_NE(gm, nullptr);
979 int32_t ret = gm->createGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
980 ASSERT_NE(ret, HC_SUCCESS);
981 }
982
983 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest104, TestSize.Level0)
984 {
985 const DeviceGroupManager *gm = GetGmInstance();
986 ASSERT_NE(gm, nullptr);
987 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
988 ASSERT_EQ(ret, HC_SUCCESS);
989 const char *createParams = "{\"deviceId\":\"TestAuthId\",\"groupType\":256,\"group"
990 "Visibility\":-1,\"userType\":0,\"expireTime\":-1}";
991 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, createParams);
992 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
993 }
994
995 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest105, TestSize.Level0)
996 {
997 const DeviceGroupManager *gm = GetGmInstance();
998 ASSERT_NE(gm, nullptr);
999 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1000 ASSERT_EQ(ret, HC_SUCCESS);
1001 const char *createParams = "{\"groupName\":\"TestGroup\",\"groupType\":256,\"group"
1002 "Visibility\":-1,\"userType\":0,\"expireTime\":-1}";
1003 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, createParams);
1004 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1005 }
1006
1007 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest106, TestSize.Level0)
1008 {
1009 const DeviceGroupManager *gm = GetGmInstance();
1010 ASSERT_NE(gm, nullptr);
1011 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1012 ASSERT_EQ(ret, HC_SUCCESS);
1013 const char *createParams = "{\"groupName\":\"TestGroup\",\"deviceId\":\"TestAuthId\",\"group"
1014 "Visibility\":-1,\"userType\":0,\"expireTime\":-1}";
1015 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, createParams);
1016 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
1017 }
1018
1019 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest107, TestSize.Level0)
1020 {
1021 const DeviceGroupManager *gm = GetGmInstance();
1022 ASSERT_NE(gm, nullptr);
1023 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1024 ASSERT_EQ(ret, HC_SUCCESS);
1025 const char *createParams = "{\"groupName\":\"TestGroup\",\"deviceId\":\"TestAuthId\",\"group"
1026 "Type\":256,\"userType\":0,\"expireTime\":-1}";
1027 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, createParams);
1028 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1029 }
1030
1031 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest108, TestSize.Level0)
1032 {
1033 const DeviceGroupManager *gm = GetGmInstance();
1034 ASSERT_NE(gm, nullptr);
1035 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1036 ASSERT_EQ(ret, HC_SUCCESS);
1037 const char *createParams = "{\"groupName\":\"TestGroup\",\"deviceId\":\"TestAuthId\",\"groupType\":256,\"group"
1038 "Visibility\":-1,\"expireTime\":-1}";
1039 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, createParams);
1040 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1041 }
1042
1043 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest109, TestSize.Level0)
1044 {
1045 const DeviceGroupManager *gm = GetGmInstance();
1046 ASSERT_NE(gm, nullptr);
1047 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1048 ASSERT_EQ(ret, HC_SUCCESS);
1049 const char *createParams = "{\"groupName\":\"TestGroup\",\"deviceId\":\"TestAuthId\",\"groupType\":256,\"group"
1050 "Visibility\":-1,\"userType\":0}";
1051 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, createParams);
1052 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1053 }
1054
1055 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest110, TestSize.Level0)
1056 {
1057 const DeviceGroupManager *gm = GetGmInstance();
1058 ASSERT_NE(gm, nullptr);
1059 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1060 ASSERT_EQ(ret, HC_SUCCESS);
1061 const char *createParams = "{\"groupName\":\"TestGroup\",\"deviceId\":\"TestAuthId\",\"groupType\":256,\"group"
1062 "Visibility\":-1,\"userType\":0,\"expireTime\":-1}";
1063 int32_t invalidOsAccountId = -3;
1064 CreateDemoGroup(invalidOsAccountId, TEST_REQ_ID, TEST_APP_ID, createParams);
1065 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1066 }
1067
1068 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest111, TestSize.Level0)
1069 {
1070 const DeviceGroupManager *gm = GetGmInstance();
1071 ASSERT_NE(gm, nullptr);
1072 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1073 ASSERT_EQ(ret, HC_SUCCESS);
1074 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
1075 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1076 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
1077 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
1078 }
1079
1080 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest112, TestSize.Level0)
1081 {
1082 const DeviceGroupManager *gm = GetGmInstance();
1083 ASSERT_NE(gm, nullptr);
1084 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1085 ASSERT_EQ(ret, HC_SUCCESS);
1086 const char *createParams = "{\"groupName\":\"TestGroup\",\"deviceId\":\"TestAuthId\",\"groupType\":333,\"group"
1087 "Visibility\":-1,\"userType\":0,\"expireTime\":-1}";
1088 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, createParams);
1089 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
1090 }
1091
1092 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest113, TestSize.Level0)
1093 {
1094 const DeviceGroupManager *gm = GetGmInstance();
1095 ASSERT_NE(gm, nullptr);
1096 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1097 ASSERT_EQ(ret, HC_SUCCESS);
1098 const char *createParams = "{\"groupName\":\"TestGroup\",\"deviceId\":\"TestAuthId\",\"groupType\":256,\"group"
1099 "Visibility\":-3,\"userType\":0,\"expireTime\":-1}";
1100 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, createParams);
1101 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
1102 }
1103
1104 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest114, TestSize.Level0)
1105 {
1106 const DeviceGroupManager *gm = GetGmInstance();
1107 ASSERT_NE(gm, nullptr);
1108 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1109 ASSERT_EQ(ret, HC_SUCCESS);
1110 const char *createParams = "{\"groupName\":\"TestGroup\",\"deviceId\":\"TestAuthId\",\"groupType\":256,\"group"
1111 "Visibility\":-1,\"userType\":-1,\"expireTime\":-1}";
1112 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, createParams);
1113 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
1114 }
1115
1116 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest115, TestSize.Level0)
1117 {
1118 const DeviceGroupManager *gm = GetGmInstance();
1119 ASSERT_NE(gm, nullptr);
1120 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1121 ASSERT_EQ(ret, HC_SUCCESS);
1122 const char *createParams = "{\"groupName\":\"TestGroup\",\"deviceId\":\"TestAuthId\",\"groupType\":256,\"group"
1123 "Visibility\":-1,\"userType\":0,\"expireTime\":-3}";
1124 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, createParams);
1125 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
1126 }
1127
1128 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest116, TestSize.Level0)
1129 {
1130 const DeviceGroupManager *gm = GetGmInstance();
1131 ASSERT_NE(gm, nullptr);
1132 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1133 ASSERT_EQ(ret, HC_SUCCESS);
1134 CreateDemoAcrossAccountGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams3);
1135 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_ERROR);
1136 }
1137
1138 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest117, TestSize.Level0)
1139 {
1140 const DeviceGroupManager *gm = GetGmInstance();
1141 ASSERT_NE(gm, nullptr);
1142 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1143 ASSERT_EQ(ret, HC_SUCCESS);
1144 CreateDemoIdenticalAccountGroup();
1145 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1146 const char *createParams = "{\"groupType\":1282,\"userId\":\"1234ABCD\",\"peerUserId\":\"0CBA4321\"}";
1147 CreateDemoAcrossAccountGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, createParams);
1148 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1149 }
1150
1151 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest118, TestSize.Level0)
1152 {
1153 const DeviceGroupManager *gm = GetGmInstance();
1154 ASSERT_NE(gm, nullptr);
1155 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1156 ASSERT_EQ(ret, HC_SUCCESS);
1157 CreateDemoIdenticalAccountGroup();
1158 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1159 const char *createParams = "{\"groupType\":1282,\"peerUserId\":\"0CBA4321\"}";
1160 CreateDemoAcrossAccountGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, createParams);
1161 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
1162 }
1163
1164 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest119, TestSize.Level0)
1165 {
1166 const DeviceGroupManager *gm = GetGmInstance();
1167 ASSERT_NE(gm, nullptr);
1168 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1169 ASSERT_EQ(ret, HC_SUCCESS);
1170 CreateDemoIdenticalAccountGroup();
1171 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1172 const char *createParams = "{\"groupType\":1282,\"userId\":\"1234ABCD\"}";
1173 CreateDemoAcrossAccountGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, createParams);
1174 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
1175 }
1176
1177 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest120, TestSize.Level0)
1178 {
1179 const DeviceGroupManager *gm = GetGmInstance();
1180 ASSERT_NE(gm, nullptr);
1181 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1182 ASSERT_EQ(ret, HC_SUCCESS);
1183 CreateDemoIdenticalAccountGroup();
1184 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1185 const char *createParams = "{\"groupType\":1282,\"userId\":\"1234ABCE\",\"peerUserId\":\"DCBA4321\"}";
1186 CreateDemoAcrossAccountGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, createParams);
1187 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
1188 }
1189
1190 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest121, TestSize.Level0)
1191 {
1192 const DeviceGroupManager *gm = GetGmInstance();
1193 ASSERT_NE(gm, nullptr);
1194 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1195 ASSERT_EQ(ret, HC_SUCCESS);
1196 CreateDemoIdenticalAccountGroup();
1197 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1198 const char *createParams = "{\"groupType\":1282,\"userId\":\"1234ABCD\",\"peerUserId\":\"1234ABCD\"}";
1199 CreateDemoAcrossAccountGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, createParams);
1200 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
1201 }
1202
1203 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest122, TestSize.Level0)
1204 {
1205 const DeviceGroupManager *gm = GetGmInstance();
1206 ASSERT_NE(gm, nullptr);
1207 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1208 ASSERT_EQ(ret, HC_SUCCESS);
1209 CreateDemoIdenticalAccountGroup();
1210 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1211 const char *createParams = "{\"groupType\":1282,\"userId\":\"1234ABCD\",\"peerUserId\":\"DCBA4321\",\"group"
1212 "Visibility\":-3,\"userType\":0,\"expireTime\":-1}";
1213 CreateDemoAcrossAccountGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, createParams);
1214 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
1215 }
1216
1217 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest123, TestSize.Level0)
1218 {
1219 const DeviceGroupManager *gm = GetGmInstance();
1220 ASSERT_NE(gm, nullptr);
1221 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1222 ASSERT_EQ(ret, HC_SUCCESS);
1223 CreateDemoIdenticalAccountGroup();
1224 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1225 const char *createParams = "{\"groupType\":1282,\"userId\":\"1234ABCD\",\"peerUserId\":\"DCBA4321\",\"group"
1226 "Visibility\":-1,\"userType\":-3,\"expireTime\":-1}";
1227 CreateDemoAcrossAccountGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, createParams);
1228 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
1229 }
1230
1231 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest124, TestSize.Level0)
1232 {
1233 const DeviceGroupManager *gm = GetGmInstance();
1234 ASSERT_NE(gm, nullptr);
1235 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1236 ASSERT_EQ(ret, HC_SUCCESS);
1237 CreateDemoIdenticalAccountGroup();
1238 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1239 const char *createParams = "{\"groupType\":1282,\"userId\":\"1234ABCD\",\"peerUserId\":\"DCBA4321\",\"group"
1240 "Visibility\":-1,\"userType\":0,\"expireTime\":-3}";
1241 CreateDemoAcrossAccountGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, createParams);
1242 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
1243 }
1244
1245 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest125, TestSize.Level0)
1246 {
1247 const DeviceGroupManager *gm = GetGmInstance();
1248 ASSERT_NE(gm, nullptr);
1249 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1250 ASSERT_EQ(ret, HC_SUCCESS);
1251 CreateDemoIdenticalAccountGroup();
1252 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1253 CreateDemoIdenticalAccountGroup();
1254 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
1255 }
1256
1257 HWTEST_F(GmCreateGroupTest, GmCreateGroupTest126, TestSize.Level0)
1258 {
1259 const DeviceGroupManager *gm = GetGmInstance();
1260 ASSERT_NE(gm, nullptr);
1261 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1262 ASSERT_EQ(ret, HC_SUCCESS);
1263 CreateDemoIdenticalAccountGroup();
1264 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1265 CreateDemoAcrossAccountGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams3);
1266 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1267 CreateDemoAcrossAccountGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams3);
1268 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
1269 }
1270
1271 class GmCheckAccessToGroupTest : public testing::Test {
1272 public:
1273 static void SetUpTestCase();
1274 static void TearDownTestCase();
1275 void SetUp();
1276 void TearDown();
1277 };
1278
SetUpTestCase()1279 void GmCheckAccessToGroupTest::SetUpTestCase()
1280 {
1281 DeleteDatabase();
1282 int ret = InitDeviceAuthService();
1283 ASSERT_EQ(ret, HC_SUCCESS);
1284 const DeviceGroupManager *gm = GetGmInstance();
1285 ASSERT_NE(gm, nullptr);
1286 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1287 ASSERT_EQ(ret, HC_SUCCESS);
1288 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
1289 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1290 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams2);
1291 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1292 CreateDemoIdenticalAccountGroup();
1293 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1294 }
1295
TearDownTestCase()1296 void GmCheckAccessToGroupTest::TearDownTestCase()
1297 {
1298 DestroyDeviceAuthService();
1299 }
1300
SetUp()1301 void GmCheckAccessToGroupTest::SetUp() {}
1302
TearDown()1303 void GmCheckAccessToGroupTest::TearDown() {}
1304
1305 HWTEST_F(GmCheckAccessToGroupTest, GmCheckAccessToGroupTest001, TestSize.Level0)
1306 {
1307 const DeviceGroupManager *gm = GetGmInstance();
1308 ASSERT_NE(gm, nullptr);
1309 int32_t ret = gm->checkAccessToGroup(DEFAULT_OS_ACCOUNT, nullptr, TEST_GROUP_ID);
1310 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1311 }
1312
1313 HWTEST_F(GmCheckAccessToGroupTest, GmCheckAccessToGroupTest002, TestSize.Level0)
1314 {
1315 const DeviceGroupManager *gm = GetGmInstance();
1316 ASSERT_NE(gm, nullptr);
1317 int32_t ret = gm->checkAccessToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, nullptr);
1318 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1319 }
1320
1321 HWTEST_F(GmCheckAccessToGroupTest, GmCheckAccessToGroupTest003, TestSize.Level0)
1322 {
1323 const DeviceGroupManager *gm = GetGmInstance();
1324 ASSERT_NE(gm, nullptr);
1325 int32_t ret = gm->checkAccessToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID);
1326 ASSERT_EQ(ret, HC_SUCCESS);
1327 }
1328
1329 HWTEST_F(GmCheckAccessToGroupTest, GmCheckAccessToGroupTest004, TestSize.Level0)
1330 {
1331 const DeviceGroupManager *gm = GetGmInstance();
1332 ASSERT_NE(gm, nullptr);
1333 int32_t ret = gm->checkAccessToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID2, TEST_GROUP_ID2);
1334 ASSERT_NE(ret, HC_SUCCESS);
1335 }
1336
1337 HWTEST_F(GmCheckAccessToGroupTest, GmCheckAccessToGroupTest005, TestSize.Level0)
1338 {
1339 const DeviceGroupManager *gm = GetGmInstance();
1340 ASSERT_NE(gm, nullptr);
1341 int32_t ret = gm->checkAccessToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID4);
1342 ASSERT_NE(ret, HC_SUCCESS);
1343 }
1344
1345 class GmGetPkInfoListTest : public testing::Test {
1346 public:
1347 static void SetUpTestCase();
1348 static void TearDownTestCase();
1349 void SetUp();
1350 void TearDown();
1351 };
1352
SetUpTestCase()1353 void GmGetPkInfoListTest::SetUpTestCase() {}
TearDownTestCase()1354 void GmGetPkInfoListTest::TearDownTestCase() {}
1355
SetUp()1356 void GmGetPkInfoListTest::SetUp()
1357 {
1358 int ret = InitDeviceAuthService();
1359 EXPECT_EQ(ret, HC_SUCCESS);
1360 }
1361
TearDown()1362 void GmGetPkInfoListTest::TearDown()
1363 {
1364 DestroyDeviceAuthService();
1365 }
1366
1367 HWTEST_F(GmGetPkInfoListTest, GmGetPkInfoListTest001, TestSize.Level0)
1368 {
1369 const DeviceGroupManager *gm = GetGmInstance();
1370 ASSERT_NE(gm, nullptr);
1371 char *returnData = nullptr;
1372 uint32_t returnNum = 0;
1373 int32_t ret = gm->getPkInfoList(DEFAULT_OS_ACCOUNT, nullptr, TEST_QUERY_PARAMS, &returnData, &returnNum);
1374 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1375 }
1376
1377 HWTEST_F(GmGetPkInfoListTest, GmGetPkInfoListTest002, TestSize.Level0)
1378 {
1379 const DeviceGroupManager *gm = GetGmInstance();
1380 ASSERT_NE(gm, nullptr);
1381 char *returnData = nullptr;
1382 uint32_t returnNum = 0;
1383 int32_t ret = gm->getPkInfoList(DEFAULT_OS_ACCOUNT, TEST_APP_ID, nullptr, &returnData, &returnNum);
1384 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1385 }
1386
1387 HWTEST_F(GmGetPkInfoListTest, GmGetPkInfoListTest003, TestSize.Level0)
1388 {
1389 const DeviceGroupManager *gm = GetGmInstance();
1390 ASSERT_NE(gm, nullptr);
1391 uint32_t returnNum = 0;
1392 int32_t ret = gm->getPkInfoList(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_QUERY_PARAMS, nullptr, &returnNum);
1393 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1394 }
1395
1396 HWTEST_F(GmGetPkInfoListTest, GmGetPkInfoListTest004, TestSize.Level0)
1397 {
1398 const DeviceGroupManager *gm = GetGmInstance();
1399 ASSERT_NE(gm, nullptr);
1400 char *returnData = nullptr;
1401 int32_t ret = gm->getPkInfoList(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_QUERY_PARAMS, &returnData, nullptr);
1402 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1403 }
1404
1405 HWTEST_F(GmGetPkInfoListTest, GmGetPkInfoListTest005, TestSize.Level0)
1406 {
1407 const DeviceGroupManager *gm = GetGmInstance();
1408 EXPECT_NE(gm, nullptr);
1409 char *returnData = nullptr;
1410 uint32_t returnNum = 0;
1411 const char *queryParams = "{\"isSelfPk\":true}";
1412 int32_t ret = gm->getPkInfoList(DEFAULT_OS_ACCOUNT, TEST_APP_ID, queryParams, &returnData, &returnNum);
1413 ASSERT_NE(ret, HC_SUCCESS);
1414 }
1415
1416 HWTEST_F(GmGetPkInfoListTest, GmGetPkInfoListTest006, TestSize.Level0)
1417 {
1418 const DeviceGroupManager *gm = GetGmInstance();
1419 EXPECT_NE(gm, nullptr);
1420 char *returnData = nullptr;
1421 uint32_t returnNum = 0;
1422 const char *queryParams = "{\"udid\":\"ABCD\"}";
1423 int32_t ret = gm->getPkInfoList(DEFAULT_OS_ACCOUNT, TEST_APP_ID, queryParams, &returnData, &returnNum);
1424 ASSERT_NE(ret, HC_SUCCESS);
1425 }
1426
1427 HWTEST_F(GmGetPkInfoListTest, GmGetPkInfoListTest007, TestSize.Level0)
1428 {
1429 const DeviceGroupManager *gm = GetGmInstance();
1430 EXPECT_NE(gm, nullptr);
1431 char *returnData = nullptr;
1432 uint32_t returnNum = 0;
1433 const char *queryParams = "{\"udid\":\"5420459D93FE773F9945FD64277FBA2CAB8FB996DDC1D0B97676FBB1242"
1434 "B3930\",\"isSelfPk\":true}";
1435 int32_t ret = gm->getPkInfoList(DEFAULT_OS_ACCOUNT, TEST_APP_ID, queryParams, &returnData, &returnNum);
1436 ASSERT_EQ(ret, HC_SUCCESS);
1437 ASSERT_NE(returnData, nullptr);
1438 ASSERT_NE(returnNum, 0);
1439 gm->destroyInfo(&returnData);
1440 }
1441
1442 HWTEST_F(GmGetPkInfoListTest, GmGetPkInfoListTest008, TestSize.Level0)
1443 {
1444 const DeviceGroupManager *gm = GetGmInstance();
1445 EXPECT_NE(gm, nullptr);
1446 char *returnData = nullptr;
1447 uint32_t returnNum = 0;
1448 const char *queryParams = "{\"udid\":\"ABCD\",\"isSelfPk\":true}";
1449 int32_t ret = gm->getPkInfoList(DEFAULT_OS_ACCOUNT, TEST_APP_ID, queryParams, &returnData, &returnNum);
1450 ASSERT_EQ(ret, HC_SUCCESS);
1451 ASSERT_NE(returnData, nullptr);
1452 gm->destroyInfo(&returnData);
1453 }
1454
1455 HWTEST_F(GmGetPkInfoListTest, GmGetPkInfoListTest009, TestSize.Level0)
1456 {
1457 const DeviceGroupManager *gm = GetGmInstance();
1458 EXPECT_NE(gm, nullptr);
1459 char *returnData = nullptr;
1460 uint32_t returnNum = 0;
1461 const char *queryParams = "{\"udid\":\"5420459D93FE773F9945FD64277FBA2CAB8FB996DDC1D0B97676FBB1242"
1462 "B3930\",\"isSelfPk\":false}";
1463 int32_t ret = gm->getPkInfoList(DEFAULT_OS_ACCOUNT, TEST_APP_ID, queryParams, &returnData, &returnNum);
1464 ASSERT_EQ(ret, HC_SUCCESS);
1465 ASSERT_NE(returnData, nullptr);
1466 gm->destroyInfo(&returnData);
1467 }
1468
1469 HWTEST_F(GmGetPkInfoListTest, GmGetPkInfoListTest010, TestSize.Level0)
1470 {
1471 const DeviceGroupManager *gm = GetGmInstance();
1472 EXPECT_NE(gm, nullptr);
1473 char *returnData = nullptr;
1474 uint32_t returnNum = 0;
1475 const char *queryParams = "{\"udid\":\"ABCD\",\"isSelfPk\":false}";
1476 int32_t ret = gm->getPkInfoList(DEFAULT_OS_ACCOUNT, TEST_APP_ID, queryParams, &returnData, &returnNum);
1477 ASSERT_EQ(ret, HC_SUCCESS);
1478 ASSERT_NE(returnData, nullptr);
1479 gm->destroyInfo(&returnData);
1480 }
1481
1482 class GmGetGroupInfoByIdTest : public testing::Test {
1483 public:
1484 static void SetUpTestCase();
1485 static void TearDownTestCase();
1486 void SetUp();
1487 void TearDown();
1488 };
1489
SetUpTestCase()1490 void GmGetGroupInfoByIdTest::SetUpTestCase() {}
TearDownTestCase()1491 void GmGetGroupInfoByIdTest::TearDownTestCase() {}
1492
SetUp()1493 void GmGetGroupInfoByIdTest::SetUp()
1494 {
1495 int ret = InitDeviceAuthService();
1496 EXPECT_EQ(ret, HC_SUCCESS);
1497 }
1498
TearDown()1499 void GmGetGroupInfoByIdTest::TearDown()
1500 {
1501 DestroyDeviceAuthService();
1502 }
1503
1504 HWTEST_F(GmGetGroupInfoByIdTest, GmGetGroupInfoByIdTest001, TestSize.Level0)
1505 {
1506 const DeviceGroupManager *gm = GetGmInstance();
1507 ASSERT_NE(gm, nullptr);
1508 char *returnData = nullptr;
1509 int32_t ret = gm->getGroupInfoById(DEFAULT_OS_ACCOUNT, nullptr, TEST_GROUP_ID, &returnData);
1510 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1511 }
1512
1513 HWTEST_F(GmGetGroupInfoByIdTest, GmGetGroupInfoByIdTest002, TestSize.Level0)
1514 {
1515 const DeviceGroupManager *gm = GetGmInstance();
1516 ASSERT_NE(gm, nullptr);
1517 char *returnData = nullptr;
1518 int32_t ret = gm->getGroupInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID, nullptr, &returnData);
1519 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1520 }
1521
1522 HWTEST_F(GmGetGroupInfoByIdTest, GmGetGroupInfoByIdTest003, TestSize.Level0)
1523 {
1524 const DeviceGroupManager *gm = GetGmInstance();
1525 ASSERT_NE(gm, nullptr);
1526 int32_t ret = gm->getGroupInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID, nullptr);
1527 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1528 }
1529
1530 HWTEST_F(GmGetGroupInfoByIdTest, GmGetGroupInfoByIdTest004, TestSize.Level0)
1531 {
1532 const DeviceGroupManager *gm = GetGmInstance();
1533 ASSERT_NE(gm, nullptr);
1534 char *returnData = nullptr;
1535 int32_t ret = gm->getGroupInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID, &returnData);
1536 ASSERT_EQ(ret, HC_SUCCESS);
1537 ASSERT_NE(returnData, nullptr);
1538 gm->destroyInfo(&returnData);
1539 }
1540
1541 HWTEST_F(GmGetGroupInfoByIdTest, GmGetGroupInfoByIdTest005, TestSize.Level0)
1542 {
1543 const DeviceGroupManager *gm = GetGmInstance();
1544 ASSERT_NE(gm, nullptr);
1545 char *returnData = nullptr;
1546 int32_t ret = gm->getGroupInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID2, TEST_GROUP_ID2, &returnData);
1547 ASSERT_NE(ret, HC_SUCCESS);
1548 }
1549
1550 HWTEST_F(GmGetGroupInfoByIdTest, GmGetGroupInfoByIdTest006, TestSize.Level0)
1551 {
1552 const DeviceGroupManager *gm = GetGmInstance();
1553 ASSERT_NE(gm, nullptr);
1554 char *returnData = nullptr;
1555 int32_t ret = gm->getGroupInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID4, &returnData);
1556 ASSERT_NE(ret, HC_SUCCESS);
1557 }
1558
1559 class GmGetGroupInfoTest : public testing::Test {
1560 public:
1561 static void SetUpTestCase();
1562 static void TearDownTestCase();
1563 void SetUp();
1564 void TearDown();
1565 };
1566
SetUpTestCase()1567 void GmGetGroupInfoTest::SetUpTestCase() {}
TearDownTestCase()1568 void GmGetGroupInfoTest::TearDownTestCase() {}
1569
SetUp()1570 void GmGetGroupInfoTest::SetUp()
1571 {
1572 int ret = InitDeviceAuthService();
1573 EXPECT_EQ(ret, HC_SUCCESS);
1574 }
1575
TearDown()1576 void GmGetGroupInfoTest::TearDown()
1577 {
1578 DestroyDeviceAuthService();
1579 }
1580
1581 HWTEST_F(GmGetGroupInfoTest, GmGetGroupInfoTest001, TestSize.Level0)
1582 {
1583 const DeviceGroupManager *gm = GetGmInstance();
1584 ASSERT_NE(gm, nullptr);
1585 char *returnData = nullptr;
1586 uint32_t returnNum = 0;
1587 int32_t ret = gm->getGroupInfo(DEFAULT_OS_ACCOUNT, nullptr, TEST_QUERY_PARAMS, &returnData, &returnNum);
1588 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1589 }
1590
1591 HWTEST_F(GmGetGroupInfoTest, GmGetGroupInfoTest002, TestSize.Level0)
1592 {
1593 const DeviceGroupManager *gm = GetGmInstance();
1594 ASSERT_NE(gm, nullptr);
1595 char *returnData = nullptr;
1596 uint32_t returnNum = 0;
1597 int32_t ret = gm->getGroupInfo(DEFAULT_OS_ACCOUNT, TEST_APP_ID, nullptr, &returnData, &returnNum);
1598 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1599 }
1600
1601 HWTEST_F(GmGetGroupInfoTest, GmGetGroupInfoTest003, TestSize.Level0)
1602 {
1603 const DeviceGroupManager *gm = GetGmInstance();
1604 ASSERT_NE(gm, nullptr);
1605 uint32_t returnNum = 0;
1606 int32_t ret = gm->getGroupInfo(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_QUERY_PARAMS, nullptr, &returnNum);
1607 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1608 }
1609
1610 HWTEST_F(GmGetGroupInfoTest, GmGetGroupInfoTest004, TestSize.Level0)
1611 {
1612 const DeviceGroupManager *gm = GetGmInstance();
1613 ASSERT_NE(gm, nullptr);
1614 char *returnData = nullptr;
1615 int32_t ret = gm->getGroupInfo(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_QUERY_PARAMS, &returnData, nullptr);
1616 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1617 }
1618
1619 HWTEST_F(GmGetGroupInfoTest, GmGetGroupInfoTest005, TestSize.Level0)
1620 {
1621 const DeviceGroupManager *gm = GetGmInstance();
1622 ASSERT_NE(gm, nullptr);
1623 char *returnData = nullptr;
1624 uint32_t returnNum = 0;
1625 const char *queryParams = "{\"groupOwner\":\"TestAppId\"}";
1626 int32_t ret = gm->getGroupInfo(DEFAULT_OS_ACCOUNT, TEST_APP_ID, queryParams, &returnData, &returnNum);
1627 ASSERT_EQ(ret, HC_SUCCESS);
1628 ASSERT_NE(returnData, nullptr);
1629 gm->destroyInfo(&returnData);
1630 }
1631
1632 HWTEST_F(GmGetGroupInfoTest, GmGetGroupInfoTest006, TestSize.Level0)
1633 {
1634 const DeviceGroupManager *gm = GetGmInstance();
1635 ASSERT_NE(gm, nullptr);
1636 char *returnData = nullptr;
1637 uint32_t returnNum = 0;
1638 const char *queryParams = "{\"groupOwner\":\"TestAppId2\"}";
1639 int32_t ret = gm->getGroupInfo(DEFAULT_OS_ACCOUNT, TEST_APP_ID, queryParams, &returnData, &returnNum);
1640 ASSERT_EQ(ret, HC_SUCCESS);
1641 ASSERT_NE(returnData, nullptr);
1642 gm->destroyInfo(&returnData);
1643 }
1644
1645 HWTEST_F(GmGetGroupInfoTest, GmGetGroupInfoTest007, TestSize.Level0)
1646 {
1647 const DeviceGroupManager *gm = GetGmInstance();
1648 ASSERT_NE(gm, nullptr);
1649 char *returnData = nullptr;
1650 uint32_t returnNum = 0;
1651 const char *queryParams = "{\"groupType\":0}";
1652 int32_t ret = gm->getGroupInfo(DEFAULT_OS_ACCOUNT, TEST_APP_ID, queryParams, &returnData, &returnNum);
1653 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1654 }
1655
1656 HWTEST_F(GmGetGroupInfoTest, GmGetGroupInfoTest008, TestSize.Level0)
1657 {
1658 const DeviceGroupManager *gm = GetGmInstance();
1659 ASSERT_NE(gm, nullptr);
1660 char *returnData = nullptr;
1661 uint32_t returnNum = 0;
1662 const char *queryParams = "{\"groupType\":123456}";
1663 int32_t ret = gm->getGroupInfo(DEFAULT_OS_ACCOUNT, TEST_APP_ID, queryParams, &returnData, &returnNum);
1664 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1665 }
1666
1667 class GmGetJoinedGroupsTest : public testing::Test {
1668 public:
1669 static void SetUpTestCase();
1670 static void TearDownTestCase();
1671 void SetUp();
1672 void TearDown();
1673 };
1674
SetUpTestCase()1675 void GmGetJoinedGroupsTest::SetUpTestCase() {}
TearDownTestCase()1676 void GmGetJoinedGroupsTest::TearDownTestCase() {}
1677
SetUp()1678 void GmGetJoinedGroupsTest::SetUp()
1679 {
1680 int ret = InitDeviceAuthService();
1681 EXPECT_EQ(ret, HC_SUCCESS);
1682 }
1683
TearDown()1684 void GmGetJoinedGroupsTest::TearDown()
1685 {
1686 DestroyDeviceAuthService();
1687 }
1688
1689 HWTEST_F(GmGetJoinedGroupsTest, GmGetJoinedGroupsTest001, TestSize.Level0)
1690 {
1691 const DeviceGroupManager *gm = GetGmInstance();
1692 ASSERT_NE(gm, nullptr);
1693 char *returnData = nullptr;
1694 uint32_t returnNum = 0;
1695 int32_t ret = gm->getJoinedGroups(DEFAULT_OS_ACCOUNT, nullptr, PEER_TO_PEER_GROUP, &returnData, &returnNum);
1696 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1697 }
1698
1699 HWTEST_F(GmGetJoinedGroupsTest, GmGetJoinedGroupsTest002, TestSize.Level0)
1700 {
1701 const DeviceGroupManager *gm = GetGmInstance();
1702 ASSERT_NE(gm, nullptr);
1703 uint32_t returnNum = 0;
1704 int32_t ret = gm->getJoinedGroups(DEFAULT_OS_ACCOUNT, TEST_APP_ID, PEER_TO_PEER_GROUP, nullptr, &returnNum);
1705 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1706 }
1707
1708 HWTEST_F(GmGetJoinedGroupsTest, GmGetJoinedGroupsTest003, TestSize.Level0)
1709 {
1710 const DeviceGroupManager *gm = GetGmInstance();
1711 ASSERT_NE(gm, nullptr);
1712 char *returnData = nullptr;
1713 int32_t ret = gm->getJoinedGroups(DEFAULT_OS_ACCOUNT, nullptr, PEER_TO_PEER_GROUP, &returnData, nullptr);
1714 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1715 }
1716
1717 HWTEST_F(GmGetJoinedGroupsTest, GmGetJoinedGroupsTest004, TestSize.Level0)
1718 {
1719 const DeviceGroupManager *gm = GetGmInstance();
1720 ASSERT_NE(gm, nullptr);
1721 char *returnData = nullptr;
1722 uint32_t returnNum = 0;
1723 int32_t ret = gm->getJoinedGroups(DEFAULT_OS_ACCOUNT, TEST_APP_ID, GROUP_TYPE_INVALID, &returnData, &returnNum);
1724 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1725 }
1726
1727 HWTEST_F(GmGetJoinedGroupsTest, GmGetJoinedGroupsTest005, TestSize.Level0)
1728 {
1729 const DeviceGroupManager *gm = GetGmInstance();
1730 ASSERT_NE(gm, nullptr);
1731 char *returnData = nullptr;
1732 uint32_t returnNum = 0;
1733 int32_t ret = gm->getJoinedGroups(DEFAULT_OS_ACCOUNT, TEST_APP_ID, PEER_TO_PEER_GROUP, &returnData, &returnNum);
1734 ASSERT_EQ(ret, HC_SUCCESS);
1735 ASSERT_NE(returnData, nullptr);
1736 ASSERT_NE(returnNum, 0);
1737 gm->destroyInfo(&returnData);
1738 }
1739
1740 HWTEST_F(GmGetJoinedGroupsTest, GmGetJoinedGroupsTest006, TestSize.Level0)
1741 {
1742 const DeviceGroupManager *gm = GetGmInstance();
1743 ASSERT_NE(gm, nullptr);
1744 char *returnData = nullptr;
1745 uint32_t returnNum = 0;
1746 int32_t ret = gm->getJoinedGroups(DEFAULT_OS_ACCOUNT, TEST_APP_ID2, PEER_TO_PEER_GROUP, &returnData, &returnNum);
1747 ASSERT_EQ(ret, HC_SUCCESS);
1748 ASSERT_NE(returnData, nullptr);
1749 gm->destroyInfo(&returnData);
1750 }
1751
1752 class GmGetRelatedGroupsTest : public testing::Test {
1753 public:
1754 static void SetUpTestCase();
1755 static void TearDownTestCase();
1756 void SetUp();
1757 void TearDown();
1758 };
1759
SetUpTestCase()1760 void GmGetRelatedGroupsTest::SetUpTestCase() {}
TearDownTestCase()1761 void GmGetRelatedGroupsTest::TearDownTestCase() {}
1762
SetUp()1763 void GmGetRelatedGroupsTest::SetUp()
1764 {
1765 int ret = InitDeviceAuthService();
1766 EXPECT_EQ(ret, HC_SUCCESS);
1767 }
1768
TearDown()1769 void GmGetRelatedGroupsTest::TearDown()
1770 {
1771 DestroyDeviceAuthService();
1772 }
1773
1774 HWTEST_F(GmGetRelatedGroupsTest, GmGetRelatedGroupsTest001, TestSize.Level0)
1775 {
1776 const DeviceGroupManager *gm = GetGmInstance();
1777 ASSERT_NE(gm, nullptr);
1778 char *returnData = nullptr;
1779 uint32_t returnNum = 0;
1780 int32_t ret = gm->getRelatedGroups(DEFAULT_OS_ACCOUNT, nullptr, TEST_AUTH_ID, &returnData, &returnNum);
1781 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1782 }
1783
1784 HWTEST_F(GmGetRelatedGroupsTest, GmGetRelatedGroupsTest002, TestSize.Level0)
1785 {
1786 const DeviceGroupManager *gm = GetGmInstance();
1787 ASSERT_NE(gm, nullptr);
1788 char *returnData = nullptr;
1789 uint32_t returnNum = 0;
1790 int32_t ret = gm->getRelatedGroups(DEFAULT_OS_ACCOUNT, TEST_APP_ID, nullptr, &returnData, &returnNum);
1791 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1792 }
1793
1794 HWTEST_F(GmGetRelatedGroupsTest, GmGetRelatedGroupsTest003, TestSize.Level0)
1795 {
1796 const DeviceGroupManager *gm = GetGmInstance();
1797 ASSERT_NE(gm, nullptr);
1798 uint32_t returnNum = 0;
1799 int32_t ret = gm->getRelatedGroups(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_AUTH_ID, nullptr, &returnNum);
1800 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1801 }
1802
1803 HWTEST_F(GmGetRelatedGroupsTest, GmGetRelatedGroupsTest004, TestSize.Level0)
1804 {
1805 const DeviceGroupManager *gm = GetGmInstance();
1806 ASSERT_NE(gm, nullptr);
1807 char *returnData = nullptr;
1808 int32_t ret = gm->getRelatedGroups(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_AUTH_ID, &returnData, nullptr);
1809 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1810 }
1811
1812 HWTEST_F(GmGetRelatedGroupsTest, GmGetRelatedGroupsTest005, TestSize.Level0)
1813 {
1814 const DeviceGroupManager *gm = GetGmInstance();
1815 ASSERT_NE(gm, nullptr);
1816 char *returnData = nullptr;
1817 uint32_t returnNum = 0;
1818 int32_t ret = gm->getRelatedGroups(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_AUTH_ID, &returnData, &returnNum);
1819 ASSERT_EQ(ret, HC_SUCCESS);
1820 ASSERT_NE(returnData, nullptr);
1821 ASSERT_NE(returnNum, 0);
1822 gm->destroyInfo(&returnData);
1823 }
1824
1825 HWTEST_F(GmGetRelatedGroupsTest, GmGetRelatedGroupsTest006, TestSize.Level0)
1826 {
1827 const DeviceGroupManager *gm = GetGmInstance();
1828 ASSERT_NE(gm, nullptr);
1829 char *returnData = nullptr;
1830 uint32_t returnNum = 0;
1831 int32_t ret = gm->getRelatedGroups(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_AUTH_ID2, &returnData, &returnNum);
1832 ASSERT_EQ(ret, HC_SUCCESS);
1833 ASSERT_NE(returnData, nullptr);
1834 gm->destroyInfo(&returnData);
1835 }
1836
1837 class GmGetDeviceInfoByIdTest : public testing::Test {
1838 public:
1839 static void SetUpTestCase();
1840 static void TearDownTestCase();
1841 void SetUp();
1842 void TearDown();
1843 };
1844
SetUpTestCase()1845 void GmGetDeviceInfoByIdTest::SetUpTestCase() {}
TearDownTestCase()1846 void GmGetDeviceInfoByIdTest::TearDownTestCase() {}
1847
SetUp()1848 void GmGetDeviceInfoByIdTest::SetUp()
1849 {
1850 int ret = InitDeviceAuthService();
1851 EXPECT_EQ(ret, HC_SUCCESS);
1852 }
1853
TearDown()1854 void GmGetDeviceInfoByIdTest::TearDown()
1855 {
1856 DestroyDeviceAuthService();
1857 }
1858
1859 HWTEST_F(GmGetDeviceInfoByIdTest, GmGetDeviceInfoByIdTest001, TestSize.Level0)
1860 {
1861 const DeviceGroupManager *gm = GetGmInstance();
1862 ASSERT_NE(gm, nullptr);
1863 char *returnData = nullptr;
1864 int32_t ret = gm->getDeviceInfoById(DEFAULT_OS_ACCOUNT, nullptr, TEST_AUTH_ID, TEST_GROUP_ID, &returnData);
1865 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1866 }
1867
1868 HWTEST_F(GmGetDeviceInfoByIdTest, GmGetDeviceInfoByIdTest002, TestSize.Level0)
1869 {
1870 const DeviceGroupManager *gm = GetGmInstance();
1871 ASSERT_NE(gm, nullptr);
1872 char *returnData = nullptr;
1873 int32_t ret = gm->getDeviceInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID, nullptr, TEST_GROUP_ID, &returnData);
1874 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1875 }
1876
1877 HWTEST_F(GmGetDeviceInfoByIdTest, GmGetDeviceInfoByIdTest003, TestSize.Level0)
1878 {
1879 const DeviceGroupManager *gm = GetGmInstance();
1880 ASSERT_NE(gm, nullptr);
1881 char *returnData = nullptr;
1882 int32_t ret = gm->getDeviceInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_AUTH_ID, nullptr, &returnData);
1883 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1884 }
1885
1886 HWTEST_F(GmGetDeviceInfoByIdTest, GmGetDeviceInfoByIdTest004, TestSize.Level0)
1887 {
1888 const DeviceGroupManager *gm = GetGmInstance();
1889 ASSERT_NE(gm, nullptr);
1890 int32_t ret = gm->getDeviceInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_AUTH_ID, TEST_GROUP_ID, nullptr);
1891 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1892 }
1893
1894 HWTEST_F(GmGetDeviceInfoByIdTest, GmGetDeviceInfoByIdTest005, TestSize.Level0)
1895 {
1896 const DeviceGroupManager *gm = GetGmInstance();
1897 ASSERT_NE(gm, nullptr);
1898 char *returnData = nullptr;
1899 int32_t ret = gm->getDeviceInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_AUTH_ID, TEST_GROUP_ID, &returnData);
1900 ASSERT_EQ(ret, HC_SUCCESS);
1901 ASSERT_NE(returnData, nullptr);
1902 gm->destroyInfo(&returnData);
1903 }
1904
1905 HWTEST_F(GmGetDeviceInfoByIdTest, GmGetDeviceInfoByIdTest006, TestSize.Level0)
1906 {
1907 const DeviceGroupManager *gm = GetGmInstance();
1908 ASSERT_NE(gm, nullptr);
1909 char *returnData = nullptr;
1910 int32_t ret = gm->getDeviceInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID2, TEST_AUTH_ID, TEST_GROUP_ID2, &returnData);
1911 ASSERT_NE(ret, HC_SUCCESS);
1912 }
1913
1914 HWTEST_F(GmGetDeviceInfoByIdTest, GmGetDeviceInfoByIdTest007, TestSize.Level0)
1915 {
1916 const DeviceGroupManager *gm = GetGmInstance();
1917 ASSERT_NE(gm, nullptr);
1918 char *returnData = nullptr;
1919 int32_t ret = gm->getDeviceInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_AUTH_ID, TEST_GROUP_ID4, &returnData);
1920 ASSERT_NE(ret, HC_SUCCESS);
1921 }
1922
1923 HWTEST_F(GmGetDeviceInfoByIdTest, GmGetDeviceInfoByIdTest008, TestSize.Level0)
1924 {
1925 const DeviceGroupManager *gm = GetGmInstance();
1926 ASSERT_NE(gm, nullptr);
1927 char *returnData = nullptr;
1928 int32_t ret = gm->getDeviceInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_AUTH_ID2, TEST_GROUP_ID, &returnData);
1929 ASSERT_NE(ret, HC_SUCCESS);
1930 }
1931
1932 class GmGetTrustedDevicesTest : public testing::Test {
1933 public:
1934 static void SetUpTestCase();
1935 static void TearDownTestCase();
1936 void SetUp();
1937 void TearDown();
1938 };
1939
SetUpTestCase()1940 void GmGetTrustedDevicesTest::SetUpTestCase() {}
TearDownTestCase()1941 void GmGetTrustedDevicesTest::TearDownTestCase() {}
1942
SetUp()1943 void GmGetTrustedDevicesTest::SetUp()
1944 {
1945 int ret = InitDeviceAuthService();
1946 EXPECT_EQ(ret, HC_SUCCESS);
1947 }
1948
TearDown()1949 void GmGetTrustedDevicesTest::TearDown()
1950 {
1951 DestroyDeviceAuthService();
1952 }
1953
1954 HWTEST_F(GmGetTrustedDevicesTest, GmGetTrustedDevicesTest001, TestSize.Level0)
1955 {
1956 const DeviceGroupManager *gm = GetGmInstance();
1957 ASSERT_NE(gm, nullptr);
1958 char *returnData = nullptr;
1959 uint32_t returnNum = 0;
1960 int32_t ret = gm->getTrustedDevices(DEFAULT_OS_ACCOUNT, nullptr, TEST_GROUP_ID, &returnData, &returnNum);
1961 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1962 }
1963
1964 HWTEST_F(GmGetTrustedDevicesTest, GmGetTrustedDevicesTest002, TestSize.Level0)
1965 {
1966 const DeviceGroupManager *gm = GetGmInstance();
1967 ASSERT_NE(gm, nullptr);
1968 char *returnData = nullptr;
1969 uint32_t returnNum = 0;
1970 int32_t ret = gm->getTrustedDevices(DEFAULT_OS_ACCOUNT, TEST_APP_ID, nullptr, &returnData, &returnNum);
1971 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1972 }
1973
1974 HWTEST_F(GmGetTrustedDevicesTest, GmGetTrustedDevicesTest003, TestSize.Level0)
1975 {
1976 const DeviceGroupManager *gm = GetGmInstance();
1977 ASSERT_NE(gm, nullptr);
1978 uint32_t returnNum = 0;
1979 int32_t ret = gm->getTrustedDevices(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID, nullptr, &returnNum);
1980 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1981 }
1982
1983 HWTEST_F(GmGetTrustedDevicesTest, GmGetTrustedDevicesTest004, TestSize.Level0)
1984 {
1985 const DeviceGroupManager *gm = GetGmInstance();
1986 ASSERT_NE(gm, nullptr);
1987 char *returnData = nullptr;
1988 int32_t ret = gm->getTrustedDevices(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID, &returnData, nullptr);
1989 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1990 }
1991
1992 HWTEST_F(GmGetTrustedDevicesTest, GmGetTrustedDevicesTest005, TestSize.Level0)
1993 {
1994 const DeviceGroupManager *gm = GetGmInstance();
1995 ASSERT_NE(gm, nullptr);
1996 char *returnData = nullptr;
1997 uint32_t returnNum = 0;
1998 int32_t ret = gm->getTrustedDevices(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID, &returnData, &returnNum);
1999 ASSERT_EQ(ret, HC_SUCCESS);
2000 ASSERT_NE(returnData, nullptr);
2001 ASSERT_NE(returnNum, 0);
2002 gm->destroyInfo(&returnData);
2003 }
2004
2005 HWTEST_F(GmGetTrustedDevicesTest, GmGetTrustedDevicesTest006, TestSize.Level0)
2006 {
2007 const DeviceGroupManager *gm = GetGmInstance();
2008 ASSERT_NE(gm, nullptr);
2009 char *returnData = nullptr;
2010 uint32_t returnNum = 0;
2011 int32_t ret = gm->getTrustedDevices(DEFAULT_OS_ACCOUNT, TEST_APP_ID2, TEST_GROUP_ID2, &returnData, &returnNum);
2012 ASSERT_NE(ret, HC_SUCCESS);
2013 }
2014
2015 HWTEST_F(GmGetTrustedDevicesTest, GmGetTrustedDevicesTest007, TestSize.Level0)
2016 {
2017 const DeviceGroupManager *gm = GetGmInstance();
2018 ASSERT_NE(gm, nullptr);
2019 char *returnData = nullptr;
2020 uint32_t returnNum = 0;
2021 int32_t ret = gm->getTrustedDevices(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID4, &returnData, &returnNum);
2022 ASSERT_NE(ret, HC_SUCCESS);
2023 }
2024
2025 class GmIsDeviceInGroupTest : public testing::Test {
2026 public:
2027 static void SetUpTestCase();
2028 static void TearDownTestCase();
2029 void SetUp();
2030 void TearDown();
2031 };
2032
SetUpTestCase()2033 void GmIsDeviceInGroupTest::SetUpTestCase() {}
TearDownTestCase()2034 void GmIsDeviceInGroupTest::TearDownTestCase() {}
2035
SetUp()2036 void GmIsDeviceInGroupTest::SetUp()
2037 {
2038 int ret = InitDeviceAuthService();
2039 EXPECT_EQ(ret, HC_SUCCESS);
2040 }
2041
TearDown()2042 void GmIsDeviceInGroupTest::TearDown()
2043 {
2044 DestroyDeviceAuthService();
2045 }
2046
2047 HWTEST_F(GmIsDeviceInGroupTest, GmIsDeviceInGroupTest001, TestSize.Level0)
2048 {
2049 const DeviceGroupManager *gm = GetGmInstance();
2050 ASSERT_NE(gm, nullptr);
2051 bool ret = gm->isDeviceInGroup(DEFAULT_OS_ACCOUNT, nullptr, TEST_GROUP_ID, TEST_AUTH_ID);
2052 ASSERT_EQ(ret, false);
2053 }
2054
2055 HWTEST_F(GmIsDeviceInGroupTest, GmIsDeviceInGroupTest002, TestSize.Level0)
2056 {
2057 const DeviceGroupManager *gm = GetGmInstance();
2058 ASSERT_NE(gm, nullptr);
2059 bool ret = gm->isDeviceInGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, nullptr, TEST_AUTH_ID);
2060 ASSERT_EQ(ret, false);
2061 }
2062
2063 HWTEST_F(GmIsDeviceInGroupTest, GmIsDeviceInGroupTest003, TestSize.Level0)
2064 {
2065 const DeviceGroupManager *gm = GetGmInstance();
2066 ASSERT_NE(gm, nullptr);
2067 bool ret = gm->isDeviceInGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID, nullptr);
2068 ASSERT_EQ(ret, false);
2069 }
2070
2071 HWTEST_F(GmIsDeviceInGroupTest, GmIsDeviceInGroupTest004, TestSize.Level0)
2072 {
2073 const DeviceGroupManager *gm = GetGmInstance();
2074 ASSERT_NE(gm, nullptr);
2075 bool ret = gm->isDeviceInGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID, TEST_AUTH_ID);
2076 ASSERT_EQ(ret, true);
2077 }
2078
2079 HWTEST_F(GmIsDeviceInGroupTest, GmIsDeviceInGroupTest005, TestSize.Level0)
2080 {
2081 const DeviceGroupManager *gm = GetGmInstance();
2082 ASSERT_NE(gm, nullptr);
2083 bool ret = gm->isDeviceInGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID2, TEST_GROUP_ID2, TEST_AUTH_ID);
2084 ASSERT_NE(ret, true);
2085 }
2086
2087 HWTEST_F(GmIsDeviceInGroupTest, GmIsDeviceInGroupTest006, TestSize.Level0)
2088 {
2089 const DeviceGroupManager *gm = GetGmInstance();
2090 ASSERT_NE(gm, nullptr);
2091 bool ret = gm->isDeviceInGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID4, TEST_AUTH_ID);
2092 ASSERT_EQ(ret, false);
2093 }
2094
2095 class GmAddMemberToGroupTest : public testing::Test {
2096 public:
2097 static void SetUpTestCase();
2098 static void TearDownTestCase();
2099 void SetUp();
2100 void TearDown();
2101 };
2102
SetUpTestCase()2103 void GmAddMemberToGroupTest::SetUpTestCase() {}
TearDownTestCase()2104 void GmAddMemberToGroupTest::TearDownTestCase() {}
2105
SetUp()2106 void GmAddMemberToGroupTest::SetUp()
2107 {
2108 DeleteDatabase();
2109 }
2110
TearDown()2111 void GmAddMemberToGroupTest::TearDown() {}
2112
2113 HWTEST_F(GmAddMemberToGroupTest, GmAddMemberToGroupTest001, TestSize.Level0)
2114 {
2115 int32_t ret = InitDeviceAuthService();
2116 EXPECT_EQ(ret, HC_SUCCESS);
2117 const DeviceGroupManager *gm = GetGmInstance();
2118 ASSERT_NE(gm, nullptr);
2119 ret = gm->addMemberToGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, nullptr, TEST_QUERY_PARAMS);
2120 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
2121 DestroyDeviceAuthService();
2122 }
2123
2124 HWTEST_F(GmAddMemberToGroupTest, GmAddMemberToGroupTest002, TestSize.Level0)
2125 {
2126 int32_t ret = InitDeviceAuthService();
2127 EXPECT_EQ(ret, HC_SUCCESS);
2128 const DeviceGroupManager *gm = GetGmInstance();
2129 ASSERT_NE(gm, nullptr);
2130 ret = gm->addMemberToGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, nullptr);
2131 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
2132 DestroyDeviceAuthService();
2133 }
2134
2135 HWTEST_F(GmAddMemberToGroupTest, GmAddMemberToGroupTest003, TestSize.Level0)
2136 {
2137 int32_t ret = InitDeviceAuthService();
2138 EXPECT_EQ(ret, HC_SUCCESS);
2139 const DeviceGroupManager *gm = GetGmInstance();
2140 ASSERT_NE(gm, nullptr);
2141 ret = gm->addMemberToGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
2142 ASSERT_NE(ret, HC_SUCCESS);
2143 DestroyDeviceAuthService();
2144 }
2145
2146 HWTEST_F(GmAddMemberToGroupTest, GmAddMemberToGroupTest004, TestSize.Level0)
2147 {
2148 int32_t ret = InitDeviceAuthService();
2149 EXPECT_EQ(ret, HC_SUCCESS);
2150 const DeviceGroupManager *gm = GetGmInstance();
2151 ASSERT_NE(gm, nullptr);
2152 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
2153 ASSERT_EQ(ret, HC_SUCCESS);
2154 ret = gm->addMemberToGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_invalidJsonStr);
2155 ASSERT_NE(ret, HC_SUCCESS);
2156 DestroyDeviceAuthService();
2157 }
2158
2159 HWTEST_F(GmAddMemberToGroupTest, GmAddMemberToGroupTest005, TestSize.Level0)
2160 {
2161 SetIsoSupported(true);
2162 SetPakeV1Supported(false);
2163 int32_t ret = InitDeviceAuthService();
2164 ASSERT_EQ(ret, HC_SUCCESS);
2165 const DeviceGroupManager *gm = GetGmInstance();
2166 ASSERT_NE(gm, nullptr);
2167 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
2168 ASSERT_EQ(ret, HC_SUCCESS);
2169 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
2170 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2171 AddDemoMember();
2172 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2173 DestroyDeviceAuthService();
2174 }
2175
2176 HWTEST_F(GmAddMemberToGroupTest, GmAddMemberToGroupTest006, TestSize.Level0)
2177 {
2178 SetIsoSupported(false);
2179 SetPakeV1Supported(true);
2180 int32_t ret = InitDeviceAuthService();
2181 ASSERT_EQ(ret, HC_SUCCESS);
2182 const DeviceGroupManager *gm = GetGmInstance();
2183 ASSERT_NE(gm, nullptr);
2184 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
2185 ASSERT_EQ(ret, HC_SUCCESS);
2186 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
2187 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2188 AddDemoMember();
2189 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2190 DestroyDeviceAuthService();
2191 }
2192
2193 class GmDeleteMemberFromGroupTest : public testing::Test {
2194 public:
2195 static void SetUpTestCase();
2196 static void TearDownTestCase();
2197 void SetUp();
2198 void TearDown();
2199 };
2200
SetUpTestCase()2201 void GmDeleteMemberFromGroupTest::SetUpTestCase() {}
TearDownTestCase()2202 void GmDeleteMemberFromGroupTest::TearDownTestCase() {}
2203
SetUp()2204 void GmDeleteMemberFromGroupTest::SetUp()
2205 {
2206 DeleteDatabase();
2207 }
2208
TearDown()2209 void GmDeleteMemberFromGroupTest::TearDown()
2210 {
2211 DestroyDeviceAuthService();
2212 }
2213
2214 HWTEST_F(GmDeleteMemberFromGroupTest, GmDeleteMemberFromGroupTest001, TestSize.Level0)
2215 {
2216 int32_t ret = InitDeviceAuthService();
2217 ASSERT_EQ(ret, HC_SUCCESS);
2218 const DeviceGroupManager *gm = GetGmInstance();
2219 ASSERT_NE(gm, nullptr);
2220 ret = gm->deleteMemberFromGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, nullptr, TEST_QUERY_PARAMS);
2221 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
2222 }
2223
2224 HWTEST_F(GmDeleteMemberFromGroupTest, GmDeleteMemberFromGroupTest002, TestSize.Level0)
2225 {
2226 int32_t ret = InitDeviceAuthService();
2227 ASSERT_EQ(ret, HC_SUCCESS);
2228 const DeviceGroupManager *gm = GetGmInstance();
2229 ASSERT_NE(gm, nullptr);
2230 ret = gm->deleteMemberFromGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, nullptr);
2231 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
2232 }
2233
2234 HWTEST_F(GmDeleteMemberFromGroupTest, GmDeleteMemberFromGroupTest003, TestSize.Level0)
2235 {
2236 int32_t ret = InitDeviceAuthService();
2237 ASSERT_EQ(ret, HC_SUCCESS);
2238 const DeviceGroupManager *gm = GetGmInstance();
2239 ASSERT_NE(gm, nullptr);
2240 ret = gm->deleteMemberFromGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_deleteParams);
2241 ASSERT_NE(ret, HC_SUCCESS);
2242 }
2243
2244 HWTEST_F(GmDeleteMemberFromGroupTest, GmDeleteMemberFromGroupTest004, TestSize.Level0)
2245 {
2246 int32_t ret = InitDeviceAuthService();
2247 ASSERT_EQ(ret, HC_SUCCESS);
2248 const DeviceGroupManager *gm = GetGmInstance();
2249 ASSERT_NE(gm, nullptr);
2250 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
2251 ASSERT_EQ(ret, HC_SUCCESS);
2252 ret = gm->deleteMemberFromGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_invalidJsonStr);
2253 ASSERT_NE(ret, HC_SUCCESS);
2254 }
2255
2256 HWTEST_F(GmDeleteMemberFromGroupTest, GmDeleteMemberFromGroupTest005, TestSize.Level0)
2257 {
2258 SetIsoSupported(true);
2259 SetPakeV1Supported(false);
2260 int32_t ret = InitDeviceAuthService();
2261 ASSERT_EQ(ret, HC_SUCCESS);
2262 const DeviceGroupManager *gm = GetGmInstance();
2263 ASSERT_NE(gm, nullptr);
2264 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
2265 ASSERT_EQ(ret, HC_SUCCESS);
2266 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
2267 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2268 AddDemoMember();
2269 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2270 DeleteDemoMember(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_deleteParams);
2271 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_ERROR);
2272 }
2273
2274 HWTEST_F(GmDeleteMemberFromGroupTest, GmDeleteMemberFromGroupTest006, TestSize.Level0)
2275 {
2276 SetIsoSupported(false);
2277 SetPakeV1Supported(true);
2278 int32_t ret = InitDeviceAuthService();
2279 ASSERT_EQ(ret, HC_SUCCESS);
2280 const DeviceGroupManager *gm = GetGmInstance();
2281 ASSERT_NE(gm, nullptr);
2282 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
2283 ASSERT_EQ(ret, HC_SUCCESS);
2284 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
2285 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2286 AddDemoMember();
2287 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2288 DeleteDemoMember(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_deleteParams);
2289 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_ERROR);
2290 }
2291
2292 HWTEST_F(GmDeleteMemberFromGroupTest, GmDeleteMemberFromGroupTest007, TestSize.Level0)
2293 {
2294 SetIsoSupported(true);
2295 SetPakeV1Supported(false);
2296 int32_t ret = InitDeviceAuthService();
2297 ASSERT_EQ(ret, HC_SUCCESS);
2298 const DeviceGroupManager *gm = GetGmInstance();
2299 ASSERT_NE(gm, nullptr);
2300 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
2301 ASSERT_EQ(ret, HC_SUCCESS);
2302 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
2303 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2304 AddDemoMember();
2305 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2306 DeleteDemoMember(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_deleteParams4);
2307 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2308 }
2309
2310 HWTEST_F(GmDeleteMemberFromGroupTest, GmDeleteMemberFromGroupTest008, TestSize.Level0)
2311 {
2312 SetIsoSupported(true);
2313 SetPakeV1Supported(false);
2314 int32_t ret = InitDeviceAuthService();
2315 ASSERT_EQ(ret, HC_SUCCESS);
2316 const DeviceGroupManager *gm = GetGmInstance();
2317 ASSERT_NE(gm, nullptr);
2318 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
2319 ASSERT_EQ(ret, HC_SUCCESS);
2320 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
2321 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2322 AddDemoMember();
2323 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2324 DeleteDemoMember(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_deleteParams4);
2325 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2326 DeleteDemoMember(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_deleteParams4);
2327 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
2328 }
2329
2330 HWTEST_F(GmDeleteMemberFromGroupTest, GmDeleteMemberFromGroupTest009, TestSize.Level0)
2331 {
2332 SetIsoSupported(true);
2333 SetPakeV1Supported(false);
2334 int32_t ret = InitDeviceAuthService();
2335 ASSERT_EQ(ret, HC_SUCCESS);
2336 const DeviceGroupManager *gm = GetGmInstance();
2337 ASSERT_NE(gm, nullptr);
2338 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
2339 ASSERT_EQ(ret, HC_SUCCESS);
2340 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
2341 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2342 AddDemoMember();
2343 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2344 const char *deleteParams = "{\"groupId\":\"E2EE6F830B176B2C96A9F99BFAE2A61F5D1490B9F4A090E9D8C28"
2345 "74C230C7C21\",\"deleteId\":\"InvalidAuthId\", \"isForceDelete\":true, \"isIgnoreChannel\":true}";
2346 DeleteDemoMember(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, deleteParams);
2347 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
2348 }
2349
2350 HWTEST_F(GmDeleteMemberFromGroupTest, GmDeleteMemberFromGroupTest010, TestSize.Level0)
2351 {
2352 SetIsoSupported(true);
2353 SetPakeV1Supported(false);
2354 int32_t ret = InitDeviceAuthService();
2355 ASSERT_EQ(ret, HC_SUCCESS);
2356 const DeviceGroupManager *gm = GetGmInstance();
2357 ASSERT_NE(gm, nullptr);
2358 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
2359 ASSERT_EQ(ret, HC_SUCCESS);
2360 const char *deleteParams = "{\"deleteId\":\"TestAuthId2\", \"isForceDelete\":true, \"isIgnoreChannel\":true}";
2361 DeleteDemoMember(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, deleteParams);
2362 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
2363 }
2364
2365 HWTEST_F(GmDeleteMemberFromGroupTest, GmDeleteMemberFromGroupTest011, TestSize.Level0)
2366 {
2367 SetIsoSupported(true);
2368 SetPakeV1Supported(false);
2369 int32_t ret = InitDeviceAuthService();
2370 ASSERT_EQ(ret, HC_SUCCESS);
2371 const DeviceGroupManager *gm = GetGmInstance();
2372 ASSERT_NE(gm, nullptr);
2373 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
2374 ASSERT_EQ(ret, HC_SUCCESS);
2375 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
2376 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2377 AddDemoMember();
2378 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2379 const char *deleteParams = "{\"groupId\":\"E2EE6F830B176B2C96A9F99BFAE2A61F5D1490B9F4A090E9D8C28"
2380 "74C230C7C21\",\"isForceDelete\":true, \"isIgnoreChannel\":true}";
2381 DeleteDemoMember(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, deleteParams);
2382 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
2383 }
2384
2385 class GmProcessDataTest : public testing::Test {
2386 public:
2387 static void SetUpTestCase();
2388 static void TearDownTestCase();
2389 void SetUp();
2390 void TearDown();
2391 };
2392
SetUpTestCase()2393 void GmProcessDataTest::SetUpTestCase() {}
TearDownTestCase()2394 void GmProcessDataTest::TearDownTestCase() {}
2395
SetUp()2396 void GmProcessDataTest::SetUp()
2397 {
2398 int ret = InitDeviceAuthService();
2399 EXPECT_EQ(ret, HC_SUCCESS);
2400 }
2401
TearDown()2402 void GmProcessDataTest::TearDown()
2403 {
2404 DestroyDeviceAuthService();
2405 }
2406
2407 HWTEST_F(GmProcessDataTest, GmProcessDataTest002, TestSize.Level0)
2408 {
2409 const DeviceGroupManager *gm = GetGmInstance();
2410 EXPECT_NE(gm, nullptr);
2411 int32_t ret = gm->processData(TEST_REQ_ID, nullptr, 0);
2412 EXPECT_NE(ret, HC_SUCCESS);
2413 }
2414
2415 class GmAddMultiMembersToGroupTest : public testing::Test {
2416 public:
2417 static void SetUpTestCase();
2418 static void TearDownTestCase();
2419 void SetUp();
2420 void TearDown();
2421 };
2422
SetUpTestCase()2423 void GmAddMultiMembersToGroupTest::SetUpTestCase() {}
TearDownTestCase()2424 void GmAddMultiMembersToGroupTest::TearDownTestCase() {}
2425
SetUp()2426 void GmAddMultiMembersToGroupTest::SetUp()
2427 {
2428 DeleteDatabase();
2429 int ret = InitDeviceAuthService();
2430 EXPECT_EQ(ret, HC_SUCCESS);
2431 }
2432
TearDown()2433 void GmAddMultiMembersToGroupTest::TearDown()
2434 {
2435 DestroyDeviceAuthService();
2436 }
2437
2438 HWTEST_F(GmAddMultiMembersToGroupTest, GmAddMultiMembersToGroupTest001, TestSize.Level0)
2439 {
2440 const DeviceGroupManager *gm = GetGmInstance();
2441 ASSERT_NE(gm, nullptr);
2442 int32_t ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, nullptr, TEST_QUERY_PARAMS);
2443 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
2444 }
2445
2446 HWTEST_F(GmAddMultiMembersToGroupTest, GmAddMultiMembersToGroupTest002, TestSize.Level0)
2447 {
2448 const DeviceGroupManager *gm = GetGmInstance();
2449 ASSERT_NE(gm, nullptr);
2450 int32_t ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, nullptr);
2451 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
2452 }
2453
2454 HWTEST_F(GmAddMultiMembersToGroupTest, GmAddMultiMembersToGroupTest003, TestSize.Level0)
2455 {
2456 const DeviceGroupManager *gm = GetGmInstance();
2457 ASSERT_NE(gm, nullptr);
2458 int32_t ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, g_invalidJsonStr);
2459 ASSERT_NE(ret, HC_SUCCESS);
2460 }
2461
2462 HWTEST_F(GmAddMultiMembersToGroupTest, GmAddMultiMembersToGroupTest004, TestSize.Level0)
2463 {
2464 const DeviceGroupManager *gm = GetGmInstance();
2465 ASSERT_NE(gm, nullptr);
2466 const char *addParams =
2467 "\"groupId\":\"1234ABCD\","
2468 "\"deviceList\":[{\"deviceId\":\"TestAuthId2\",\"udid\":\"TestUdid\",\"userId\":\"1234ABCD\","
2469 "\"credential\":{\"credentialType\":1,"
2470 "\"authCode\":\"37364761534f454d33567a73424e794f33573330507069434b31676f7254706b\"}},"
2471 "{\"deviceId\":\"TestAuthId3\",\"udid\":\"TestUdid2\",\"userId\":\"1234ABCD\","
2472 "\"credential\":{\"credentialType\":1,"
2473 "\"authCode\":\"2f7562744654535564586e665467546b322b4b506b65626373466f48766a4335\"}}]}";
2474 int32_t ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, addParams);
2475 ASSERT_NE(ret, HC_SUCCESS);
2476 }
2477
2478 HWTEST_F(GmAddMultiMembersToGroupTest, GmAddMultiMembersToGroupTest005, TestSize.Level0)
2479 {
2480 const DeviceGroupManager *gm = GetGmInstance();
2481 ASSERT_NE(gm, nullptr);
2482 const char *addParams =
2483 "{\"groupType\":1132123,\"groupId\":\"1234ABCD\","
2484 "\"deviceList\":[{\"deviceId\":\"TestAuthId2\",\"udid\":\"TestUdid\",\"userId\":\"1234ABCD\","
2485 "\"credential\":{\"credentialType\":1,"
2486 "\"authCode\":\"37364761534f454d33567a73424e794f33573330507069434b31676f7254706b\"}},"
2487 "{\"deviceId\":\"TestAuthId3\",\"udid\":\"TestUdid2\",\"userId\":\"1234ABCD\","
2488 "\"credential\":{\"credentialType\":1,"
2489 "\"authCode\":\"2f7562744654535564586e665467546b322b4b506b65626373466f48766a4335\"}}]}";
2490 int32_t ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, addParams);
2491 ASSERT_NE(ret, HC_SUCCESS);
2492 }
2493
2494 HWTEST_F(GmAddMultiMembersToGroupTest, GmAddMultiMembersToGroupTest006, TestSize.Level0)
2495 {
2496 const DeviceGroupManager *gm = GetGmInstance();
2497 ASSERT_NE(gm, nullptr);
2498 const char *addParams =
2499 "{\"groupType\":256,\"groupId\":\"1234ABCD\","
2500 "\"deviceList\":[{\"deviceId\":\"TestAuthId2\",\"udid\":\"TestUdid\",\"userId\":\"1234ABCD\","
2501 "\"credential\":{\"credentialType\":1,"
2502 "\"authCode\":\"37364761534f454d33567a73424e794f33573330507069434b31676f7254706b\"}},"
2503 "{\"deviceId\":\"TestAuthId3\",\"udid\":\"TestUdid2\",\"userId\":\"1234ABCD\","
2504 "\"credential\":{\"credentialType\":1,"
2505 "\"authCode\":\"2f7562744654535564586e665467546b322b4b506b65626373466f48766a4335\"}}]}";
2506 int32_t ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, addParams);
2507 ASSERT_NE(ret, HC_SUCCESS);
2508 }
2509
2510 HWTEST_F(GmAddMultiMembersToGroupTest, GmAddMultiMembersToGroupTest007, TestSize.Level0)
2511 {
2512 const DeviceGroupManager *gm = GetGmInstance();
2513 ASSERT_NE(gm, nullptr);
2514 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
2515 ASSERT_EQ(ret, HC_SUCCESS);
2516 CreateDemoIdenticalAccountGroup();
2517 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2518 ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, g_addParams2);
2519 ASSERT_EQ(ret, HC_SUCCESS);
2520 }
2521
2522 HWTEST_F(GmAddMultiMembersToGroupTest, GmAddMultiMembersToGroupTest008, TestSize.Level0)
2523 {
2524 const DeviceGroupManager *gm = GetGmInstance();
2525 ASSERT_NE(gm, nullptr);
2526 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
2527 ASSERT_EQ(ret, HC_SUCCESS);
2528 CreateDemoIdenticalAccountGroup();
2529 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2530 CreateDemoAcrossAccountGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams3);
2531 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2532 ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, g_addParams3);
2533 ASSERT_EQ(ret, HC_SUCCESS);
2534 }
2535
2536 class GmDelMultiMembersFromGroupTest : public testing::Test {
2537 public:
2538 static void SetUpTestCase();
2539 static void TearDownTestCase();
2540 void SetUp();
2541 void TearDown();
2542 };
2543
SetUpTestCase()2544 void GmDelMultiMembersFromGroupTest::SetUpTestCase() {}
TearDownTestCase()2545 void GmDelMultiMembersFromGroupTest::TearDownTestCase() {}
2546
SetUp()2547 void GmDelMultiMembersFromGroupTest::SetUp()
2548 {
2549 DeleteDatabase();
2550 int ret = InitDeviceAuthService();
2551 EXPECT_EQ(ret, HC_SUCCESS);
2552 }
2553
TearDown()2554 void GmDelMultiMembersFromGroupTest::TearDown()
2555 {
2556 DestroyDeviceAuthService();
2557 }
2558
2559 HWTEST_F(GmDelMultiMembersFromGroupTest, GmDelMultiMembersFromGroupTest001, TestSize.Level0)
2560 {
2561 const DeviceGroupManager *gm = GetGmInstance();
2562 ASSERT_NE(gm, nullptr);
2563 int32_t ret = gm->delMultiMembersFromGroup(DEFAULT_OS_ACCOUNT, nullptr, TEST_QUERY_PARAMS);
2564 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
2565 }
2566
2567 HWTEST_F(GmDelMultiMembersFromGroupTest, GmDelMultiMembersFromGroupTest002, TestSize.Level0)
2568 {
2569 const DeviceGroupManager *gm = GetGmInstance();
2570 ASSERT_NE(gm, nullptr);
2571 int32_t ret = gm->delMultiMembersFromGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, nullptr);
2572 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
2573 }
2574
2575 HWTEST_F(GmDelMultiMembersFromGroupTest, GmDelMultiMembersFromGroupTest003, TestSize.Level0)
2576 {
2577 const DeviceGroupManager *gm = GetGmInstance();
2578 ASSERT_NE(gm, nullptr);
2579 int32_t ret = gm->delMultiMembersFromGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, g_invalidJsonStr);
2580 ASSERT_NE(ret, HC_SUCCESS);
2581 }
2582
2583 HWTEST_F(GmDelMultiMembersFromGroupTest, GmDelMultiMembersFromGroupTest004, TestSize.Level0)
2584 {
2585 const DeviceGroupManager *gm = GetGmInstance();
2586 ASSERT_NE(gm, nullptr);
2587 const char *deleteParams =
2588 "{\"groupId\":\"1234ABCD\","
2589 "\"deviceList\":[{\"deviceId\":\"TestAuthId2\"},{\"deviceId\":\"TestAuthId3\"}]}";
2590 int32_t ret = gm->delMultiMembersFromGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, deleteParams);
2591 ASSERT_NE(ret, HC_SUCCESS);
2592 }
2593
2594 HWTEST_F(GmDelMultiMembersFromGroupTest, GmDelMultiMembersFromGroupTest005, TestSize.Level0)
2595 {
2596 const DeviceGroupManager *gm = GetGmInstance();
2597 ASSERT_NE(gm, nullptr);
2598 const char *deleteParams =
2599 "{\"groupType\":1123123,\"groupId\":\"1234ABCD\","
2600 "\"deviceList\":[{\"deviceId\":\"TestAuthId2\"},{\"deviceId\":\"TestAuthId3\"}]}";
2601 int32_t ret = gm->delMultiMembersFromGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, deleteParams);
2602 ASSERT_NE(ret, HC_SUCCESS);
2603 }
2604
2605 HWTEST_F(GmDelMultiMembersFromGroupTest, GmDelMultiMembersFromGroupTest006, TestSize.Level0)
2606 {
2607 const DeviceGroupManager *gm = GetGmInstance();
2608 ASSERT_NE(gm, nullptr);
2609 const char *deleteParams =
2610 "{\"groupType\":256,\"groupId\":\"1234ABCD\","
2611 "\"deviceList\":[{\"deviceId\":\"TestAuthId2\"},{\"deviceId\":\"TestAuthId3\"}]}";
2612 int32_t ret = gm->delMultiMembersFromGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, deleteParams);
2613 ASSERT_NE(ret, HC_SUCCESS);
2614 }
2615
2616 HWTEST_F(GmDelMultiMembersFromGroupTest, GmDelMultiMembersFromGroupTest007, TestSize.Level0)
2617 {
2618 const DeviceGroupManager *gm = GetGmInstance();
2619 ASSERT_NE(gm, nullptr);
2620 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
2621 ASSERT_EQ(ret, HC_SUCCESS);
2622 CreateDemoIdenticalAccountGroup();
2623 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2624 ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, g_addParams2);
2625 ASSERT_EQ(ret, HC_SUCCESS);
2626 ret = gm->delMultiMembersFromGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, g_deleteParams2);
2627 ASSERT_EQ(ret, HC_SUCCESS);
2628 }
2629
2630 HWTEST_F(GmDelMultiMembersFromGroupTest, GmDelMultiMembersFromGroupTest008, TestSize.Level0)
2631 {
2632 const DeviceGroupManager *gm = GetGmInstance();
2633 ASSERT_NE(gm, nullptr);
2634 int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
2635 ASSERT_EQ(ret, HC_SUCCESS);
2636 CreateDemoIdenticalAccountGroup();
2637 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2638 CreateDemoAcrossAccountGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams3);
2639 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2640 ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, g_addParams3);
2641 ASSERT_EQ(ret, HC_SUCCESS);
2642 ret = gm->delMultiMembersFromGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, g_deleteParams3);
2643 ASSERT_EQ(ret, HC_SUCCESS);
2644 }
2645
2646 class GmGetRegisterInfoTest : public testing::Test {
2647 public:
2648 static void SetUpTestCase();
2649 static void TearDownTestCase();
2650 void SetUp();
2651 void TearDown();
2652 };
2653
SetUpTestCase()2654 void GmGetRegisterInfoTest::SetUpTestCase() {}
TearDownTestCase()2655 void GmGetRegisterInfoTest::TearDownTestCase() {}
2656
SetUp()2657 void GmGetRegisterInfoTest::SetUp()
2658 {
2659 int ret = InitDeviceAuthService();
2660 EXPECT_EQ(ret, HC_SUCCESS);
2661 }
2662
TearDown()2663 void GmGetRegisterInfoTest::TearDown()
2664 {
2665 DestroyDeviceAuthService();
2666 }
2667
2668 HWTEST_F(GmGetRegisterInfoTest, GmGetRegisterInfoTest001, TestSize.Level0)
2669 {
2670 const DeviceGroupManager *gm = GetGmInstance();
2671 ASSERT_NE(gm, nullptr);
2672 char *returnData = nullptr;
2673 int32_t ret = gm->getRegisterInfo(nullptr, &returnData);
2674 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
2675 }
2676
2677 HWTEST_F(GmGetRegisterInfoTest, GmGetRegisterInfoTest002, TestSize.Level0)
2678 {
2679 const DeviceGroupManager *gm = GetGmInstance();
2680 ASSERT_NE(gm, nullptr);
2681 int32_t ret = gm->getRegisterInfo(TEST_QUERY_PARAMS, nullptr);
2682 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
2683 }
2684
2685 HWTEST_F(GmGetRegisterInfoTest, GmGetRegisterInfoTest003, TestSize.Level0)
2686 {
2687 const DeviceGroupManager *gm = GetGmInstance();
2688 ASSERT_NE(gm, nullptr);
2689 char *returnData = nullptr;
2690 int32_t ret = gm->getRegisterInfo(g_getRegisterInfoParams, &returnData);
2691 ASSERT_EQ(ret, HC_SUCCESS);
2692 ASSERT_NE(returnData, nullptr);
2693 gm->destroyInfo(&returnData);
2694 }
2695
2696 class GmDeleteGroupTest : public testing::Test {
2697 public:
2698 static void SetUpTestCase();
2699 static void TearDownTestCase();
2700 void SetUp();
2701 void TearDown();
2702 };
2703
SetUpTestCase()2704 void GmDeleteGroupTest::SetUpTestCase() {}
TearDownTestCase()2705 void GmDeleteGroupTest::TearDownTestCase() {}
2706
SetUp()2707 void GmDeleteGroupTest::SetUp()
2708 {
2709 DeleteDatabase();
2710 }
2711
TearDown()2712 void GmDeleteGroupTest::TearDown() {}
2713
2714 HWTEST_F(GmDeleteGroupTest, GmDeleteGroupTest001, TestSize.Level0)
2715 {
2716 int32_t ret = InitDeviceAuthService();
2717 ASSERT_EQ(ret, HC_SUCCESS);
2718 const DeviceGroupManager *gm = GetGmInstance();
2719 ASSERT_NE(gm, nullptr);
2720 ret = gm->deleteGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, nullptr);
2721 ASSERT_NE(ret, HC_SUCCESS);
2722 DestroyDeviceAuthService();
2723 }
2724
2725 HWTEST_F(GmDeleteGroupTest, GmDeleteGroupTest002, TestSize.Level0)
2726 {
2727 int32_t ret = InitDeviceAuthService();
2728 ASSERT_EQ(ret, HC_SUCCESS);
2729 const DeviceGroupManager *gm = GetGmInstance();
2730 ASSERT_NE(gm, nullptr);
2731 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
2732 ASSERT_EQ(ret, HC_SUCCESS);
2733 DeleteDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_disbandParams);
2734 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_ERROR);
2735 DestroyDeviceAuthService();
2736 }
2737
2738 HWTEST_F(GmDeleteGroupTest, GmDeleteGroupTest003, TestSize.Level0)
2739 {
2740 int32_t ret = InitDeviceAuthService();
2741 ASSERT_EQ(ret, HC_SUCCESS);
2742 const DeviceGroupManager *gm = GetGmInstance();
2743 ASSERT_NE(gm, nullptr);
2744 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
2745 ASSERT_EQ(ret, HC_SUCCESS);
2746 ret = gm->deleteGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_invalidJsonStr);
2747 ASSERT_NE(ret, HC_SUCCESS);
2748 DestroyDeviceAuthService();
2749 }
2750
2751 HWTEST_F(GmDeleteGroupTest, GmDeleteGroupTest004, TestSize.Level0)
2752 {
2753 int32_t ret = InitDeviceAuthService();
2754 ASSERT_EQ(ret, HC_SUCCESS);
2755 const DeviceGroupManager *gm = GetGmInstance();
2756 ASSERT_NE(gm, nullptr);
2757 ret = gm->deleteGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_disbandParams);
2758 ASSERT_NE(ret, HC_SUCCESS);
2759 DestroyDeviceAuthService();
2760 }
2761
2762 HWTEST_F(GmDeleteGroupTest, GmDeleteGroupTest005, TestSize.Level0)
2763 {
2764 int32_t ret = InitDeviceAuthService();
2765 ASSERT_EQ(ret, HC_SUCCESS);
2766 const DeviceGroupManager *gm = GetGmInstance();
2767 ASSERT_NE(gm, nullptr);
2768 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
2769 ASSERT_EQ(ret, HC_SUCCESS);
2770 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
2771 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2772 DeleteDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_disbandParams);
2773 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2774 DestroyDeviceAuthService();
2775 }
2776
2777 HWTEST_F(GmDeleteGroupTest, GmDeleteGroupTest006, TestSize.Level0)
2778 {
2779 SetIsoSupported(true);
2780 SetPakeV1Supported(false);
2781 int32_t ret = InitDeviceAuthService();
2782 ASSERT_EQ(ret, HC_SUCCESS);
2783 const DeviceGroupManager *gm = GetGmInstance();
2784 ASSERT_NE(gm, nullptr);
2785 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
2786 ASSERT_EQ(ret, HC_SUCCESS);
2787 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
2788 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2789 AddDemoMember();
2790 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2791 DeleteDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_disbandParams);
2792 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2793 DestroyDeviceAuthService();
2794 }
2795
2796 HWTEST_F(GmDeleteGroupTest, GmDeleteGroupTest007, TestSize.Level0)
2797 {
2798 int32_t ret = InitDeviceAuthService();
2799 ASSERT_EQ(ret, HC_SUCCESS);
2800 const DeviceGroupManager *gm = GetGmInstance();
2801 ASSERT_NE(gm, nullptr);
2802 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
2803 ASSERT_EQ(ret, HC_SUCCESS);
2804 CreateDemoIdenticalAccountGroup();
2805 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2806 CreateDemoAcrossAccountGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams3);
2807 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2808 DeleteDemoAcrossAccountGroup();
2809 DeleteDemoIdenticalAccountGroup();
2810 DestroyDeviceAuthService();
2811 }
2812
2813 HWTEST_F(GmDeleteGroupTest, GmDeleteGroupTest008, TestSize.Level0)
2814 {
2815 int32_t ret = InitDeviceAuthService();
2816 ASSERT_EQ(ret, HC_SUCCESS);
2817 const DeviceGroupManager *gm = GetGmInstance();
2818 ASSERT_NE(gm, nullptr);
2819 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
2820 ASSERT_EQ(ret, HC_SUCCESS);
2821 CreateDemoIdenticalAccountGroup();
2822 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2823 ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, g_addParams2);
2824 ASSERT_EQ(ret, HC_SUCCESS);
2825 CreateDemoAcrossAccountGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams3);
2826 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2827 DeleteDemoAcrossAccountGroup();
2828 DeleteDemoIdenticalAccountGroup();
2829 DestroyDeviceAuthService();
2830 }
2831
2832 HWTEST_F(GmDeleteGroupTest, GmDeleteGroupTest009, TestSize.Level0)
2833 {
2834 int32_t ret = InitDeviceAuthService();
2835 ASSERT_EQ(ret, HC_SUCCESS);
2836 const DeviceGroupManager *gm = GetGmInstance();
2837 ASSERT_NE(gm, nullptr);
2838 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
2839 ASSERT_EQ(ret, HC_SUCCESS);
2840 CreateDemoIdenticalAccountGroup();
2841 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2842 CreateDemoAcrossAccountGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams3);
2843 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2844 ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, g_addParams3);
2845 ASSERT_EQ(ret, HC_SUCCESS);
2846 DeleteDemoAcrossAccountGroup();
2847 DeleteDemoIdenticalAccountGroup();
2848 DestroyDeviceAuthService();
2849 }
2850
2851 class GmCancelRequestTest : public testing::Test {
2852 public:
2853 static void SetUpTestCase();
2854 static void TearDownTestCase();
2855 void SetUp();
2856 void TearDown();
2857 };
2858
SetUpTestCase()2859 void GmCancelRequestTest::SetUpTestCase() {}
2860
TearDownTestCase()2861 void GmCancelRequestTest::TearDownTestCase() {}
2862
SetUp()2863 void GmCancelRequestTest::SetUp()
2864 {
2865 DeleteDatabase();
2866 }
2867
TearDown()2868 void GmCancelRequestTest::TearDown() {}
2869
2870 HWTEST_F(GmCancelRequestTest, GmCancelRequestTest001, TestSize.Level0)
2871 {
2872 int32_t ret = InitDeviceAuthService();
2873 ASSERT_EQ(ret, HC_SUCCESS);
2874 const DeviceGroupManager *gm = GetGmInstance();
2875 ASSERT_NE(gm, nullptr);
2876 gm->cancelRequest(TEST_REQ_ID, nullptr);
2877 DestroyDeviceAuthService();
2878 }
2879
2880 HWTEST_F(GmCancelRequestTest, GmCancelRequestTest002, TestSize.Level0)
2881 {
2882 SetIsoSupported(true);
2883 SetPakeV1Supported(false);
2884 int32_t ret = InitDeviceAuthService();
2885 ASSERT_EQ(ret, HC_SUCCESS);
2886 const DeviceGroupManager *gm = GetGmInstance();
2887 ASSERT_NE(gm, nullptr);
2888 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
2889 ASSERT_EQ(ret, HC_SUCCESS);
2890 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
2891 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2892 ret = gm->addMemberToGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_addParams);
2893 ASSERT_EQ(ret, HC_SUCCESS);
2894 gm->cancelRequest(TEST_REQ_ID, TEST_APP_ID);
2895 usleep(TEST_DEV_AUTH_SLEEP_TIME);
2896 DestroyDeviceAuthService();
2897 }
2898
2899 HWTEST_F(GmCancelRequestTest, GmCancelRequestTest003, TestSize.Level0)
2900 {
2901 SetIsoSupported(true);
2902 SetPakeV1Supported(false);
2903 int32_t ret = InitDeviceAuthService();
2904 ASSERT_EQ(ret, HC_SUCCESS);
2905 const DeviceGroupManager *gm = GetGmInstance();
2906 ASSERT_NE(gm, nullptr);
2907 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
2908 ASSERT_EQ(ret, HC_SUCCESS);
2909 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
2910 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2911 ret = gm->addMemberToGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_addParams);
2912 ASSERT_EQ(ret, HC_SUCCESS);
2913 gm->cancelRequest(TEST_REQ_ID2, TEST_APP_ID);
2914 usleep(TEST_DEV_AUTH_SLEEP_TIME);
2915 DestroyDeviceAuthService();
2916 }
2917
2918 HWTEST_F(GmCancelRequestTest, GmCancelRequestTest004, TestSize.Level0)
2919 {
2920 SetIsoSupported(true);
2921 SetPakeV1Supported(false);
2922 int32_t ret = InitDeviceAuthService();
2923 ASSERT_EQ(ret, HC_SUCCESS);
2924 const DeviceGroupManager *gm = GetGmInstance();
2925 ASSERT_NE(gm, nullptr);
2926 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
2927 ASSERT_EQ(ret, HC_SUCCESS);
2928 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
2929 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2930 ret = gm->addMemberToGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_addParams);
2931 ASSERT_EQ(ret, HC_SUCCESS);
2932 gm->cancelRequest(TEST_REQ_ID, TEST_APP_ID2);
2933 usleep(TEST_DEV_AUTH_SLEEP_TIME);
2934 DestroyDeviceAuthService();
2935 }
2936
2937 HWTEST_F(GmCancelRequestTest, GmCancelRequestTest005, TestSize.Level0)
2938 {
2939 SetIsoSupported(true);
2940 SetPakeV1Supported(false);
2941 int32_t ret = InitDeviceAuthService();
2942 ASSERT_EQ(ret, HC_SUCCESS);
2943 const DeviceGroupManager *gm = GetGmInstance();
2944 ASSERT_NE(gm, nullptr);
2945 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
2946 ASSERT_EQ(ret, HC_SUCCESS);
2947 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
2948 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
2949 ret = gm->addMemberToGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_addParams);
2950 ASSERT_EQ(ret, HC_SUCCESS);
2951 const GroupAuthManager *ga = GetGaInstance();
2952 ASSERT_NE(ga, nullptr);
2953 ga->cancelRequest(TEST_REQ_ID, TEST_APP_ID);
2954 usleep(TEST_DEV_AUTH_SLEEP_TIME);
2955 DestroyDeviceAuthService();
2956 }
2957
2958 class GmDestroyInfoTest : public testing::Test {
2959 public:
2960 static void SetUpTestCase();
2961 static void TearDownTestCase();
2962 void SetUp();
2963 void TearDown();
2964 };
2965
SetUpTestCase()2966 void GmDestroyInfoTest::SetUpTestCase()
2967 {
2968 int32_t ret = InitDeviceAuthService();
2969 ASSERT_EQ(ret, HC_SUCCESS);
2970 }
2971
TearDownTestCase()2972 void GmDestroyInfoTest::TearDownTestCase()
2973 {
2974 DestroyDeviceAuthService();
2975 }
2976
SetUp()2977 void GmDestroyInfoTest::SetUp() {}
2978
TearDown()2979 void GmDestroyInfoTest::TearDown() {}
2980
2981 HWTEST_F(GmDestroyInfoTest, GmDestroyInfoTest001, TestSize.Level0)
2982 {
2983 const DeviceGroupManager *gm = GetGmInstance();
2984 ASSERT_NE(gm, nullptr);
2985 gm->destroyInfo(nullptr);
2986 }
2987
2988 HWTEST_F(GmDestroyInfoTest, GmDestroyInfoTest002, TestSize.Level0)
2989 {
2990 const DeviceGroupManager *gm = GetGmInstance();
2991 ASSERT_NE(gm, nullptr);
2992 char *str = nullptr;
2993 gm->destroyInfo(&str);
2994 }
2995
2996 class GaAuthDeviceTest : public testing::Test {
2997 public:
2998 static void SetUpTestCase();
2999 static void TearDownTestCase();
3000 void SetUp();
3001 void TearDown();
3002 };
3003
SetUpTestCase()3004 void GaAuthDeviceTest::SetUpTestCase() {}
TearDownTestCase()3005 void GaAuthDeviceTest::TearDownTestCase() {}
3006
SetUp()3007 void GaAuthDeviceTest::SetUp()
3008 {
3009 DeleteDatabase();
3010 }
3011
TearDown()3012 void GaAuthDeviceTest::TearDown() {}
3013
3014 HWTEST_F(GaAuthDeviceTest, GaAuthDeviceTest001, TestSize.Level0)
3015 {
3016 int32_t ret = InitDeviceAuthService();
3017 ASSERT_EQ(ret, HC_SUCCESS);
3018 const GroupAuthManager *ga = GetGaInstance();
3019 ASSERT_NE(ga, nullptr);
3020 ret = ga->authDevice(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, nullptr, &g_gmCallback);
3021 ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
3022 DestroyDeviceAuthService();
3023 }
3024
3025 HWTEST_F(GaAuthDeviceTest, GaAuthDeviceTest002, TestSize.Level0)
3026 {
3027 int32_t ret = InitDeviceAuthService();
3028 ASSERT_EQ(ret, HC_SUCCESS);
3029 const GroupAuthManager *ga = GetGaInstance();
3030 ASSERT_NE(ga, nullptr);
3031 ret = ga->authDevice(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, g_authParams, nullptr);
3032 ASSERT_NE(ret, HC_SUCCESS);
3033 DestroyDeviceAuthService();
3034 }
3035
3036 HWTEST_F(GaAuthDeviceTest, GaAuthDeviceTest003, TestSize.Level0)
3037 {
3038 SetIsoSupported(true);
3039 SetPakeV1Supported(false);
3040 int32_t ret = InitDeviceAuthService();
3041 ASSERT_EQ(ret, HC_SUCCESS);
3042 const DeviceGroupManager *gm = GetGmInstance();
3043 ASSERT_NE(gm, nullptr);
3044 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
3045 ASSERT_EQ(ret, HC_SUCCESS);
3046 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
3047 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
3048 AddDemoMember();
3049 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
3050 AuthDemoMember();
3051 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
3052 DestroyDeviceAuthService();
3053 }
3054
3055 HWTEST_F(GaAuthDeviceTest, GaAuthDeviceTest004, TestSize.Level0)
3056 {
3057 SetIsoSupported(false);
3058 SetPakeV1Supported(true);
3059 int32_t ret = InitDeviceAuthService();
3060 ASSERT_EQ(ret, HC_SUCCESS);
3061 const DeviceGroupManager *gm = GetGmInstance();
3062 ASSERT_NE(gm, nullptr);
3063 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
3064 ASSERT_EQ(ret, HC_SUCCESS);
3065 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
3066 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
3067 AddDemoMember();
3068 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
3069 AuthDemoMember();
3070 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
3071 DestroyDeviceAuthService();
3072 }
3073
3074 HWTEST_F(GaAuthDeviceTest, GaAuthDeviceTest005, TestSize.Level0)
3075 {
3076 SetIsoSupported(true);
3077 SetPakeV1Supported(false);
3078 int32_t ret = InitDeviceAuthService();
3079 ASSERT_EQ(ret, HC_SUCCESS);
3080 const DeviceGroupManager *gm = GetGmInstance();
3081 ASSERT_NE(gm, nullptr);
3082 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
3083 ASSERT_EQ(ret, HC_SUCCESS);
3084 CreateDemoSymClientIdenticalAccountGroup();
3085 ASSERT_EQ(ret, HC_SUCCESS);
3086 SetDeviceStatus(false);
3087 CreateDemoSymServerIdenticalAccountGroup();
3088 SetDeviceStatus(true);
3089 AuthDemoMember();
3090 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
3091 DestroyDeviceAuthService();
3092 }
3093
3094 HWTEST_F(GaAuthDeviceTest, GaAuthDeviceTest006, TestSize.Level0)
3095 {
3096 SetIsoSupported(true);
3097 SetPakeV1Supported(false);
3098 int32_t ret = InitDeviceAuthService();
3099 ASSERT_EQ(ret, HC_SUCCESS);
3100 const DeviceGroupManager *gm = GetGmInstance();
3101 ASSERT_NE(gm, nullptr);
3102 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
3103 ASSERT_EQ(ret, HC_SUCCESS);
3104 CreateDemoSymClientIdenticalAccountGroup();
3105 SetDeviceStatus(false);
3106 CreateDemoSymServerIdenticalAccountGroup();
3107 SetDeviceStatus(true);
3108 ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, g_addParams4);
3109 ASSERT_EQ(ret, HC_SUCCESS);
3110 SetDeviceStatus(false);
3111 ret = gm->addMultiMembersToGroup(TEST_AUTH_OS_ACCOUNT_ID, TEST_APP_ID, g_addParams5);
3112 ASSERT_EQ(ret, HC_SUCCESS);
3113 SetDeviceStatus(true);
3114 AuthDemoMember();
3115 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
3116 DestroyDeviceAuthService();
3117 }
3118
3119 class GaProcessDataTest : public testing::Test {
3120 public:
3121 static void SetUpTestCase();
3122 static void TearDownTestCase();
3123 void SetUp();
3124 void TearDown();
3125 };
3126
SetUpTestCase()3127 void GaProcessDataTest::SetUpTestCase() {}
TearDownTestCase()3128 void GaProcessDataTest::TearDownTestCase() {}
3129
SetUp()3130 void GaProcessDataTest::SetUp()
3131 {
3132 int ret = InitDeviceAuthService();
3133 EXPECT_EQ(ret, HC_SUCCESS);
3134 }
3135
TearDown()3136 void GaProcessDataTest::TearDown()
3137 {
3138 DestroyDeviceAuthService();
3139 }
3140
3141 HWTEST_F(GaProcessDataTest, GaProcessDataTest002, TestSize.Level0)
3142 {
3143 const GroupAuthManager *ga = GetGaInstance();
3144 EXPECT_NE(ga, nullptr);
3145 int32_t ret = ga->processData(TEST_REQ_ID, nullptr, 0, nullptr);
3146 EXPECT_NE(ret, HC_SUCCESS);
3147 }
3148
3149 class GaCancelRequestTest : public testing::Test {
3150 public:
3151 static void SetUpTestCase();
3152 static void TearDownTestCase();
3153 void SetUp();
3154 void TearDown();
3155 };
3156
SetUpTestCase()3157 void GaCancelRequestTest::SetUpTestCase() {}
3158
TearDownTestCase()3159 void GaCancelRequestTest::TearDownTestCase() {}
3160
SetUp()3161 void GaCancelRequestTest::SetUp()
3162 {
3163 DeleteDatabase();
3164 }
3165
TearDown()3166 void GaCancelRequestTest::TearDown() {}
3167
3168 HWTEST_F(GaCancelRequestTest, GaCancelRequestTest001, TestSize.Level0)
3169 {
3170 SetIsoSupported(true);
3171 SetPakeV1Supported(false);
3172 int32_t ret = InitDeviceAuthService();
3173 ASSERT_EQ(ret, HC_SUCCESS);
3174 const DeviceGroupManager *gm = GetGmInstance();
3175 ASSERT_NE(gm, nullptr);
3176 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
3177 ASSERT_EQ(ret, HC_SUCCESS);
3178 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
3179 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
3180 AddDemoMember();
3181 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
3182 const GroupAuthManager *ga = GetGaInstance();
3183 ASSERT_NE(ga, nullptr);
3184 ret = ga->authDevice(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, g_authParams, &g_gaCallback);
3185 ASSERT_EQ(ret, HC_SUCCESS);
3186 ga->cancelRequest(TEST_REQ_ID, TEST_APP_ID);
3187 usleep(TEST_DEV_AUTH_SLEEP_TIME);
3188 DestroyDeviceAuthService();
3189 }
3190
3191 HWTEST_F(GaCancelRequestTest, GaCancelRequestTest002, TestSize.Level0)
3192 {
3193 SetIsoSupported(true);
3194 SetPakeV1Supported(false);
3195 int32_t ret = InitDeviceAuthService();
3196 ASSERT_EQ(ret, HC_SUCCESS);
3197 const DeviceGroupManager *gm = GetGmInstance();
3198 ASSERT_NE(gm, nullptr);
3199 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
3200 ASSERT_EQ(ret, HC_SUCCESS);
3201 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
3202 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
3203 AddDemoMember();
3204 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
3205 const GroupAuthManager *ga = GetGaInstance();
3206 ASSERT_NE(ga, nullptr);
3207 ret = ga->authDevice(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, g_authParams, &g_gaCallback);
3208 ASSERT_EQ(ret, HC_SUCCESS);
3209 ga->cancelRequest(TEST_REQ_ID2, TEST_APP_ID);
3210 usleep(TEST_DEV_AUTH_SLEEP_TIME);
3211 DestroyDeviceAuthService();
3212 }
3213
3214 HWTEST_F(GaCancelRequestTest, GaCancelRequestTest003, TestSize.Level0)
3215 {
3216 SetIsoSupported(true);
3217 SetPakeV1Supported(false);
3218 int32_t ret = InitDeviceAuthService();
3219 ASSERT_EQ(ret, HC_SUCCESS);
3220 const DeviceGroupManager *gm = GetGmInstance();
3221 ASSERT_NE(gm, nullptr);
3222 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
3223 ASSERT_EQ(ret, HC_SUCCESS);
3224 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
3225 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
3226 AddDemoMember();
3227 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
3228 const GroupAuthManager *ga = GetGaInstance();
3229 ASSERT_NE(ga, nullptr);
3230 ret = ga->authDevice(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, g_authParams, &g_gaCallback);
3231 ASSERT_EQ(ret, HC_SUCCESS);
3232 ga->cancelRequest(TEST_REQ_ID, TEST_APP_ID2);
3233 usleep(TEST_DEV_AUTH_SLEEP_TIME);
3234 DestroyDeviceAuthService();
3235 }
3236
3237 HWTEST_F(GaCancelRequestTest, GaCancelRequestTest004, TestSize.Level0)
3238 {
3239 SetIsoSupported(true);
3240 SetPakeV1Supported(false);
3241 int32_t ret = InitDeviceAuthService();
3242 ASSERT_EQ(ret, HC_SUCCESS);
3243 const DeviceGroupManager *gm = GetGmInstance();
3244 ASSERT_NE(gm, nullptr);
3245 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
3246 ASSERT_EQ(ret, HC_SUCCESS);
3247 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
3248 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
3249 AddDemoMember();
3250 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
3251 const GroupAuthManager *ga = GetGaInstance();
3252 ASSERT_NE(ga, nullptr);
3253 ret = ga->authDevice(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, g_authParams, &g_gaCallback);
3254 ASSERT_EQ(ret, HC_SUCCESS);
3255 gm->cancelRequest(TEST_REQ_ID, TEST_APP_ID);
3256 usleep(TEST_DEV_AUTH_SLEEP_TIME);
3257 DestroyDeviceAuthService();
3258 }
3259
3260 class DevAuthTest : public testing::Test {
3261 public:
3262 static void SetUpTestCase();
3263 static void TearDownTestCase();
3264 void SetUp();
3265 void TearDown();
3266 };
3267
SetUpTestCase()3268 void DevAuthTest::SetUpTestCase() {}
TearDownTestCase()3269 void DevAuthTest::TearDownTestCase()
3270 {
3271 DeleteDatabase();
3272 }
3273
SetUp()3274 void DevAuthTest::SetUp()
3275 {
3276 DeleteDatabase();
3277 }
3278
TearDown()3279 void DevAuthTest::TearDown() {}
3280
3281 HWTEST_F(DevAuthTest, DevAuthTest001, TestSize.Level0)
3282 {
3283 StartRecordJsonCallNum();
3284 int32_t ret = InitDeviceAuthService();
3285 ASSERT_EQ(ret, HC_SUCCESS);
3286 const DeviceGroupManager *gm = GetGmInstance();
3287 ASSERT_NE(gm, nullptr);
3288 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
3289 ASSERT_EQ(ret, HC_SUCCESS);
3290 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
3291 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
3292 DestroyDeviceAuthService();
3293 uint32_t mallocCount = GetJsonCallNum();
3294 printf("mock count: %u\n", mallocCount);
3295 for (int i = 0; i < mallocCount; i++) {
3296 ResetRecordJsonCallNum();
3297 SetJsonCallMockIndex(i);
3298 ret = InitDeviceAuthService();
3299 if (ret != HC_SUCCESS) {
3300 continue;
3301 }
3302 const DeviceGroupManager *gm = GetGmInstance();
3303 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
3304 if (ret != HC_SUCCESS) {
3305 DestroyDeviceAuthService();
3306 continue;
3307 }
3308 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
3309 if (g_asyncStatus != ASYNC_STATUS_FINISH) {
3310 DestroyDeviceAuthService();
3311 DeleteDatabase();
3312 continue;
3313 }
3314 DestroyDeviceAuthService();
3315 }
3316 }
3317
3318 HWTEST_F(DevAuthTest, DevAuthTest101, TestSize.Level0)
3319 {
3320 SetIsoSupported(true);
3321 SetPakeV1Supported(false);
3322 int32_t ret = InitDeviceAuthService();
3323 ASSERT_EQ(ret, HC_SUCCESS);
3324 const DeviceGroupManager *gm = GetGmInstance();
3325 ASSERT_NE(gm, nullptr);
3326 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
3327 ASSERT_EQ(ret, HC_SUCCESS);
3328 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
3329 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
3330 StartRecordJsonCallNum();
3331 AddDemoMember();
3332 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
3333 DestroyDeviceAuthService();
3334 DeleteDatabase();
3335 uint32_t mallocCount = GetJsonCallNum();
3336 printf("mock count: %u\n", mallocCount);
3337 for (int i = 0; i < mallocCount; i++) {
3338 ret = InitDeviceAuthService();
3339 ASSERT_EQ(ret, HC_SUCCESS);
3340 const DeviceGroupManager *gm = GetGmInstance();
3341 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
3342 ASSERT_EQ(ret, HC_SUCCESS);
3343 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
3344 if (g_asyncStatus != ASYNC_STATUS_FINISH) {
3345 DestroyDeviceAuthService();
3346 DeleteDatabase();
3347 continue;
3348 }
3349 ResetRecordJsonCallNum();
3350 SetJsonCallMockIndex(i);
3351 AddDemoMember();
3352 if (g_asyncStatus != ASYNC_STATUS_FINISH) {
3353 DestroyDeviceAuthService();
3354 DeleteDatabase();
3355 continue;
3356 }
3357 DestroyDeviceAuthService();
3358 }
3359 }
3360
3361 HWTEST_F(DevAuthTest, DevAuthTest002, TestSize.Level0)
3362 {
3363 int32_t ret = InitDeviceAuthService();
3364 ASSERT_EQ(ret, HC_SUCCESS);
3365 const DeviceGroupManager *gm = GetGmInstance();
3366 ASSERT_NE(gm, nullptr);
3367 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
3368 ASSERT_EQ(ret, HC_SUCCESS);
3369 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
3370 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
3371
3372 StartRecordJsonCallNum();
3373 ret = gm->checkAccessToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID);
3374 ASSERT_EQ(ret, HC_SUCCESS);
3375 uint32_t mallocCount = GetJsonCallNum();
3376 for (int i = 0; i < mallocCount; i++) {
3377 ResetRecordJsonCallNum();
3378 SetJsonCallMockIndex(i);
3379 ret = gm->checkAccessToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID);
3380 if (ret != HC_SUCCESS) {
3381 continue;
3382 }
3383 }
3384 DestroyDeviceAuthService();
3385 }
3386
3387 HWTEST_F(DevAuthTest, DevAuthTest003, TestSize.Level0)
3388 {
3389 int32_t ret = InitDeviceAuthService();
3390 ASSERT_EQ(ret, HC_SUCCESS);
3391 const DeviceGroupManager *gm = GetGmInstance();
3392 ASSERT_NE(gm, nullptr);
3393 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
3394 ASSERT_EQ(ret, HC_SUCCESS);
3395 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
3396 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
3397
3398 StartRecordJsonCallNum();
3399 char *returnData = nullptr;
3400 uint32_t returnNum = 0;
3401 const char *queryParams = "{\"udid\":\"5420459D93FE773F9945FD64277FBA2CAB8FB996DDC1D0B97676FBB1242"
3402 "B3930\",\"isSelfPk\":true}";
3403 ret = gm->getPkInfoList(DEFAULT_OS_ACCOUNT, TEST_APP_ID, queryParams, &returnData, &returnNum);
3404 ASSERT_EQ(ret, HC_SUCCESS);
3405 gm->destroyInfo(&returnData);
3406 uint32_t mallocCount = GetJsonCallNum();
3407 for (int i = 0; i < mallocCount; i++) {
3408 ResetRecordJsonCallNum();
3409 SetJsonCallMockIndex(i);
3410 ret = gm->getPkInfoList(DEFAULT_OS_ACCOUNT, TEST_APP_ID, queryParams, &returnData, &returnNum);
3411 if (ret != HC_SUCCESS) {
3412 continue;
3413 }
3414 gm->destroyInfo(&returnData);
3415 }
3416 DestroyDeviceAuthService();
3417 }
3418
3419 HWTEST_F(DevAuthTest, DevAuthTest004, TestSize.Level0)
3420 {
3421 int32_t ret = InitDeviceAuthService();
3422 ASSERT_EQ(ret, HC_SUCCESS);
3423 const DeviceGroupManager *gm = GetGmInstance();
3424 ASSERT_NE(gm, nullptr);
3425 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
3426 ASSERT_EQ(ret, HC_SUCCESS);
3427 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
3428 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
3429
3430 StartRecordJsonCallNum();
3431 char *returnData = nullptr;
3432 ret = gm->getGroupInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID, &returnData);
3433 ASSERT_EQ(ret, HC_SUCCESS);
3434 gm->destroyInfo(&returnData);
3435 uint32_t mallocCount = GetJsonCallNum();
3436 for (int i = 0; i < mallocCount; i++) {
3437 ResetRecordJsonCallNum();
3438 SetJsonCallMockIndex(i);
3439 ret = gm->getGroupInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID, &returnData);
3440 if (ret != HC_SUCCESS) {
3441 continue;
3442 }
3443 gm->destroyInfo(&returnData);
3444 }
3445 DestroyDeviceAuthService();
3446 }
3447
3448 HWTEST_F(DevAuthTest, DevAuthTest005, TestSize.Level0)
3449 {
3450 int32_t ret = InitDeviceAuthService();
3451 ASSERT_EQ(ret, HC_SUCCESS);
3452 const DeviceGroupManager *gm = GetGmInstance();
3453 ASSERT_NE(gm, nullptr);
3454 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
3455 ASSERT_EQ(ret, HC_SUCCESS);
3456 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
3457 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
3458
3459 StartRecordJsonCallNum();
3460 char *returnData = nullptr;
3461 uint32_t returnNum = 0;
3462 const char *queryParams = "{\"groupOwner\":\"TestAppId\"}";
3463 ret = gm->getGroupInfo(DEFAULT_OS_ACCOUNT, TEST_APP_ID, queryParams, &returnData, &returnNum);
3464 ASSERT_EQ(ret, HC_SUCCESS);
3465 gm->destroyInfo(&returnData);
3466 uint32_t mallocCount = GetJsonCallNum();
3467 for (int i = 0; i < mallocCount; i++) {
3468 ResetRecordJsonCallNum();
3469 SetJsonCallMockIndex(i);
3470 ret = gm->getGroupInfo(DEFAULT_OS_ACCOUNT, TEST_APP_ID, queryParams, &returnData, &returnNum);
3471 if (ret != HC_SUCCESS) {
3472 continue;
3473 }
3474 gm->destroyInfo(&returnData);
3475 }
3476 DestroyDeviceAuthService();
3477 }
3478
3479 HWTEST_F(DevAuthTest, DevAuthTest006, TestSize.Level0)
3480 {
3481 int32_t ret = InitDeviceAuthService();
3482 ASSERT_EQ(ret, HC_SUCCESS);
3483 const DeviceGroupManager *gm = GetGmInstance();
3484 ASSERT_NE(gm, nullptr);
3485 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
3486 ASSERT_EQ(ret, HC_SUCCESS);
3487 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
3488 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
3489
3490 StartRecordJsonCallNum();
3491 char *returnData = nullptr;
3492 uint32_t returnNum = 0;
3493 ret = gm->getJoinedGroups(DEFAULT_OS_ACCOUNT, TEST_APP_ID, PEER_TO_PEER_GROUP, &returnData, &returnNum);
3494 ASSERT_EQ(ret, HC_SUCCESS);
3495 gm->destroyInfo(&returnData);
3496 uint32_t mallocCount = GetJsonCallNum();
3497 for (int i = 0; i < mallocCount; i++) {
3498 ResetRecordJsonCallNum();
3499 SetJsonCallMockIndex(i);
3500 ret = gm->getJoinedGroups(DEFAULT_OS_ACCOUNT, TEST_APP_ID, PEER_TO_PEER_GROUP, &returnData, &returnNum);
3501 if (ret != HC_SUCCESS) {
3502 continue;
3503 }
3504 gm->destroyInfo(&returnData);
3505 }
3506 DestroyDeviceAuthService();
3507 }
3508
3509 HWTEST_F(DevAuthTest, DevAuthTest007, TestSize.Level0)
3510 {
3511 int32_t ret = InitDeviceAuthService();
3512 ASSERT_EQ(ret, HC_SUCCESS);
3513 const DeviceGroupManager *gm = GetGmInstance();
3514 ASSERT_NE(gm, nullptr);
3515 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
3516 ASSERT_EQ(ret, HC_SUCCESS);
3517 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
3518 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
3519
3520 StartRecordJsonCallNum();
3521 char *returnData = nullptr;
3522 uint32_t returnNum = 0;
3523 ret = gm->getRelatedGroups(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_AUTH_ID, &returnData, &returnNum);
3524 ASSERT_EQ(ret, HC_SUCCESS);
3525 gm->destroyInfo(&returnData);
3526 uint32_t mallocCount = GetJsonCallNum();
3527 for (int i = 0; i < mallocCount; i++) {
3528 ResetRecordJsonCallNum();
3529 SetJsonCallMockIndex(i);
3530 ret = gm->getRelatedGroups(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_AUTH_ID, &returnData, &returnNum);
3531 if (ret != HC_SUCCESS) {
3532 continue;
3533 }
3534 gm->destroyInfo(&returnData);
3535 }
3536 DestroyDeviceAuthService();
3537 }
3538
3539 HWTEST_F(DevAuthTest, DevAuthTest008, TestSize.Level0)
3540 {
3541 int32_t ret = InitDeviceAuthService();
3542 ASSERT_EQ(ret, HC_SUCCESS);
3543 const DeviceGroupManager *gm = GetGmInstance();
3544 ASSERT_NE(gm, nullptr);
3545 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
3546 ASSERT_EQ(ret, HC_SUCCESS);
3547 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
3548 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
3549
3550 StartRecordJsonCallNum();
3551 char *returnData = nullptr;
3552 ret = gm->getDeviceInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_AUTH_ID, TEST_GROUP_ID, &returnData);
3553 ASSERT_EQ(ret, HC_SUCCESS);
3554 gm->destroyInfo(&returnData);
3555 uint32_t mallocCount = GetJsonCallNum();
3556 for (int i = 0; i < mallocCount; i++) {
3557 ResetRecordJsonCallNum();
3558 SetJsonCallMockIndex(i);
3559 ret = gm->getDeviceInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_AUTH_ID, TEST_GROUP_ID, &returnData);
3560 if (ret != HC_SUCCESS) {
3561 continue;
3562 }
3563 gm->destroyInfo(&returnData);
3564 }
3565 DestroyDeviceAuthService();
3566 }
3567
3568 HWTEST_F(DevAuthTest, DevAuthTest009, TestSize.Level0)
3569 {
3570 int32_t ret = InitDeviceAuthService();
3571 ASSERT_EQ(ret, HC_SUCCESS);
3572 const DeviceGroupManager *gm = GetGmInstance();
3573 ASSERT_NE(gm, nullptr);
3574 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
3575 ASSERT_EQ(ret, HC_SUCCESS);
3576 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
3577 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
3578
3579 StartRecordJsonCallNum();
3580 char *returnData = nullptr;
3581 uint32_t returnNum = 0;
3582 ret = gm->getTrustedDevices(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID, &returnData, &returnNum);
3583 ASSERT_EQ(ret, HC_SUCCESS);
3584 gm->destroyInfo(&returnData);
3585 uint32_t mallocCount = GetJsonCallNum();
3586 for (int i = 0; i < mallocCount; i++) {
3587 ResetRecordJsonCallNum();
3588 SetJsonCallMockIndex(i);
3589 ret = gm->getTrustedDevices(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID, &returnData, &returnNum);
3590 if (ret != HC_SUCCESS) {
3591 continue;
3592 }
3593 gm->destroyInfo(&returnData);
3594 }
3595 DestroyDeviceAuthService();
3596 }
3597
3598 HWTEST_F(DevAuthTest, DevAuthTest010, TestSize.Level0)
3599 {
3600 SetIsoSupported(true);
3601 SetPakeV1Supported(false);
3602 int32_t ret = InitDeviceAuthService();
3603 ASSERT_EQ(ret, HC_SUCCESS);
3604 const DeviceGroupManager *gm = GetGmInstance();
3605 ASSERT_NE(gm, nullptr);
3606 ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
3607 ASSERT_EQ(ret, HC_SUCCESS);
3608 CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, g_createParams);
3609 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
3610
3611 StartRecordJsonCallNum();
3612 bool isExist = gm->isDeviceInGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID, TEST_AUTH_ID);
3613 ASSERT_EQ(isExist, true);
3614 uint32_t mallocCount = GetJsonCallNum();
3615 for (int i = 0; i < mallocCount; i++) {
3616 ResetRecordJsonCallNum();
3617 SetJsonCallMockIndex(i);
3618 isExist = gm->isDeviceInGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID, TEST_AUTH_ID);
3619 if (!isExist) {
3620 continue;
3621 }
3622 }
3623 DestroyDeviceAuthService();
3624 }
3625
3626 class ExtPartTest : public testing::Test {
3627 public:
3628 static void SetUpTestCase();
3629 static void TearDownTestCase();
3630 void SetUp();
3631 void TearDown();
3632 ExtPart *extPart;
3633 };
3634
SetUpTestCase()3635 void ExtPartTest::SetUpTestCase() {}
TearDownTestCase()3636 void ExtPartTest::TearDownTestCase() {}
3637
SetUp()3638 void ExtPartTest::SetUp()
3639 {
3640 int ret = InitDeviceAuthService();
3641 EXPECT_EQ(ret, HC_SUCCESS);
3642 extPart = reinterpret_cast<ExtPart *>(HcMalloc(sizeof(ExtPart), 0));
3643 ASSERT_NE(extPart, nullptr);
3644 }
3645
TearDown()3646 void ExtPartTest::TearDown()
3647 {
3648 DestroyDeviceAuthService();
3649 HcFree(extPart);
3650 }
3651
3652 HWTEST_F(ExtPartTest, ExtPartTestTest001, TestSize.Level0)
3653 {
3654 int ret = InitExtPart(nullptr, extPart);
3655 EXPECT_EQ(ret, HC_SUCCESS);
3656 }
3657
3658 HWTEST_F(ExtPartTest, ExtPartTestTest002, TestSize.Level0)
3659 {
3660 ExtPluginList list = GetExtPlugins(extPart);
3661 ASSERT_NE(list, nullptr);
3662 }
3663
3664 HWTEST_F(ExtPartTest, ExtPartTestTest003, TestSize.Level0)
3665 {
3666 DestroyExtPart(extPart);
3667 ASSERT_TRUE(extPart->instance == nullptr);
3668 }
3669 }
3670