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