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_REQ_ID3 132
39 #define TEST_REQ_ID4 213
40 #define TEST_APP_ID "TestAppId"
41 #define TEST_APP_ID2 "TestAppId2"
42 #define TEST_GROUP_NAME "TestGroup"
43 #define TEST_AUTH_ID "TestAuthId"
44 #define TEST_AUTH_ID2 "TestAuthId2"
45 #define TEST_AUTH_ID3 "TestAuthId3"
46 #define TEST_UDID "TestUdid"
47 #define TEST_UDID2 "TestUdid2"
48 #define TEST_UDID_CLIENT "5420459D93FE773F9945FD64277FBA2CAB8FB996DDC1D0B97676FBB1242B3930"
49 #define TEST_UDID_SERVER "52E2706717D5C39D736E134CC1E3BE1BAA2AA52DB7C76A37C749558BD2E6492C"
50 #define TEST_USER_ID_AUTH "4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4"
51 #define TEST_USER_ID "1234ABCD"
52 #define TEST_USER_ID2 "DCBA4321"
53 #define TEST_GROUP_ID "E2EE6F830B176B2C96A9F99BFAE2A61F5D1490B9F4A090E9D8C2874C230C7C21"
54 #define TEST_GROUP_ID2 "F2AA208B1E010542B20A34B03B4B6289EA7C7F6DFE97DA2E370348B826682D3D"
55 #define TEST_GROUP_ID3 "1234ABCD"
56 #define TEST_GROUP_ID4 "6B7B805962B8EB8275D73128BFDAA7ECD755A2EC304E36543941874A277FA75F"
57 #define TEST_AUTH_CODE "37364761534f454d33567a73424e794f33573330507069434b31676f7254706b"
58 #define TEST_AUTH_CODE2 "2f7562744654535564586e665467546b322b4b506b65626373466f48766a4335"
59 #define TEST_AUTH_CODE3 "1234567812345678123456781234567812345678123456781234567812345678"
60 #define TEST_AUTH_TOKEN3 "10F9F0576E61730193D2052B7F771887124A68F1607EFCF7796C1491F834CD92"
61 #define TEST_QUERY_PARAMS "bac"
62 #define TEST_PIN_CODE "123456"
63 #define TEST_GROUP_DATA_PATH "/data/service/el1/public/deviceauthMock"
64 #define TEST_HKS_MAIN_DATA_PATH "/data/service/el1/public/huks_service/tmp/+0+0+0+0"
65 #define TEST_DEV_AUTH_TEMP_KEY_PAIR_LEN 32
66 #define TEST_DEV_AUTH_SLEEP_TIME 50000
67 #define TEST_DEV_AUTH_SLEEP_TIME2 60000
68 static const int32_t TEST_AUTH_OS_ACCOUNT_ID = 100;
69 static const int TEST_DEV_AUTH_BUFFER_SIZE = 128;
70 static const char *INVALID_JSON_STR = "invalid json format";
71 static const char *CREATE_PARAMS = "{\"groupName\":\"TestGroup\",\"deviceId\":\"TestAuthId\",\"groupType\":256,\"group"
72     "Visibility\":-1,\"userType\":0,\"expireTime\":-1}";
73 static const char *CREATE_PARAMS3 = "{\"groupType\":1282,\"userId\":\"1234ABCD\",\"peerUserId\":\"DCBA4321\"}";
74 static const char *DISBAND_PARAMS =
75     "{\"groupId\":\"E2EE6F830B176B2C96A9F99BFAE2A61F5D1490B9F4A090E9D8C2874C230C7C21\"}";
76 static const char *DISBAND_PARAMS2 = "{\"groupId\":\"1234ABCD\"}";
77 static const char *DISBAND_PARAMS3 =
78     "{\"groupId\":\"6B7B805962B8EB8275D73128BFDAA7ECD755A2EC304E36543941874A277FA75F\"}";
79 static const char *ADD_PARAMS =
80     "{\"groupId\":\"E2EE6F830B176B2C96A9F99BFAE2A61F5D1490B9F4A090E9D8C2874C230C7C21\","
81     "\"groupType\":256,\"pinCode\":\"123456\"}";
82 static const char *ADD_PARAMS2 =
83     "{\"groupType\":1,\"groupId\":\"1234ABCD\","
84     "\"deviceList\":[{\"deviceId\":\"TestAuthId2\",\"udid\":\"TestUdid\",\"userId\":\"1234ABCD\","
85     "\"credential\":{\"credentialType\":1,"
86     "\"authCode\":\"37364761534f454d33567a73424e794f33573330507069434b31676f7254706b\"}},"
87     "{\"deviceId\":\"TestAuthId3\",\"udid\":\"TestUdid2\",\"userId\":\"1234ABCD\","
88     "\"credential\":{\"credentialType\":1,"
89     "\"authCode\":\"2f7562744654535564586e665467546b322b4b506b65626373466f48766a4335\"}}]}";
90 static const char *ADD_PARAMS3 =
91     "{\"groupType\":1282,\"groupId\":\"6B7B805962B8EB8275D73128BFDAA7ECD755A2EC304E36543941874A277FA75F\","
92     "\"deviceList\":[{\"deviceId\":\"TestAuthId2\",\"udid\":\"TestUdid\",\"userId\":\"DCBA4321\","
93     "\"credential\":{\"credentialType\":1,"
94     "\"authCode\":\"37364761534f454d33567a73424e794f33573330507069434b31676f7254706b\"}},"
95     "{\"deviceId\":\"TestAuthId3\",\"udid\":\"TestUdid2\",\"userId\":\"DCBA4321\","
96     "\"credential\":{\"credentialType\":1,"
97     "\"authCode\":\"2f7562744654535564586e665467546b322b4b506b65626373466f48766a4335\"}}]}";
98 static const char *ADD_PARAMS4 =
99     "{\"groupType\":1,\"groupId\":\"4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4\","
100     "\"deviceList\":[{\"deviceId\":\"52E2706717D5C39D736E134CC1E3BE1BAA2AA52DB7C76A37C749558BD2E6492C\","
101     "\"udid\":\"52E2706717D5C39D736E134CC1E3BE1BAA2AA52DB7C76A37C749558BD2E6492C\","
102     "\"userId\":\"4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4\","
103     "\"credential\":{\"credentialType\":1,"
104     "\"authCode\":\"10F9F0576E61730193D2052B7F771887124A68F1607EFCF7796C1491F834CD92\"}},"
105     "{\"deviceId\":\"TestAuthId3\",\"udid\":\"TestUdid2\","
106     "\"userId\":\"4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4\","
107     "\"credential\":{\"credentialType\":1,"
108     "\"authCode\":\"2f7562744654535564586e665467546b322b4b506b65626373466f48766a4335\"}}]}";
109 static const char *ADD_PARAMS5 =
110     "{\"groupType\":1,\"groupId\":\"4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4\","
111     "\"deviceList\":[{\"deviceId\":\"5420459D93FE773F9945FD64277FBA2CAB8FB996DDC1D0B97676FBB1242B3930\","
112     "\"udid\":\"5420459D93FE773F9945FD64277FBA2CAB8FB996DDC1D0B97676FBB1242B3930\","
113     "\"userId\":\"4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4\","
114     "\"credential\":{\"credentialType\":1,"
115     "\"authCode\":\"10F9F0576E61730193D2052B7F771887124A68F1607EFCF7796C1491F834CD92\"}},"
116     "{\"deviceId\":\"TestAuthId3\",\"udid\":\"TestUdid2\","
117     "\"userId\":\"4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4\","
118     "\"credential\":{\"credentialType\":1,"
119     "\"authCode\":\"2f7562744654535564586e665467546b322b4b506b65626373466f48766a4335\"}}]}";
120 static const char *DELETE_PARAMS2 =
121     "{\"groupType\":1,\"groupId\":\"1234ABCD\","
122     "\"deviceList\":[{\"deviceId\":\"TestAuthId2\"},{\"deviceId\":\"TestAuthId3\"}]}";
123 static const char *DELETE_PARAMS3 =
124     "{\"groupType\":1282,\"groupId\":\"6B7B805962B8EB8275D73128BFDAA7ECD755A2EC304E36543941874A277FA75F\","
125     "\"deviceList\":[{\"deviceId\":\"TestAuthId2\"},{\"deviceId\":\"TestAuthId3\"}]}";
126 static const char *GET_REG_INFO_PARAMS =
127     "{\"version\":\"1.0.0\",\"deviceId\":\"TestAuthId\",\"userId\":\"1234ABCD\"}";
128 static const char *AUTH_PARAMS = "{\"peerConnDeviceId\":\"52E2706717D5C39D736E134CC1E3BE1BAA2AA52DB7C76A37C"
129     "749558BD2E6492C\",\"servicePkgName\":\"TestAppId\",\"isClient\":true}";
130 
131 enum AsyncStatus {
132     ASYNC_STATUS_WAITING = 0,
133     ASYNC_STATUS_TRANSMIT = 1,
134     ASYNC_STATUS_FINISH = 2,
135     ASYNC_STATUS_ERROR = 3
136 };
137 
138 static AsyncStatus volatile g_asyncStatus;
139 static uint32_t g_transmitDataMaxLen = 2048;
140 static uint8_t g_transmitData[2048] = { 0 };
141 static uint32_t g_transmitDataLen = 0;
142 
OnTransmit(int64_t requestId,const uint8_t * data,uint32_t dataLen)143 static bool OnTransmit(int64_t requestId, const uint8_t *data, uint32_t dataLen)
144 {
145     if (memcpy_s(g_transmitData, g_transmitDataMaxLen, data, dataLen) != EOK) {
146         return false;
147     }
148     g_transmitDataLen = dataLen;
149     g_asyncStatus = ASYNC_STATUS_TRANSMIT;
150     return true;
151 }
152 
OnSessionKeyReturned(int64_t requestId,const uint8_t * sessionKey,uint32_t sessionKeyLen)153 static void OnSessionKeyReturned(int64_t requestId, const uint8_t *sessionKey, uint32_t sessionKeyLen)
154 {
155     (void)requestId;
156     (void)sessionKey;
157     (void)sessionKeyLen;
158     return;
159 }
160 
OnFinish(int64_t requestId,int operationCode,const char * authReturn)161 static void OnFinish(int64_t requestId, int operationCode, const char *authReturn)
162 {
163     g_asyncStatus = ASYNC_STATUS_FINISH;
164 }
165 
OnError(int64_t requestId,int operationCode,int errorCode,const char * errorReturn)166 static void OnError(int64_t requestId, int operationCode, int errorCode, const char *errorReturn)
167 {
168     g_asyncStatus = ASYNC_STATUS_ERROR;
169 }
170 
OnBindRequest(int64_t requestId,int operationCode,const char * reqParam)171 static char *OnBindRequest(int64_t requestId, int operationCode, const char* reqParam)
172 {
173     CJson *json = CreateJson();
174     AddIntToJson(json, FIELD_CONFIRMATION, REQUEST_ACCEPTED);
175     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, TEST_AUTH_OS_ACCOUNT_ID);
176     AddStringToJson(json, FIELD_PIN_CODE, TEST_PIN_CODE);
177     AddStringToJson(json, FIELD_DEVICE_ID, TEST_AUTH_ID2);
178     char *returnDataStr = PackJsonToString(json);
179     FreeJson(json);
180     return returnDataStr;
181 }
182 
OnAuthRequest(int64_t requestId,int operationCode,const char * reqParam)183 static char *OnAuthRequest(int64_t requestId, int operationCode, const char* reqParam)
184 {
185     CJson *json = CreateJson();
186     AddIntToJson(json, FIELD_CONFIRMATION, REQUEST_ACCEPTED);
187     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, TEST_AUTH_OS_ACCOUNT_ID);
188     AddStringToJson(json, FIELD_PEER_CONN_DEVICE_ID, TEST_UDID_CLIENT);
189     AddStringToJson(json, FIELD_SERVICE_PKG_NAME, TEST_APP_ID);
190     char *returnDataStr = PackJsonToString(json);
191     FreeJson(json);
192     return returnDataStr;
193 }
194 
195 static DeviceAuthCallback g_gmCallback = {
196     .onTransmit = OnTransmit,
197     .onSessionKeyReturned = OnSessionKeyReturned,
198     .onFinish = OnFinish,
199     .onError = OnError,
200     .onRequest = OnBindRequest
201 };
202 
203 static DeviceAuthCallback g_gaCallback = {
204     .onTransmit = OnTransmit,
205     .onSessionKeyReturned = OnSessionKeyReturned,
206     .onFinish = OnFinish,
207     .onError = OnError,
208     .onRequest = OnAuthRequest
209 };
210 
RemoveDir(const char * path)211 static void RemoveDir(const char *path)
212 {
213     char strBuf[TEST_DEV_AUTH_BUFFER_SIZE] = {0};
214     if (path == nullptr) {
215         return;
216     }
217     if (sprintf_s(strBuf, sizeof(strBuf) - 1, "rm -rf %s", path) < 0) {
218         return;
219     }
220     system(strBuf);
221 }
222 
DeleteDatabase()223 static void DeleteDatabase()
224 {
225     RemoveDir(TEST_GROUP_DATA_PATH);
226     RemoveDir(TEST_HKS_MAIN_DATA_PATH);
227 }
228 
GenerateTempKeyPair(Uint8Buff * keyAlias)229 static bool GenerateTempKeyPair(Uint8Buff *keyAlias)
230 {
231     int ret = GetLoaderInstance()->checkKeyExist(keyAlias, false, DEFAULT_OS_ACCOUNT);
232     if (ret != HC_SUCCESS) {
233         printf("Key pair not exist, start to generate\n");
234         int32_t authId = 0;
235         Uint8Buff authIdBuff = { reinterpret_cast<uint8_t *>(&authId), sizeof(int32_t)};
236         ExtraInfo extInfo = {authIdBuff, -1, -1};
237         KeyParams keyParams = { { keyAlias->val, keyAlias->length, true }, false, DEFAULT_OS_ACCOUNT };
238         ret = GetLoaderInstance()->generateKeyPairWithStorage(&keyParams, TEST_DEV_AUTH_TEMP_KEY_PAIR_LEN, P256,
239             KEY_PURPOSE_SIGN_VERIFY, &extInfo);
240     } else {
241         printf("Server key pair already exists\n");
242     }
243 
244     if (ret != HC_SUCCESS) {
245         printf("Generate key pair failed\n");
246         return false;
247     } else {
248         printf("Generate key pair for server success\n");
249     }
250     return true;
251 }
252 
GetAsyCredentialJson(string registerInfo)253 static CJson *GetAsyCredentialJson(string registerInfo)
254 {
255     uint8_t keyAliasValue[] = "TestServerKeyPair";
256     int32_t keyAliasLen = 18;
257     Uint8Buff keyAlias = {
258         .val = keyAliasValue,
259         .length = keyAliasLen
260     };
261     if (!GenerateTempKeyPair(&keyAlias)) {
262         return nullptr;
263     }
264     uint8_t *serverPkVal = reinterpret_cast<uint8_t *>(HcMalloc(SERVER_PK_SIZE, 0));
265     Uint8Buff serverPk = {
266         .val = serverPkVal,
267         .length = SERVER_PK_SIZE
268     };
269 
270     KeyParams keyAliasParams = { { keyAlias.val, keyAlias.length, true }, false, DEFAULT_OS_ACCOUNT };
271     int32_t ret = GetLoaderInstance()->exportPublicKey(&keyAliasParams, &serverPk);
272     if (ret != HC_SUCCESS) {
273         printf("export PublicKey failed\n");
274         HcFree(serverPkVal);
275         return nullptr;
276     }
277 
278     Uint8Buff messageBuff = {
279         .val = reinterpret_cast<uint8_t *>(const_cast<char *>(registerInfo.c_str())),
280         .length = registerInfo.length() + 1
281     };
282     uint8_t *signatureValue = reinterpret_cast<uint8_t *>(HcMalloc(SIGNATURE_SIZE, 0));
283     Uint8Buff signature = {
284         .val = signatureValue,
285         .length = SIGNATURE_SIZE
286     };
287     ret = GetLoaderInstance()->sign(&keyAliasParams, &messageBuff, P256, &signature);
288     if (ret != HC_SUCCESS) {
289         printf("Sign pkInfo failed.\n");
290         HcFree(serverPkVal);
291         HcFree(signatureValue);
292         return nullptr;
293     }
294 
295     CJson *pkInfoJson = CreateJsonFromString(registerInfo.c_str());
296     CJson *credentialJson = CreateJson();
297     (void)AddIntToJson(credentialJson, FIELD_CREDENTIAL_TYPE, ASYMMETRIC_CRED);
298     (void)AddByteToJson(credentialJson, FIELD_SERVER_PK, serverPkVal, serverPk.length);
299     (void)AddByteToJson(credentialJson, FIELD_PK_INFO_SIGNATURE, signatureValue, signature.length);
300     (void)AddObjToJson(credentialJson, FIELD_PK_INFO, pkInfoJson);
301     FreeJson(pkInfoJson);
302     return credentialJson;
303 }
304 
CreateDemoGroup(int32_t osAccountId,int64_t reqId,const char * appId,const char * createParams)305 static void CreateDemoGroup(int32_t osAccountId, int64_t reqId, const char *appId, const char *createParams)
306 {
307     g_asyncStatus = ASYNC_STATUS_WAITING;
308     const DeviceGroupManager *gm = GetGmInstance();
309     int32_t ret = gm->createGroup(osAccountId, reqId, appId, createParams);
310     if (ret != HC_SUCCESS) {
311         g_asyncStatus = ASYNC_STATUS_ERROR;
312         return;
313     }
314     while (g_asyncStatus == ASYNC_STATUS_WAITING) {
315         usleep(TEST_DEV_AUTH_SLEEP_TIME);
316     }
317     usleep(TEST_DEV_AUTH_SLEEP_TIME);
318 }
319 
CreateDemoIdenticalAccountGroup()320 static void CreateDemoIdenticalAccountGroup()
321 {
322     g_asyncStatus = ASYNC_STATUS_WAITING;
323     const DeviceGroupManager *gm = GetGmInstance();
324     ASSERT_NE(gm, nullptr);
325     char *returnData = nullptr;
326     int32_t ret = gm->getRegisterInfo(GET_REG_INFO_PARAMS, &returnData);
327     ASSERT_EQ(ret, HC_SUCCESS);
328     ASSERT_NE(returnData, nullptr);
329     string registerInfo(returnData);
330 
331     CJson *credJson = GetAsyCredentialJson(registerInfo);
332     ASSERT_NE(credJson, nullptr);
333     CJson *json = CreateJson();
334     AddIntToJson(json, FIELD_GROUP_TYPE, IDENTICAL_ACCOUNT_GROUP);
335     AddStringToJson(json, FIELD_USER_ID, TEST_USER_ID);
336     AddObjToJson(json, FIELD_CREDENTIAL, credJson);
337     char *jsonStr = PackJsonToString(json);
338     FreeJson(credJson);
339     FreeJson(json);
340     gm->destroyInfo(&returnData);
341     ASSERT_NE(jsonStr, nullptr);
342     ret = gm->createGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, jsonStr);
343     FreeJsonString(jsonStr);
344     ASSERT_EQ(ret, HC_SUCCESS);
345     while (g_asyncStatus == ASYNC_STATUS_WAITING) {
346         usleep(TEST_DEV_AUTH_SLEEP_TIME);
347     }
348 }
349 
CreateDemoSymClientIdenticalAccountGroup(void)350 static void CreateDemoSymClientIdenticalAccountGroup(void)
351 {
352     g_asyncStatus = ASYNC_STATUS_WAITING;
353     const DeviceGroupManager *gm = GetGmInstance();
354     ASSERT_NE(gm, nullptr);
355 
356     CJson *credJson = CreateJson();
357     (void)AddIntToJson(credJson, FIELD_CREDENTIAL_TYPE, SYMMETRIC_CRED);
358     (void)AddStringToJson(credJson, FIELD_AUTH_CODE, TEST_AUTH_CODE3);
359     CJson *json = CreateJson();
360     AddIntToJson(json, FIELD_GROUP_TYPE, IDENTICAL_ACCOUNT_GROUP);
361     AddStringToJson(json, FIELD_USER_ID, TEST_USER_ID_AUTH);
362     AddObjToJson(json, FIELD_CREDENTIAL, credJson);
363     char *jsonStr = PackJsonToString(json);
364     FreeJson(credJson);
365     FreeJson(json);
366     if (jsonStr == nullptr) {
367         return;
368     }
369     int32_t ret = gm->createGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, jsonStr);
370     FreeJsonString(jsonStr);
371     ASSERT_EQ(ret, HC_SUCCESS);
372     while (g_asyncStatus == ASYNC_STATUS_WAITING) {
373         usleep(TEST_DEV_AUTH_SLEEP_TIME);
374     }
375     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
376 }
377 
CreateDemoSymServerIdenticalAccountGroup(void)378 static void CreateDemoSymServerIdenticalAccountGroup(void)
379 {
380     g_asyncStatus = ASYNC_STATUS_WAITING;
381     const DeviceGroupManager *gm = GetGmInstance();
382     ASSERT_NE(gm, nullptr);
383 
384     CJson *credJson = CreateJson();
385     (void)AddIntToJson(credJson, FIELD_CREDENTIAL_TYPE, SYMMETRIC_CRED);
386     (void)AddStringToJson(credJson, FIELD_AUTH_CODE, TEST_AUTH_CODE3);
387     CJson *json = CreateJson();
388     AddIntToJson(json, FIELD_GROUP_TYPE, IDENTICAL_ACCOUNT_GROUP);
389     AddStringToJson(json, FIELD_USER_ID, TEST_USER_ID_AUTH);
390     AddObjToJson(json, FIELD_CREDENTIAL, credJson);
391     char *jsonStr = PackJsonToString(json);
392     FreeJson(credJson);
393     FreeJson(json);
394     if (jsonStr == nullptr) {
395         return;
396     }
397 
398     int32_t ret = gm->createGroup(TEST_AUTH_OS_ACCOUNT_ID, TEST_REQ_ID, TEST_APP_ID, jsonStr);
399     FreeJsonString(jsonStr);
400     ASSERT_EQ(ret, HC_SUCCESS);
401     while (g_asyncStatus == ASYNC_STATUS_WAITING) {
402         usleep(TEST_DEV_AUTH_SLEEP_TIME);
403     }
404     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
405 }
406 
CreateDemoAcrossAccountGroup(int32_t osAccountId,int64_t reqId,const char * appId,const char * createParams)407 static void CreateDemoAcrossAccountGroup(int32_t osAccountId, int64_t reqId, const char *appId,
408     const char *createParams)
409 {
410     g_asyncStatus = ASYNC_STATUS_WAITING;
411     const DeviceGroupManager *gm = GetGmInstance();
412     ASSERT_NE(gm, nullptr);
413     int32_t ret = gm->createGroup(osAccountId, reqId, appId, createParams);
414     ASSERT_EQ(ret, HC_SUCCESS);
415     while (g_asyncStatus == ASYNC_STATUS_WAITING) {
416         usleep(TEST_DEV_AUTH_SLEEP_TIME);
417     }
418 }
419 
DeleteDemoGroup(int32_t osAccountId,int64_t reqId,const char * appId,const char * disbandParams)420 static void DeleteDemoGroup(int32_t osAccountId, int64_t reqId, const char *appId,
421     const char *disbandParams)
422 {
423     g_asyncStatus = ASYNC_STATUS_WAITING;
424     const DeviceGroupManager *gm = GetGmInstance();
425     ASSERT_NE(gm, nullptr);
426     int32_t ret = gm->deleteGroup(osAccountId, reqId, appId, disbandParams);
427     ASSERT_EQ(ret, HC_SUCCESS);
428     while (g_asyncStatus == ASYNC_STATUS_WAITING) {
429         usleep(TEST_DEV_AUTH_SLEEP_TIME);
430     }
431 }
432 
DeleteDemoIdenticalAccountGroup(void)433 static void DeleteDemoIdenticalAccountGroup(void)
434 {
435     g_asyncStatus = ASYNC_STATUS_WAITING;
436     const DeviceGroupManager *gm = GetGmInstance();
437     ASSERT_NE(gm, nullptr);
438     int32_t ret = gm->deleteGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, DISBAND_PARAMS2);
439     ASSERT_EQ(ret, HC_SUCCESS);
440     while (g_asyncStatus == ASYNC_STATUS_WAITING) {
441         usleep(TEST_DEV_AUTH_SLEEP_TIME);
442     }
443     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
444 }
445 
DeleteDemoAcrossAccountGroup(void)446 static void DeleteDemoAcrossAccountGroup(void)
447 {
448     g_asyncStatus = ASYNC_STATUS_WAITING;
449     const DeviceGroupManager *gm = GetGmInstance();
450     ASSERT_NE(gm, nullptr);
451     int32_t ret = gm->deleteGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, DISBAND_PARAMS3);
452     ASSERT_EQ(ret, HC_SUCCESS);
453     while (g_asyncStatus == ASYNC_STATUS_WAITING) {
454         usleep(TEST_DEV_AUTH_SLEEP_TIME);
455     }
456     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
457 }
458 
AddDemoMember(void)459 static void AddDemoMember(void)
460 {
461     g_asyncStatus = ASYNC_STATUS_WAITING;
462     bool isClient = true;
463     SetDeviceStatus(isClient);
464     const DeviceGroupManager *gm = GetGmInstance();
465     int32_t ret = gm->addMemberToGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, ADD_PARAMS);
466     if (ret != HC_SUCCESS) {
467         g_asyncStatus = ASYNC_STATUS_ERROR;
468         return;
469     }
470     while (g_asyncStatus == ASYNC_STATUS_WAITING) {
471         usleep(TEST_DEV_AUTH_SLEEP_TIME);
472     }
473     while (g_asyncStatus == ASYNC_STATUS_TRANSMIT) {
474         isClient = !isClient;
475         SetDeviceStatus(isClient);
476         g_asyncStatus = ASYNC_STATUS_WAITING;
477         uint8_t tmpTransmitData[2048] = { 0 };
478         uint32_t tmpTransmitDataLen = 0;
479         if (memcpy_s(tmpTransmitData, sizeof(tmpTransmitData), g_transmitData, g_transmitDataLen) != EOK) {
480             g_asyncStatus = ASYNC_STATUS_ERROR;
481             return;
482         }
483         tmpTransmitDataLen = g_transmitDataLen;
484         (void)memset_s(g_transmitData, g_transmitDataMaxLen, 0, g_transmitDataMaxLen);
485         g_transmitDataLen = 0;
486         if (isClient) {
487             ret = gm->processData(TEST_REQ_ID, tmpTransmitData, tmpTransmitDataLen);
488         } else {
489             ret = gm->processData(TEST_REQ_ID2, tmpTransmitData, tmpTransmitDataLen);
490         }
491         if (ret != HC_SUCCESS) {
492             g_asyncStatus = ASYNC_STATUS_ERROR;
493             return;
494         }
495         while (g_asyncStatus == ASYNC_STATUS_WAITING) {
496             usleep(TEST_DEV_AUTH_SLEEP_TIME);
497         }
498         if (g_asyncStatus == ASYNC_STATUS_ERROR) {
499             break;
500         }
501         if (g_transmitDataLen > 0) {
502             g_asyncStatus = ASYNC_STATUS_TRANSMIT;
503         }
504     }
505     usleep(TEST_DEV_AUTH_SLEEP_TIME2);
506     SetDeviceStatus(true);
507 }
508 
AuthDemoMember(void)509 static void AuthDemoMember(void)
510 {
511     g_asyncStatus = ASYNC_STATUS_WAITING;
512     bool isClient = true;
513     SetDeviceStatus(isClient);
514     const GroupAuthManager *ga = GetGaInstance();
515     ASSERT_NE(ga, nullptr);
516     int32_t ret = ga->authDevice(DEFAULT_OS_ACCOUNT, TEST_REQ_ID3, AUTH_PARAMS, &g_gaCallback);
517     if (ret != HC_SUCCESS) {
518         g_asyncStatus = ASYNC_STATUS_ERROR;
519         return;
520     }
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 = ga->processData(TEST_REQ_ID3, g_transmitData, g_transmitDataLen, &g_gaCallback);
530         } else {
531             ret = ga->processData(TEST_REQ_ID4, g_transmitData, g_transmitDataLen, &g_gaCallback);
532         }
533         (void)memset_s(g_transmitData, g_transmitDataMaxLen, 0, g_transmitDataMaxLen);
534         g_transmitDataLen = 0;
535         if (ret != HC_SUCCESS) {
536             g_asyncStatus = ASYNC_STATUS_ERROR;
537             return;
538         }
539         while (g_asyncStatus == ASYNC_STATUS_WAITING) {
540             usleep(TEST_DEV_AUTH_SLEEP_TIME);
541         }
542         if (g_asyncStatus == ASYNC_STATUS_ERROR) {
543             break;
544         }
545         if (g_transmitDataLen > 0) {
546             g_asyncStatus = ASYNC_STATUS_TRANSMIT;
547         }
548     }
549     SetDeviceStatus(true);
550 }
551 
552 class GmProcessDataTest : public testing::Test {
553 public:
554     static void SetUpTestCase();
555     static void TearDownTestCase();
556     void SetUp();
557     void TearDown();
558 };
559 
SetUpTestCase()560 void GmProcessDataTest::SetUpTestCase() {}
TearDownTestCase()561 void GmProcessDataTest::TearDownTestCase() {}
562 
SetUp()563 void GmProcessDataTest::SetUp()
564 {
565     int ret = InitDeviceAuthService();
566     EXPECT_EQ(ret, HC_SUCCESS);
567 }
568 
TearDown()569 void GmProcessDataTest::TearDown()
570 {
571     DestroyDeviceAuthService();
572 }
573 
574 HWTEST_F(GmProcessDataTest, GmProcessDataTest002, TestSize.Level0)
575 {
576     const DeviceGroupManager *gm = GetGmInstance();
577     EXPECT_NE(gm, nullptr);
578     int32_t ret = gm->processData(TEST_REQ_ID, nullptr, 0);
579     EXPECT_NE(ret, HC_SUCCESS);
580 }
581 
582 class GmAddMultiMembersToGroupTest : public testing::Test {
583 public:
584     static void SetUpTestCase();
585     static void TearDownTestCase();
586     void SetUp();
587     void TearDown();
588 };
589 
SetUpTestCase()590 void GmAddMultiMembersToGroupTest::SetUpTestCase() {}
TearDownTestCase()591 void GmAddMultiMembersToGroupTest::TearDownTestCase() {}
592 
SetUp()593 void GmAddMultiMembersToGroupTest::SetUp()
594 {
595     DeleteDatabase();
596     int ret = InitDeviceAuthService();
597     EXPECT_EQ(ret, HC_SUCCESS);
598 }
599 
TearDown()600 void GmAddMultiMembersToGroupTest::TearDown()
601 {
602     DestroyDeviceAuthService();
603 }
604 
605 HWTEST_F(GmAddMultiMembersToGroupTest, GmAddMultiMembersToGroupTest001, TestSize.Level0)
606 {
607     const DeviceGroupManager *gm = GetGmInstance();
608     ASSERT_NE(gm, nullptr);
609     int32_t ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, nullptr, TEST_QUERY_PARAMS);
610     ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
611 }
612 
613 HWTEST_F(GmAddMultiMembersToGroupTest, GmAddMultiMembersToGroupTest002, TestSize.Level0)
614 {
615     const DeviceGroupManager *gm = GetGmInstance();
616     ASSERT_NE(gm, nullptr);
617     int32_t ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, nullptr);
618     ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
619 }
620 
621 HWTEST_F(GmAddMultiMembersToGroupTest, GmAddMultiMembersToGroupTest003, TestSize.Level0)
622 {
623     const DeviceGroupManager *gm = GetGmInstance();
624     ASSERT_NE(gm, nullptr);
625     int32_t ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, INVALID_JSON_STR);
626     ASSERT_NE(ret, HC_SUCCESS);
627 }
628 
629 HWTEST_F(GmAddMultiMembersToGroupTest, GmAddMultiMembersToGroupTest004, TestSize.Level0)
630 {
631     const DeviceGroupManager *gm = GetGmInstance();
632     ASSERT_NE(gm, nullptr);
633     const char *addParams =
634     "\"groupId\":\"1234ABCD\","
635     "\"deviceList\":[{\"deviceId\":\"TestAuthId2\",\"udid\":\"TestUdid\",\"userId\":\"1234ABCD\","
636     "\"credential\":{\"credentialType\":1,"
637     "\"authCode\":\"37364761534f454d33567a73424e794f33573330507069434b31676f7254706b\"}},"
638     "{\"deviceId\":\"TestAuthId3\",\"udid\":\"TestUdid2\",\"userId\":\"1234ABCD\","
639     "\"credential\":{\"credentialType\":1,"
640     "\"authCode\":\"2f7562744654535564586e665467546b322b4b506b65626373466f48766a4335\"}}]}";
641     int32_t ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, addParams);
642     ASSERT_NE(ret, HC_SUCCESS);
643 }
644 
645 HWTEST_F(GmAddMultiMembersToGroupTest, GmAddMultiMembersToGroupTest005, TestSize.Level0)
646 {
647     const DeviceGroupManager *gm = GetGmInstance();
648     ASSERT_NE(gm, nullptr);
649     const char *addParams =
650     "{\"groupType\":1132123,\"groupId\":\"1234ABCD\","
651     "\"deviceList\":[{\"deviceId\":\"TestAuthId2\",\"udid\":\"TestUdid\",\"userId\":\"1234ABCD\","
652     "\"credential\":{\"credentialType\":1,"
653     "\"authCode\":\"37364761534f454d33567a73424e794f33573330507069434b31676f7254706b\"}},"
654     "{\"deviceId\":\"TestAuthId3\",\"udid\":\"TestUdid2\",\"userId\":\"1234ABCD\","
655     "\"credential\":{\"credentialType\":1,"
656     "\"authCode\":\"2f7562744654535564586e665467546b322b4b506b65626373466f48766a4335\"}}]}";
657     int32_t ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, addParams);
658     ASSERT_NE(ret, HC_SUCCESS);
659 }
660 
661 HWTEST_F(GmAddMultiMembersToGroupTest, GmAddMultiMembersToGroupTest006, TestSize.Level0)
662 {
663     const DeviceGroupManager *gm = GetGmInstance();
664     ASSERT_NE(gm, nullptr);
665     const char *addParams =
666     "{\"groupType\":256,\"groupId\":\"1234ABCD\","
667     "\"deviceList\":[{\"deviceId\":\"TestAuthId2\",\"udid\":\"TestUdid\",\"userId\":\"1234ABCD\","
668     "\"credential\":{\"credentialType\":1,"
669     "\"authCode\":\"37364761534f454d33567a73424e794f33573330507069434b31676f7254706b\"}},"
670     "{\"deviceId\":\"TestAuthId3\",\"udid\":\"TestUdid2\",\"userId\":\"1234ABCD\","
671     "\"credential\":{\"credentialType\":1,"
672     "\"authCode\":\"2f7562744654535564586e665467546b322b4b506b65626373466f48766a4335\"}}]}";
673     int32_t ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, addParams);
674     ASSERT_NE(ret, HC_SUCCESS);
675 }
676 
677 HWTEST_F(GmAddMultiMembersToGroupTest, GmAddMultiMembersToGroupTest007, TestSize.Level0)
678 {
679     const DeviceGroupManager *gm = GetGmInstance();
680     ASSERT_NE(gm, nullptr);
681     int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
682     ASSERT_EQ(ret, HC_SUCCESS);
683     CreateDemoIdenticalAccountGroup();
684     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
685     ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, ADD_PARAMS2);
686     ASSERT_EQ(ret, HC_SUCCESS);
687 }
688 
689 HWTEST_F(GmAddMultiMembersToGroupTest, GmAddMultiMembersToGroupTest008, TestSize.Level0)
690 {
691     const DeviceGroupManager *gm = GetGmInstance();
692     ASSERT_NE(gm, nullptr);
693     int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
694     ASSERT_EQ(ret, HC_SUCCESS);
695     CreateDemoIdenticalAccountGroup();
696     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
697     CreateDemoAcrossAccountGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS3);
698     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
699     ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, ADD_PARAMS3);
700     ASSERT_EQ(ret, HC_SUCCESS);
701 }
702 
703 class GmDelMultiMembersFromGroupTest : public testing::Test {
704 public:
705     static void SetUpTestCase();
706     static void TearDownTestCase();
707     void SetUp();
708     void TearDown();
709 };
710 
SetUpTestCase()711 void GmDelMultiMembersFromGroupTest::SetUpTestCase() {}
TearDownTestCase()712 void GmDelMultiMembersFromGroupTest::TearDownTestCase() {}
713 
SetUp()714 void GmDelMultiMembersFromGroupTest::SetUp()
715 {
716     DeleteDatabase();
717     int ret = InitDeviceAuthService();
718     EXPECT_EQ(ret, HC_SUCCESS);
719 }
720 
TearDown()721 void GmDelMultiMembersFromGroupTest::TearDown()
722 {
723     DestroyDeviceAuthService();
724 }
725 
726 HWTEST_F(GmDelMultiMembersFromGroupTest, GmDelMultiMembersFromGroupTest001, TestSize.Level0)
727 {
728     const DeviceGroupManager *gm = GetGmInstance();
729     ASSERT_NE(gm, nullptr);
730     int32_t ret = gm->delMultiMembersFromGroup(DEFAULT_OS_ACCOUNT, nullptr, TEST_QUERY_PARAMS);
731     ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
732 }
733 
734 HWTEST_F(GmDelMultiMembersFromGroupTest, GmDelMultiMembersFromGroupTest002, TestSize.Level0)
735 {
736     const DeviceGroupManager *gm = GetGmInstance();
737     ASSERT_NE(gm, nullptr);
738     int32_t ret = gm->delMultiMembersFromGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, nullptr);
739     ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
740 }
741 
742 HWTEST_F(GmDelMultiMembersFromGroupTest, GmDelMultiMembersFromGroupTest003, TestSize.Level0)
743 {
744     const DeviceGroupManager *gm = GetGmInstance();
745     ASSERT_NE(gm, nullptr);
746     int32_t ret = gm->delMultiMembersFromGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, INVALID_JSON_STR);
747     ASSERT_NE(ret, HC_SUCCESS);
748 }
749 
750 HWTEST_F(GmDelMultiMembersFromGroupTest, GmDelMultiMembersFromGroupTest004, TestSize.Level0)
751 {
752     const DeviceGroupManager *gm = GetGmInstance();
753     ASSERT_NE(gm, nullptr);
754     const char *deleteParams =
755     "{\"groupId\":\"1234ABCD\","
756     "\"deviceList\":[{\"deviceId\":\"TestAuthId2\"},{\"deviceId\":\"TestAuthId3\"}]}";
757     int32_t ret = gm->delMultiMembersFromGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, deleteParams);
758     ASSERT_NE(ret, HC_SUCCESS);
759 }
760 
761 HWTEST_F(GmDelMultiMembersFromGroupTest, GmDelMultiMembersFromGroupTest005, TestSize.Level0)
762 {
763     const DeviceGroupManager *gm = GetGmInstance();
764     ASSERT_NE(gm, nullptr);
765     const char *deleteParams =
766     "{\"groupType\":1123123,\"groupId\":\"1234ABCD\","
767     "\"deviceList\":[{\"deviceId\":\"TestAuthId2\"},{\"deviceId\":\"TestAuthId3\"}]}";
768     int32_t ret = gm->delMultiMembersFromGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, deleteParams);
769     ASSERT_NE(ret, HC_SUCCESS);
770 }
771 
772 HWTEST_F(GmDelMultiMembersFromGroupTest, GmDelMultiMembersFromGroupTest006, TestSize.Level0)
773 {
774     const DeviceGroupManager *gm = GetGmInstance();
775     ASSERT_NE(gm, nullptr);
776     const char *deleteParams =
777     "{\"groupType\":256,\"groupId\":\"1234ABCD\","
778     "\"deviceList\":[{\"deviceId\":\"TestAuthId2\"},{\"deviceId\":\"TestAuthId3\"}]}";
779     int32_t ret = gm->delMultiMembersFromGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, deleteParams);
780     ASSERT_NE(ret, HC_SUCCESS);
781 }
782 
783 HWTEST_F(GmDelMultiMembersFromGroupTest, GmDelMultiMembersFromGroupTest007, TestSize.Level0)
784 {
785     const DeviceGroupManager *gm = GetGmInstance();
786     ASSERT_NE(gm, nullptr);
787     int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
788     ASSERT_EQ(ret, HC_SUCCESS);
789     CreateDemoIdenticalAccountGroup();
790     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
791     ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, ADD_PARAMS2);
792     ASSERT_EQ(ret, HC_SUCCESS);
793     ret = gm->delMultiMembersFromGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, DELETE_PARAMS2);
794     ASSERT_EQ(ret, HC_SUCCESS);
795 }
796 
797 HWTEST_F(GmDelMultiMembersFromGroupTest, GmDelMultiMembersFromGroupTest008, TestSize.Level0)
798 {
799     const DeviceGroupManager *gm = GetGmInstance();
800     ASSERT_NE(gm, nullptr);
801     int32_t ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
802     ASSERT_EQ(ret, HC_SUCCESS);
803     CreateDemoIdenticalAccountGroup();
804     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
805     CreateDemoAcrossAccountGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS3);
806     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
807     ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, ADD_PARAMS3);
808     ASSERT_EQ(ret, HC_SUCCESS);
809     ret = gm->delMultiMembersFromGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, DELETE_PARAMS3);
810     ASSERT_EQ(ret, HC_SUCCESS);
811 }
812 
813 class GmGetRegisterInfoTest : public testing::Test {
814 public:
815     static void SetUpTestCase();
816     static void TearDownTestCase();
817     void SetUp();
818     void TearDown();
819 };
820 
SetUpTestCase()821 void GmGetRegisterInfoTest::SetUpTestCase() {}
TearDownTestCase()822 void GmGetRegisterInfoTest::TearDownTestCase() {}
823 
SetUp()824 void GmGetRegisterInfoTest::SetUp()
825 {
826     int ret = InitDeviceAuthService();
827     EXPECT_EQ(ret, HC_SUCCESS);
828 }
829 
TearDown()830 void GmGetRegisterInfoTest::TearDown()
831 {
832     DestroyDeviceAuthService();
833 }
834 
835 HWTEST_F(GmGetRegisterInfoTest, GmGetRegisterInfoTest001, TestSize.Level0)
836 {
837     const DeviceGroupManager *gm = GetGmInstance();
838     ASSERT_NE(gm, nullptr);
839     char *returnData = nullptr;
840     int32_t ret = gm->getRegisterInfo(nullptr, &returnData);
841     ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
842 }
843 
844 HWTEST_F(GmGetRegisterInfoTest, GmGetRegisterInfoTest002, TestSize.Level0)
845 {
846     const DeviceGroupManager *gm = GetGmInstance();
847     ASSERT_NE(gm, nullptr);
848     int32_t ret = gm->getRegisterInfo(TEST_QUERY_PARAMS, nullptr);
849     ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
850 }
851 
852 HWTEST_F(GmGetRegisterInfoTest, GmGetRegisterInfoTest003, TestSize.Level0)
853 {
854     const DeviceGroupManager *gm = GetGmInstance();
855     ASSERT_NE(gm, nullptr);
856     char *returnData = nullptr;
857     int32_t ret = gm->getRegisterInfo(GET_REG_INFO_PARAMS, &returnData);
858     ASSERT_EQ(ret, HC_SUCCESS);
859     ASSERT_NE(returnData, nullptr);
860     gm->destroyInfo(&returnData);
861 }
862 
863 class GmDeleteGroupTest : public testing::Test {
864 public:
865     static void SetUpTestCase();
866     static void TearDownTestCase();
867     void SetUp();
868     void TearDown();
869 };
870 
SetUpTestCase()871 void GmDeleteGroupTest::SetUpTestCase() {}
TearDownTestCase()872 void GmDeleteGroupTest::TearDownTestCase() {}
873 
SetUp()874 void GmDeleteGroupTest::SetUp()
875 {
876     DeleteDatabase();
877 }
878 
TearDown()879 void GmDeleteGroupTest::TearDown() {}
880 
881 HWTEST_F(GmDeleteGroupTest, GmDeleteGroupTest001, TestSize.Level0)
882 {
883     int32_t ret = InitDeviceAuthService();
884     ASSERT_EQ(ret, HC_SUCCESS);
885     const DeviceGroupManager *gm = GetGmInstance();
886     ASSERT_NE(gm, nullptr);
887     ret = gm->deleteGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, nullptr);
888     ASSERT_NE(ret, HC_SUCCESS);
889     DestroyDeviceAuthService();
890 }
891 
892 HWTEST_F(GmDeleteGroupTest, GmDeleteGroupTest002, TestSize.Level0)
893 {
894     int32_t ret = InitDeviceAuthService();
895     ASSERT_EQ(ret, HC_SUCCESS);
896     const DeviceGroupManager *gm = GetGmInstance();
897     ASSERT_NE(gm, nullptr);
898     ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
899     ASSERT_EQ(ret, HC_SUCCESS);
900     DeleteDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, DISBAND_PARAMS);
901     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_ERROR);
902     DestroyDeviceAuthService();
903 }
904 
905 HWTEST_F(GmDeleteGroupTest, GmDeleteGroupTest003, TestSize.Level0)
906 {
907     int32_t ret = InitDeviceAuthService();
908     ASSERT_EQ(ret, HC_SUCCESS);
909     const DeviceGroupManager *gm = GetGmInstance();
910     ASSERT_NE(gm, nullptr);
911     ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
912     ASSERT_EQ(ret, HC_SUCCESS);
913     ret = gm->deleteGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, INVALID_JSON_STR);
914     ASSERT_NE(ret, HC_SUCCESS);
915     DestroyDeviceAuthService();
916 }
917 
918 HWTEST_F(GmDeleteGroupTest, GmDeleteGroupTest004, TestSize.Level0)
919 {
920     int32_t ret = InitDeviceAuthService();
921     ASSERT_EQ(ret, HC_SUCCESS);
922     const DeviceGroupManager *gm = GetGmInstance();
923     ASSERT_NE(gm, nullptr);
924     ret = gm->deleteGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, DISBAND_PARAMS);
925     ASSERT_NE(ret, HC_SUCCESS);
926     DestroyDeviceAuthService();
927 }
928 
929 HWTEST_F(GmDeleteGroupTest, GmDeleteGroupTest005, TestSize.Level0)
930 {
931     int32_t ret = InitDeviceAuthService();
932     ASSERT_EQ(ret, HC_SUCCESS);
933     const DeviceGroupManager *gm = GetGmInstance();
934     ASSERT_NE(gm, nullptr);
935     ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
936     ASSERT_EQ(ret, HC_SUCCESS);
937     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
938     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
939     DeleteDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, DISBAND_PARAMS);
940     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
941     DestroyDeviceAuthService();
942 }
943 
944 HWTEST_F(GmDeleteGroupTest, GmDeleteGroupTest006, TestSize.Level0)
945 {
946     SetIsoSupported(true);
947     SetPakeV1Supported(false);
948     int32_t ret = InitDeviceAuthService();
949     ASSERT_EQ(ret, HC_SUCCESS);
950     const DeviceGroupManager *gm = GetGmInstance();
951     ASSERT_NE(gm, nullptr);
952     ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
953     ASSERT_EQ(ret, HC_SUCCESS);
954     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
955     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
956     AddDemoMember();
957     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
958     DeleteDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, DISBAND_PARAMS);
959     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
960     DestroyDeviceAuthService();
961 }
962 
963 HWTEST_F(GmDeleteGroupTest, GmDeleteGroupTest007, TestSize.Level0)
964 {
965     int32_t ret = InitDeviceAuthService();
966     ASSERT_EQ(ret, HC_SUCCESS);
967     const DeviceGroupManager *gm = GetGmInstance();
968     ASSERT_NE(gm, nullptr);
969     ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
970     ASSERT_EQ(ret, HC_SUCCESS);
971     CreateDemoIdenticalAccountGroup();
972     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
973     CreateDemoAcrossAccountGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS3);
974     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
975     DeleteDemoAcrossAccountGroup();
976     DeleteDemoIdenticalAccountGroup();
977     DestroyDeviceAuthService();
978 }
979 
980 HWTEST_F(GmDeleteGroupTest, GmDeleteGroupTest008, TestSize.Level0)
981 {
982     int32_t ret = InitDeviceAuthService();
983     ASSERT_EQ(ret, HC_SUCCESS);
984     const DeviceGroupManager *gm = GetGmInstance();
985     ASSERT_NE(gm, nullptr);
986     ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
987     ASSERT_EQ(ret, HC_SUCCESS);
988     CreateDemoIdenticalAccountGroup();
989     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
990     ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, ADD_PARAMS2);
991     ASSERT_EQ(ret, HC_SUCCESS);
992     CreateDemoAcrossAccountGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS3);
993     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
994     DeleteDemoAcrossAccountGroup();
995     DeleteDemoIdenticalAccountGroup();
996     DestroyDeviceAuthService();
997 }
998 
999 HWTEST_F(GmDeleteGroupTest, GmDeleteGroupTest009, TestSize.Level0)
1000 {
1001     int32_t ret = InitDeviceAuthService();
1002     ASSERT_EQ(ret, HC_SUCCESS);
1003     const DeviceGroupManager *gm = GetGmInstance();
1004     ASSERT_NE(gm, nullptr);
1005     ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1006     ASSERT_EQ(ret, HC_SUCCESS);
1007     CreateDemoIdenticalAccountGroup();
1008     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1009     CreateDemoAcrossAccountGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS3);
1010     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1011     ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, ADD_PARAMS3);
1012     ASSERT_EQ(ret, HC_SUCCESS);
1013     DeleteDemoAcrossAccountGroup();
1014     DeleteDemoIdenticalAccountGroup();
1015     DestroyDeviceAuthService();
1016 }
1017 
1018 class GmCancelRequestTest : public testing::Test {
1019 public:
1020     static void SetUpTestCase();
1021     static void TearDownTestCase();
1022     void SetUp();
1023     void TearDown();
1024 };
1025 
SetUpTestCase()1026 void GmCancelRequestTest::SetUpTestCase() {}
1027 
TearDownTestCase()1028 void GmCancelRequestTest::TearDownTestCase() {}
1029 
SetUp()1030 void GmCancelRequestTest::SetUp()
1031 {
1032     DeleteDatabase();
1033 }
1034 
TearDown()1035 void GmCancelRequestTest::TearDown() {}
1036 
1037 HWTEST_F(GmCancelRequestTest, GmCancelRequestTest001, TestSize.Level0)
1038 {
1039     int32_t ret = InitDeviceAuthService();
1040     ASSERT_EQ(ret, HC_SUCCESS);
1041     const DeviceGroupManager *gm = GetGmInstance();
1042     ASSERT_NE(gm, nullptr);
1043     gm->cancelRequest(TEST_REQ_ID, nullptr);
1044     DestroyDeviceAuthService();
1045 }
1046 
1047 HWTEST_F(GmCancelRequestTest, GmCancelRequestTest002, TestSize.Level0)
1048 {
1049     SetIsoSupported(true);
1050     SetPakeV1Supported(false);
1051     int32_t ret = InitDeviceAuthService();
1052     ASSERT_EQ(ret, HC_SUCCESS);
1053     const DeviceGroupManager *gm = GetGmInstance();
1054     ASSERT_NE(gm, nullptr);
1055     ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1056     ASSERT_EQ(ret, HC_SUCCESS);
1057     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
1058     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1059     ret = gm->addMemberToGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, ADD_PARAMS);
1060     ASSERT_EQ(ret, HC_SUCCESS);
1061     gm->cancelRequest(TEST_REQ_ID, TEST_APP_ID);
1062     usleep(TEST_DEV_AUTH_SLEEP_TIME);
1063     DestroyDeviceAuthService();
1064 }
1065 
1066 HWTEST_F(GmCancelRequestTest, GmCancelRequestTest003, TestSize.Level0)
1067 {
1068     SetIsoSupported(true);
1069     SetPakeV1Supported(false);
1070     int32_t ret = InitDeviceAuthService();
1071     ASSERT_EQ(ret, HC_SUCCESS);
1072     const DeviceGroupManager *gm = GetGmInstance();
1073     ASSERT_NE(gm, nullptr);
1074     ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1075     ASSERT_EQ(ret, HC_SUCCESS);
1076     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
1077     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1078     ret = gm->addMemberToGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, ADD_PARAMS);
1079     ASSERT_EQ(ret, HC_SUCCESS);
1080     gm->cancelRequest(TEST_REQ_ID2, TEST_APP_ID);
1081     usleep(TEST_DEV_AUTH_SLEEP_TIME);
1082     DestroyDeviceAuthService();
1083 }
1084 
1085 HWTEST_F(GmCancelRequestTest, GmCancelRequestTest004, TestSize.Level0)
1086 {
1087     SetIsoSupported(true);
1088     SetPakeV1Supported(false);
1089     int32_t ret = InitDeviceAuthService();
1090     ASSERT_EQ(ret, HC_SUCCESS);
1091     const DeviceGroupManager *gm = GetGmInstance();
1092     ASSERT_NE(gm, nullptr);
1093     ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1094     ASSERT_EQ(ret, HC_SUCCESS);
1095     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
1096     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1097     ret = gm->addMemberToGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, ADD_PARAMS);
1098     ASSERT_EQ(ret, HC_SUCCESS);
1099     gm->cancelRequest(TEST_REQ_ID, TEST_APP_ID2);
1100     usleep(TEST_DEV_AUTH_SLEEP_TIME);
1101     DestroyDeviceAuthService();
1102 }
1103 
1104 HWTEST_F(GmCancelRequestTest, GmCancelRequestTest005, TestSize.Level0)
1105 {
1106     SetIsoSupported(true);
1107     SetPakeV1Supported(false);
1108     int32_t ret = InitDeviceAuthService();
1109     ASSERT_EQ(ret, HC_SUCCESS);
1110     const DeviceGroupManager *gm = GetGmInstance();
1111     ASSERT_NE(gm, nullptr);
1112     ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1113     ASSERT_EQ(ret, HC_SUCCESS);
1114     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
1115     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1116     ret = gm->addMemberToGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, ADD_PARAMS);
1117     ASSERT_EQ(ret, HC_SUCCESS);
1118     const GroupAuthManager *ga = GetGaInstance();
1119     ASSERT_NE(ga, nullptr);
1120     ga->cancelRequest(TEST_REQ_ID, TEST_APP_ID);
1121     usleep(TEST_DEV_AUTH_SLEEP_TIME);
1122     DestroyDeviceAuthService();
1123 }
1124 
1125 class GmDestroyInfoTest : public testing::Test {
1126 public:
1127     static void SetUpTestCase();
1128     static void TearDownTestCase();
1129     void SetUp();
1130     void TearDown();
1131 };
1132 
SetUpTestCase()1133 void GmDestroyInfoTest::SetUpTestCase()
1134 {
1135     int32_t ret = InitDeviceAuthService();
1136     ASSERT_EQ(ret, HC_SUCCESS);
1137 }
1138 
TearDownTestCase()1139 void GmDestroyInfoTest::TearDownTestCase()
1140 {
1141     DestroyDeviceAuthService();
1142 }
1143 
SetUp()1144 void GmDestroyInfoTest::SetUp() {}
1145 
TearDown()1146 void GmDestroyInfoTest::TearDown() {}
1147 
1148 HWTEST_F(GmDestroyInfoTest, GmDestroyInfoTest001, TestSize.Level0)
1149 {
1150     const DeviceGroupManager *gm = GetGmInstance();
1151     ASSERT_NE(gm, nullptr);
1152     gm->destroyInfo(nullptr);
1153 }
1154 
1155 HWTEST_F(GmDestroyInfoTest, GmDestroyInfoTest002, TestSize.Level0)
1156 {
1157     const DeviceGroupManager *gm = GetGmInstance();
1158     ASSERT_NE(gm, nullptr);
1159     char *str = nullptr;
1160     gm->destroyInfo(&str);
1161 }
1162 
1163 class GaAuthDeviceTest : public testing::Test {
1164 public:
1165     static void SetUpTestCase();
1166     static void TearDownTestCase();
1167     void SetUp();
1168     void TearDown();
1169 };
1170 
SetUpTestCase()1171 void GaAuthDeviceTest::SetUpTestCase() {}
TearDownTestCase()1172 void GaAuthDeviceTest::TearDownTestCase() {}
1173 
SetUp()1174 void GaAuthDeviceTest::SetUp()
1175 {
1176     DeleteDatabase();
1177 }
1178 
TearDown()1179 void GaAuthDeviceTest::TearDown() {}
1180 
1181 HWTEST_F(GaAuthDeviceTest, GaAuthDeviceTest001, TestSize.Level0)
1182 {
1183     int32_t ret = InitDeviceAuthService();
1184     ASSERT_EQ(ret, HC_SUCCESS);
1185     const GroupAuthManager *ga = GetGaInstance();
1186     ASSERT_NE(ga, nullptr);
1187     ret = ga->authDevice(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, nullptr, &g_gmCallback);
1188     ASSERT_EQ(ret, HC_ERR_INVALID_PARAMS);
1189     DestroyDeviceAuthService();
1190 }
1191 
1192 HWTEST_F(GaAuthDeviceTest, GaAuthDeviceTest002, TestSize.Level0)
1193 {
1194     int32_t ret = InitDeviceAuthService();
1195     ASSERT_EQ(ret, HC_SUCCESS);
1196     const GroupAuthManager *ga = GetGaInstance();
1197     ASSERT_NE(ga, nullptr);
1198     ret = ga->authDevice(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, AUTH_PARAMS, nullptr);
1199     ASSERT_NE(ret, HC_SUCCESS);
1200     DestroyDeviceAuthService();
1201 }
1202 
1203 HWTEST_F(GaAuthDeviceTest, GaAuthDeviceTest003, TestSize.Level0)
1204 {
1205     SetIsoSupported(true);
1206     SetPakeV1Supported(false);
1207     int32_t ret = InitDeviceAuthService();
1208     ASSERT_EQ(ret, HC_SUCCESS);
1209     const DeviceGroupManager *gm = GetGmInstance();
1210     ASSERT_NE(gm, nullptr);
1211     ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1212     ASSERT_EQ(ret, HC_SUCCESS);
1213     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
1214     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1215     AddDemoMember();
1216     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1217     AuthDemoMember();
1218     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1219     DestroyDeviceAuthService();
1220 }
1221 
1222 HWTEST_F(GaAuthDeviceTest, GaAuthDeviceTest004, TestSize.Level0)
1223 {
1224     SetIsoSupported(false);
1225     SetPakeV1Supported(true);
1226     int32_t ret = InitDeviceAuthService();
1227     ASSERT_EQ(ret, HC_SUCCESS);
1228     const DeviceGroupManager *gm = GetGmInstance();
1229     ASSERT_NE(gm, nullptr);
1230     ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1231     ASSERT_EQ(ret, HC_SUCCESS);
1232     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
1233     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1234     AddDemoMember();
1235     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1236     AuthDemoMember();
1237     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1238     DestroyDeviceAuthService();
1239 }
1240 
1241 HWTEST_F(GaAuthDeviceTest, GaAuthDeviceTest005, TestSize.Level0)
1242 {
1243     SetIsoSupported(true);
1244     SetPakeV1Supported(false);
1245     int32_t ret = InitDeviceAuthService();
1246     ASSERT_EQ(ret, HC_SUCCESS);
1247     const DeviceGroupManager *gm = GetGmInstance();
1248     ASSERT_NE(gm, nullptr);
1249     ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1250     ASSERT_EQ(ret, HC_SUCCESS);
1251     CreateDemoSymClientIdenticalAccountGroup();
1252     ASSERT_EQ(ret, HC_SUCCESS);
1253     SetDeviceStatus(false);
1254     CreateDemoSymServerIdenticalAccountGroup();
1255     SetDeviceStatus(true);
1256     AuthDemoMember();
1257     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1258     DestroyDeviceAuthService();
1259 }
1260 
1261 HWTEST_F(GaAuthDeviceTest, GaAuthDeviceTest006, TestSize.Level0)
1262 {
1263     SetIsoSupported(true);
1264     SetPakeV1Supported(false);
1265     int32_t ret = InitDeviceAuthService();
1266     ASSERT_EQ(ret, HC_SUCCESS);
1267     const DeviceGroupManager *gm = GetGmInstance();
1268     ASSERT_NE(gm, nullptr);
1269     ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1270     ASSERT_EQ(ret, HC_SUCCESS);
1271     CreateDemoSymClientIdenticalAccountGroup();
1272     SetDeviceStatus(false);
1273     CreateDemoSymServerIdenticalAccountGroup();
1274     SetDeviceStatus(true);
1275     ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, ADD_PARAMS4);
1276     ASSERT_EQ(ret, HC_SUCCESS);
1277     SetDeviceStatus(false);
1278     ret = gm->addMultiMembersToGroup(TEST_AUTH_OS_ACCOUNT_ID, TEST_APP_ID, ADD_PARAMS5);
1279     ASSERT_EQ(ret, HC_SUCCESS);
1280     SetDeviceStatus(true);
1281     AuthDemoMember();
1282     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1283     DestroyDeviceAuthService();
1284 }
1285 
1286 class GaProcessDataTest : public testing::Test {
1287 public:
1288     static void SetUpTestCase();
1289     static void TearDownTestCase();
1290     void SetUp();
1291     void TearDown();
1292 };
1293 
SetUpTestCase()1294 void GaProcessDataTest::SetUpTestCase() {}
TearDownTestCase()1295 void GaProcessDataTest::TearDownTestCase() {}
1296 
SetUp()1297 void GaProcessDataTest::SetUp()
1298 {
1299     int ret = InitDeviceAuthService();
1300     EXPECT_EQ(ret, HC_SUCCESS);
1301 }
1302 
TearDown()1303 void GaProcessDataTest::TearDown()
1304 {
1305     DestroyDeviceAuthService();
1306 }
1307 
1308 HWTEST_F(GaProcessDataTest, GaProcessDataTest002, TestSize.Level0)
1309 {
1310     const GroupAuthManager *ga = GetGaInstance();
1311     EXPECT_NE(ga, nullptr);
1312     int32_t ret = ga->processData(TEST_REQ_ID, nullptr, 0, nullptr);
1313     EXPECT_NE(ret, HC_SUCCESS);
1314 }
1315 
1316 class GaCancelRequestTest : public testing::Test {
1317 public:
1318     static void SetUpTestCase();
1319     static void TearDownTestCase();
1320     void SetUp();
1321     void TearDown();
1322 };
1323 
SetUpTestCase()1324 void GaCancelRequestTest::SetUpTestCase() {}
1325 
TearDownTestCase()1326 void GaCancelRequestTest::TearDownTestCase() {}
1327 
SetUp()1328 void GaCancelRequestTest::SetUp()
1329 {
1330     DeleteDatabase();
1331 }
1332 
TearDown()1333 void GaCancelRequestTest::TearDown() {}
1334 
1335 HWTEST_F(GaCancelRequestTest, GaCancelRequestTest001, TestSize.Level0)
1336 {
1337     SetIsoSupported(true);
1338     SetPakeV1Supported(false);
1339     int32_t ret = InitDeviceAuthService();
1340     ASSERT_EQ(ret, HC_SUCCESS);
1341     const DeviceGroupManager *gm = GetGmInstance();
1342     ASSERT_NE(gm, nullptr);
1343     ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1344     ASSERT_EQ(ret, HC_SUCCESS);
1345     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
1346     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1347     AddDemoMember();
1348     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1349     const GroupAuthManager *ga = GetGaInstance();
1350     ASSERT_NE(ga, nullptr);
1351     ret = ga->authDevice(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, AUTH_PARAMS, &g_gaCallback);
1352     ASSERT_EQ(ret, HC_SUCCESS);
1353     ga->cancelRequest(TEST_REQ_ID, TEST_APP_ID);
1354     usleep(TEST_DEV_AUTH_SLEEP_TIME);
1355     DestroyDeviceAuthService();
1356 }
1357 
1358 HWTEST_F(GaCancelRequestTest, GaCancelRequestTest002, TestSize.Level0)
1359 {
1360     SetIsoSupported(true);
1361     SetPakeV1Supported(false);
1362     int32_t ret = InitDeviceAuthService();
1363     ASSERT_EQ(ret, HC_SUCCESS);
1364     const DeviceGroupManager *gm = GetGmInstance();
1365     ASSERT_NE(gm, nullptr);
1366     ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1367     ASSERT_EQ(ret, HC_SUCCESS);
1368     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
1369     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1370     AddDemoMember();
1371     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1372     const GroupAuthManager *ga = GetGaInstance();
1373     ASSERT_NE(ga, nullptr);
1374     ret = ga->authDevice(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, AUTH_PARAMS, &g_gaCallback);
1375     ASSERT_EQ(ret, HC_SUCCESS);
1376     ga->cancelRequest(TEST_REQ_ID2, TEST_APP_ID);
1377     usleep(TEST_DEV_AUTH_SLEEP_TIME);
1378     DestroyDeviceAuthService();
1379 }
1380 
1381 HWTEST_F(GaCancelRequestTest, GaCancelRequestTest003, TestSize.Level0)
1382 {
1383     SetIsoSupported(true);
1384     SetPakeV1Supported(false);
1385     int32_t ret = InitDeviceAuthService();
1386     ASSERT_EQ(ret, HC_SUCCESS);
1387     const DeviceGroupManager *gm = GetGmInstance();
1388     ASSERT_NE(gm, nullptr);
1389     ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1390     ASSERT_EQ(ret, HC_SUCCESS);
1391     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
1392     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1393     AddDemoMember();
1394     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1395     const GroupAuthManager *ga = GetGaInstance();
1396     ASSERT_NE(ga, nullptr);
1397     ret = ga->authDevice(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, AUTH_PARAMS, &g_gaCallback);
1398     ASSERT_EQ(ret, HC_SUCCESS);
1399     ga->cancelRequest(TEST_REQ_ID, TEST_APP_ID2);
1400     usleep(TEST_DEV_AUTH_SLEEP_TIME);
1401     DestroyDeviceAuthService();
1402 }
1403 
1404 HWTEST_F(GaCancelRequestTest, GaCancelRequestTest004, TestSize.Level0)
1405 {
1406     SetIsoSupported(true);
1407     SetPakeV1Supported(false);
1408     int32_t ret = InitDeviceAuthService();
1409     ASSERT_EQ(ret, HC_SUCCESS);
1410     const DeviceGroupManager *gm = GetGmInstance();
1411     ASSERT_NE(gm, nullptr);
1412     ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1413     ASSERT_EQ(ret, HC_SUCCESS);
1414     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
1415     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1416     AddDemoMember();
1417     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1418     const GroupAuthManager *ga = GetGaInstance();
1419     ASSERT_NE(ga, nullptr);
1420     ret = ga->authDevice(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, AUTH_PARAMS, &g_gaCallback);
1421     ASSERT_EQ(ret, HC_SUCCESS);
1422     gm->cancelRequest(TEST_REQ_ID, TEST_APP_ID);
1423     usleep(TEST_DEV_AUTH_SLEEP_TIME);
1424     DestroyDeviceAuthService();
1425 }
1426 
1427 class DevAuthTest : public testing::Test {
1428 public:
1429     static void SetUpTestCase();
1430     static void TearDownTestCase();
1431     void SetUp();
1432     void TearDown();
1433 };
1434 
SetUpTestCase()1435 void DevAuthTest::SetUpTestCase() {}
TearDownTestCase()1436 void DevAuthTest::TearDownTestCase()
1437 {
1438     DeleteDatabase();
1439 }
1440 
SetUp()1441 void DevAuthTest::SetUp()
1442 {
1443     DeleteDatabase();
1444 }
1445 
TearDown()1446 void DevAuthTest::TearDown() {}
1447 
1448 HWTEST_F(DevAuthTest, DevAuthTest001, TestSize.Level0)
1449 {
1450     StartRecordJsonCallNum();
1451     int32_t ret = InitDeviceAuthService();
1452     ASSERT_EQ(ret, HC_SUCCESS);
1453     const DeviceGroupManager *gm = GetGmInstance();
1454     ASSERT_NE(gm, nullptr);
1455     ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1456     ASSERT_EQ(ret, HC_SUCCESS);
1457     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
1458     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1459     DestroyDeviceAuthService();
1460     uint32_t mallocCount = GetJsonCallNum();
1461     printf("mock count: %u\n", mallocCount);
1462     for (int i = 0; i < mallocCount; i++) {
1463         ResetRecordJsonCallNum();
1464         SetJsonCallMockIndex(i);
1465         ret = InitDeviceAuthService();
1466         if (ret != HC_SUCCESS) {
1467             continue;
1468         }
1469         const DeviceGroupManager *gm = GetGmInstance();
1470         ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1471         if (ret != HC_SUCCESS) {
1472             DestroyDeviceAuthService();
1473             continue;
1474         }
1475         CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
1476         if (g_asyncStatus != ASYNC_STATUS_FINISH) {
1477             DestroyDeviceAuthService();
1478             DeleteDatabase();
1479             continue;
1480         }
1481         DestroyDeviceAuthService();
1482     }
1483 }
1484 
1485 HWTEST_F(DevAuthTest, DevAuthTest101, TestSize.Level0)
1486 {
1487     SetIsoSupported(true);
1488     SetPakeV1Supported(false);
1489     int32_t ret = InitDeviceAuthService();
1490     ASSERT_EQ(ret, HC_SUCCESS);
1491     const DeviceGroupManager *gm = GetGmInstance();
1492     ASSERT_NE(gm, nullptr);
1493     ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1494     ASSERT_EQ(ret, HC_SUCCESS);
1495     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
1496     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1497     StartRecordJsonCallNum();
1498     AddDemoMember();
1499     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1500     DestroyDeviceAuthService();
1501     DeleteDatabase();
1502     uint32_t mallocCount = GetJsonCallNum();
1503     printf("mock count: %u\n", mallocCount);
1504     for (int i = 0; i < mallocCount; i++) {
1505         ret = InitDeviceAuthService();
1506         ASSERT_EQ(ret, HC_SUCCESS);
1507         const DeviceGroupManager *gm = GetGmInstance();
1508         ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1509         ASSERT_EQ(ret, HC_SUCCESS);
1510         CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
1511         if (g_asyncStatus != ASYNC_STATUS_FINISH) {
1512             DestroyDeviceAuthService();
1513             DeleteDatabase();
1514             continue;
1515         }
1516         ResetRecordJsonCallNum();
1517         SetJsonCallMockIndex(i);
1518         AddDemoMember();
1519         if (g_asyncStatus != ASYNC_STATUS_FINISH) {
1520             DestroyDeviceAuthService();
1521             DeleteDatabase();
1522             continue;
1523         }
1524         DestroyDeviceAuthService();
1525     }
1526 }
1527 
1528 HWTEST_F(DevAuthTest, DevAuthTest002, TestSize.Level0)
1529 {
1530     int32_t ret = InitDeviceAuthService();
1531     ASSERT_EQ(ret, HC_SUCCESS);
1532     const DeviceGroupManager *gm = GetGmInstance();
1533     ASSERT_NE(gm, nullptr);
1534     ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1535     ASSERT_EQ(ret, HC_SUCCESS);
1536     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
1537     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1538 
1539     StartRecordJsonCallNum();
1540     ret = gm->checkAccessToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID);
1541     ASSERT_EQ(ret, HC_SUCCESS);
1542     uint32_t mallocCount = GetJsonCallNum();
1543     for (int i = 0; i < mallocCount; i++) {
1544         ResetRecordJsonCallNum();
1545         SetJsonCallMockIndex(i);
1546         ret = gm->checkAccessToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID);
1547         if (ret != HC_SUCCESS) {
1548             continue;
1549         }
1550     }
1551     DestroyDeviceAuthService();
1552 }
1553 
1554 HWTEST_F(DevAuthTest, DevAuthTest003, TestSize.Level0)
1555 {
1556     int32_t ret = InitDeviceAuthService();
1557     ASSERT_EQ(ret, HC_SUCCESS);
1558     const DeviceGroupManager *gm = GetGmInstance();
1559     ASSERT_NE(gm, nullptr);
1560     ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1561     ASSERT_EQ(ret, HC_SUCCESS);
1562     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
1563     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1564 
1565     StartRecordJsonCallNum();
1566     char *returnData = nullptr;
1567     uint32_t returnNum = 0;
1568     const char *queryParams = "{\"udid\":\"5420459D93FE773F9945FD64277FBA2CAB8FB996DDC1D0B97676FBB1242"
1569         "B3930\",\"isSelfPk\":true}";
1570     ret = gm->getPkInfoList(DEFAULT_OS_ACCOUNT, TEST_APP_ID, queryParams, &returnData, &returnNum);
1571     ASSERT_EQ(ret, HC_SUCCESS);
1572     gm->destroyInfo(&returnData);
1573     uint32_t mallocCount = GetJsonCallNum();
1574     for (int i = 0; i < mallocCount; i++) {
1575         ResetRecordJsonCallNum();
1576         SetJsonCallMockIndex(i);
1577         ret = gm->getPkInfoList(DEFAULT_OS_ACCOUNT, TEST_APP_ID, queryParams, &returnData, &returnNum);
1578         if (ret != HC_SUCCESS) {
1579             continue;
1580         }
1581         gm->destroyInfo(&returnData);
1582     }
1583     DestroyDeviceAuthService();
1584 }
1585 
1586 HWTEST_F(DevAuthTest, DevAuthTest004, TestSize.Level0)
1587 {
1588     int32_t ret = InitDeviceAuthService();
1589     ASSERT_EQ(ret, HC_SUCCESS);
1590     const DeviceGroupManager *gm = GetGmInstance();
1591     ASSERT_NE(gm, nullptr);
1592     ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1593     ASSERT_EQ(ret, HC_SUCCESS);
1594     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
1595     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1596 
1597     StartRecordJsonCallNum();
1598     char *returnData = nullptr;
1599     ret = gm->getGroupInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID, &returnData);
1600     ASSERT_EQ(ret, HC_SUCCESS);
1601     gm->destroyInfo(&returnData);
1602     uint32_t mallocCount = GetJsonCallNum();
1603     for (int i = 0; i < mallocCount; i++) {
1604         ResetRecordJsonCallNum();
1605         SetJsonCallMockIndex(i);
1606         ret = gm->getGroupInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID, &returnData);
1607         if (ret != HC_SUCCESS) {
1608             continue;
1609         }
1610         gm->destroyInfo(&returnData);
1611     }
1612     DestroyDeviceAuthService();
1613 }
1614 
1615 HWTEST_F(DevAuthTest, DevAuthTest005, TestSize.Level0)
1616 {
1617     int32_t ret = InitDeviceAuthService();
1618     ASSERT_EQ(ret, HC_SUCCESS);
1619     const DeviceGroupManager *gm = GetGmInstance();
1620     ASSERT_NE(gm, nullptr);
1621     ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1622     ASSERT_EQ(ret, HC_SUCCESS);
1623     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
1624     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1625 
1626     StartRecordJsonCallNum();
1627     char *returnData = nullptr;
1628     uint32_t returnNum = 0;
1629     const char *queryParams = "{\"groupOwner\":\"TestAppId\"}";
1630     ret = gm->getGroupInfo(DEFAULT_OS_ACCOUNT, TEST_APP_ID, queryParams, &returnData, &returnNum);
1631     ASSERT_EQ(ret, HC_SUCCESS);
1632     gm->destroyInfo(&returnData);
1633     uint32_t mallocCount = GetJsonCallNum();
1634     for (int i = 0; i < mallocCount; i++) {
1635         ResetRecordJsonCallNum();
1636         SetJsonCallMockIndex(i);
1637         ret = gm->getGroupInfo(DEFAULT_OS_ACCOUNT, TEST_APP_ID, queryParams, &returnData, &returnNum);
1638         if (ret != HC_SUCCESS) {
1639             continue;
1640         }
1641         gm->destroyInfo(&returnData);
1642     }
1643     DestroyDeviceAuthService();
1644 }
1645 
1646 HWTEST_F(DevAuthTest, DevAuthTest006, TestSize.Level0)
1647 {
1648     int32_t ret = InitDeviceAuthService();
1649     ASSERT_EQ(ret, HC_SUCCESS);
1650     const DeviceGroupManager *gm = GetGmInstance();
1651     ASSERT_NE(gm, nullptr);
1652     ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1653     ASSERT_EQ(ret, HC_SUCCESS);
1654     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
1655     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1656 
1657     StartRecordJsonCallNum();
1658     char *returnData = nullptr;
1659     uint32_t returnNum = 0;
1660     ret = gm->getJoinedGroups(DEFAULT_OS_ACCOUNT, TEST_APP_ID, PEER_TO_PEER_GROUP, &returnData, &returnNum);
1661     ASSERT_EQ(ret, HC_SUCCESS);
1662     gm->destroyInfo(&returnData);
1663     uint32_t mallocCount = GetJsonCallNum();
1664     for (int i = 0; i < mallocCount; i++) {
1665         ResetRecordJsonCallNum();
1666         SetJsonCallMockIndex(i);
1667         ret = gm->getJoinedGroups(DEFAULT_OS_ACCOUNT, TEST_APP_ID, PEER_TO_PEER_GROUP, &returnData, &returnNum);
1668         if (ret != HC_SUCCESS) {
1669             continue;
1670         }
1671         gm->destroyInfo(&returnData);
1672     }
1673     DestroyDeviceAuthService();
1674 }
1675 
1676 HWTEST_F(DevAuthTest, DevAuthTest007, TestSize.Level0)
1677 {
1678     int32_t ret = InitDeviceAuthService();
1679     ASSERT_EQ(ret, HC_SUCCESS);
1680     const DeviceGroupManager *gm = GetGmInstance();
1681     ASSERT_NE(gm, nullptr);
1682     ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1683     ASSERT_EQ(ret, HC_SUCCESS);
1684     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
1685     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1686 
1687     StartRecordJsonCallNum();
1688     char *returnData = nullptr;
1689     uint32_t returnNum = 0;
1690     ret = gm->getRelatedGroups(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_AUTH_ID, &returnData, &returnNum);
1691     ASSERT_EQ(ret, HC_SUCCESS);
1692     gm->destroyInfo(&returnData);
1693     uint32_t mallocCount = GetJsonCallNum();
1694     for (int i = 0; i < mallocCount; i++) {
1695         ResetRecordJsonCallNum();
1696         SetJsonCallMockIndex(i);
1697         ret = gm->getRelatedGroups(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_AUTH_ID, &returnData, &returnNum);
1698         if (ret != HC_SUCCESS) {
1699             continue;
1700         }
1701         gm->destroyInfo(&returnData);
1702     }
1703     DestroyDeviceAuthService();
1704 }
1705 
1706 HWTEST_F(DevAuthTest, DevAuthTest008, TestSize.Level0)
1707 {
1708     int32_t ret = InitDeviceAuthService();
1709     ASSERT_EQ(ret, HC_SUCCESS);
1710     const DeviceGroupManager *gm = GetGmInstance();
1711     ASSERT_NE(gm, nullptr);
1712     ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1713     ASSERT_EQ(ret, HC_SUCCESS);
1714     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
1715     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1716 
1717     StartRecordJsonCallNum();
1718     char *returnData = nullptr;
1719     ret = gm->getDeviceInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_AUTH_ID, TEST_GROUP_ID, &returnData);
1720     ASSERT_EQ(ret, HC_SUCCESS);
1721     gm->destroyInfo(&returnData);
1722     uint32_t mallocCount = GetJsonCallNum();
1723     for (int i = 0; i < mallocCount; i++) {
1724         ResetRecordJsonCallNum();
1725         SetJsonCallMockIndex(i);
1726         ret = gm->getDeviceInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_AUTH_ID, TEST_GROUP_ID, &returnData);
1727         if (ret != HC_SUCCESS) {
1728             continue;
1729         }
1730         gm->destroyInfo(&returnData);
1731     }
1732     DestroyDeviceAuthService();
1733 }
1734 
1735 HWTEST_F(DevAuthTest, DevAuthTest009, TestSize.Level0)
1736 {
1737     int32_t ret = InitDeviceAuthService();
1738     ASSERT_EQ(ret, HC_SUCCESS);
1739     const DeviceGroupManager *gm = GetGmInstance();
1740     ASSERT_NE(gm, nullptr);
1741     ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1742     ASSERT_EQ(ret, HC_SUCCESS);
1743     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
1744     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1745 
1746     StartRecordJsonCallNum();
1747     char *returnData = nullptr;
1748     uint32_t returnNum = 0;
1749     ret = gm->getTrustedDevices(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID, &returnData, &returnNum);
1750     ASSERT_EQ(ret, HC_SUCCESS);
1751     gm->destroyInfo(&returnData);
1752     uint32_t mallocCount = GetJsonCallNum();
1753     for (int i = 0; i < mallocCount; i++) {
1754         ResetRecordJsonCallNum();
1755         SetJsonCallMockIndex(i);
1756         ret = gm->getTrustedDevices(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID, &returnData, &returnNum);
1757         if (ret != HC_SUCCESS) {
1758             continue;
1759         }
1760         gm->destroyInfo(&returnData);
1761     }
1762     DestroyDeviceAuthService();
1763 }
1764 
1765 HWTEST_F(DevAuthTest, DevAuthTest010, TestSize.Level0)
1766 {
1767     SetIsoSupported(true);
1768     SetPakeV1Supported(false);
1769     int32_t ret = InitDeviceAuthService();
1770     ASSERT_EQ(ret, HC_SUCCESS);
1771     const DeviceGroupManager *gm = GetGmInstance();
1772     ASSERT_NE(gm, nullptr);
1773     ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1774     ASSERT_EQ(ret, HC_SUCCESS);
1775     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
1776     ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1777 
1778     StartRecordJsonCallNum();
1779     bool isExist = gm->isDeviceInGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID, TEST_AUTH_ID);
1780     ASSERT_EQ(isExist, true);
1781     uint32_t mallocCount = GetJsonCallNum();
1782     for (int i = 0; i < mallocCount; i++) {
1783         ResetRecordJsonCallNum();
1784         SetJsonCallMockIndex(i);
1785         isExist = gm->isDeviceInGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID, TEST_AUTH_ID);
1786         if (!isExist) {
1787             continue;
1788         }
1789     }
1790     DestroyDeviceAuthService();
1791 }
1792 
1793 class ExtPartTest : public testing::Test {
1794 public:
1795     static void SetUpTestCase();
1796     static void TearDownTestCase();
1797     void SetUp();
1798     void TearDown();
1799     ExtPart *extPart;
1800 };
1801 
SetUpTestCase()1802 void ExtPartTest::SetUpTestCase() {}
TearDownTestCase()1803 void ExtPartTest::TearDownTestCase() {}
1804 
SetUp()1805 void ExtPartTest::SetUp()
1806 {
1807     int ret = InitDeviceAuthService();
1808     EXPECT_EQ(ret, HC_SUCCESS);
1809     extPart = reinterpret_cast<ExtPart *>(HcMalloc(sizeof(ExtPart), 0));
1810     ASSERT_NE(extPart, nullptr);
1811 }
1812 
TearDown()1813 void ExtPartTest::TearDown()
1814 {
1815     DestroyDeviceAuthService();
1816     HcFree(extPart);
1817 }
1818 
1819 HWTEST_F(ExtPartTest, ExtPartTestTest001, TestSize.Level0)
1820 {
1821     int ret = InitExtPart(nullptr, extPart);
1822     EXPECT_EQ(ret, HC_SUCCESS);
1823 }
1824 
1825 HWTEST_F(ExtPartTest, ExtPartTestTest002, TestSize.Level0)
1826 {
1827     ExtPluginList list = GetExtPlugins(extPart);
1828     ASSERT_NE(list, nullptr);
1829 }
1830 
1831 HWTEST_F(ExtPartTest, ExtPartTestTest003, TestSize.Level0)
1832 {
1833     DestroyExtPart(extPart);
1834     ASSERT_TRUE(extPart->instance == nullptr);
1835 }
1836 }
1837