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