1 /*
2  * Copyright (C) 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 <cinttypes>
17 #include <unistd.h>
18 #include <gtest/gtest.h>
19 #include "alg_loader.h"
20 #include "common_defs.h"
21 #include "device_auth.h"
22 #include "device_auth_defines.h"
23 #include "iso_auth_client_task.h"
24 #include "iso_auth_server_task.h"
25 #include "iso_auth_task_common.h"
26 #include "json_utils.h"
27 #include "securec.h"
28 
29 using namespace std;
30 using namespace testing::ext;
31 
32 namespace {
33 static const std::string TEST_USER_ID = "1234ABCD";
34 static const std::string TEST_AUTH_ID = "TestAuthId";
35 static const std::string TEST_DEV_ID_EXCEED =
36     "37364761534f454d33567a73424e794f33573330507069434b31676f7254706069434b3";
37 static const std::string TEST_UDID = "TestUdid";
38 static const std::string TEST_SESSION_KEY = "2f7562744654535564586e665467546b322b4b506b65626373466f48766a4335";
39 static const std::string TEST_SEED = "2f7562744654535564586e665467546b322b4b506b65626373466f48766a4335";
40 static const std::string TEST_SALT = "2f7562744654535564586e665467546b";
41 static const std::string TEST_AUTH_CODE = "37364761534f454d33567a73424e794f33573330507069434b31676f7254706b";
42 static const std::string TEST_PAYLOAD = "37364761534f454d33567a73424e794f33573330507069434b31676f7254706b";
43 static const std::string TEST_DEV_ID = "abcabcdefa";
44 static const std::string TEST_AUTH_RESULT_MAC = "37364761534f454d33567a73424e794f33573330507069434b31676f7254706b";
45 
46 static const int SESSION_BYTES_LENGTH = 32;
47 static const int INVALID_TASK_STATUS = -1;
48 static const int TASK_STATUS_SERVER_BEGIN_TOKEN = 0;
49 static const int TASK_STATUS_SERVER_GEN_SESSION_KEY = 1;
50 static const int TASK_STATUS_SERVER_END = 2;
51 static const int TASK_STATUS_ISO_MAIN_STEP_ONE = 1;
52 static const int TASK_STATUS_ISO_MAIN_STEP_TWO = 2;
53 static const int TASK_STATUS_ISO_MAIN_END = 3;
54 
55 class IsoAuthTaskTest : public testing::Test {
56 public:
57     static void SetUpTestCase();
58     static void TearDownTestCase();
59     void SetUp();
60     void TearDown();
61 };
62 
SetUpTestCase()63 void IsoAuthTaskTest::SetUpTestCase() {}
TearDownTestCase()64 void IsoAuthTaskTest::TearDownTestCase() {}
65 
SetUp()66 void IsoAuthTaskTest::SetUp() {}
67 
TearDown()68 void IsoAuthTaskTest::TearDown() {}
69 
70 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest001, TestSize.Level0)
71 {
72     TaskBase *task = CreateIsoAuthTask(nullptr, nullptr, nullptr);
73     EXPECT_EQ(task, nullptr);
74 
75     CJson *inJson = CreateJson();
76     EXPECT_NE(inJson, nullptr);
77     (void)AddIntToJson(inJson, FIELD_AUTH_FORM, AUTH_FORM_IDENTICAL_ACCOUNT);
78     CJson *outJson = CreateJson();
79     EXPECT_NE(outJson, nullptr);
80     AccountVersionInfo info = { AUTH_PAKE_V2_EC_P256, PAKE_V2, PAKE_ALG_EC, CURVE_256, false, nullptr, nullptr};
81 
82     task = CreateIsoAuthClientTask(inJson, outJson, &info);
83     EXPECT_EQ(task, nullptr);
84 
85     (void)AddIntToJson(inJson, FIELD_CREDENTIAL_TYPE, SYMMETRIC_CRED);
86 
87     task = CreateIsoAuthClientTask(inJson, outJson, &info);
88     EXPECT_EQ(task, nullptr);
89 
90     (void)AddIntToJson(inJson, FIELD_LOCAL_DEVICE_TYPE, DEVICE_TYPE_CONTROLLER);
91 
92     task = CreateIsoAuthClientTask(inJson, outJson, &info);
93     EXPECT_EQ(task, nullptr);
94 
95     (void)AddStringToJson(inJson, FIELD_SELF_USER_ID, TEST_USER_ID.c_str());
96 
97     task = CreateIsoAuthClientTask(inJson, outJson, &info);
98     EXPECT_EQ(task, nullptr);
99 
100     (void)AddStringToJson(inJson, FIELD_SELF_DEV_ID, TEST_DEV_ID_EXCEED.c_str());
101 
102     task = CreateIsoAuthClientTask(inJson, outJson, &info);
103     EXPECT_EQ(task, nullptr);
104 
105     (void)AddStringToJson(inJson, FIELD_SELF_DEV_ID, TEST_UDID.c_str());
106 
107     task = CreateIsoAuthClientTask(inJson, outJson, &info);
108     EXPECT_EQ(task, nullptr);
109 
110     (void)AddIntToJson(inJson, FIELD_CREDENTIAL_TYPE, ASYMMETRIC_CRED);
111     (void)AddIntToJson(inJson, FIELD_LOCAL_DEVICE_TYPE, DEVICE_TYPE_ACCESSORY);
112     (void)AddStringToJson(inJson, FIELD_SELF_DEVICE_ID, TEST_AUTH_ID.c_str());
113 
114     task = CreateIsoAuthClientTask(inJson, outJson, &info);
115     EXPECT_EQ(task, nullptr);
116 
117     FreeJson(inJson);
118     FreeJson(outJson);
119 }
120 
121 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest002, TestSize.Level0)
122 {
123     int32_t ret = InitDeviceAuthService();
124     ASSERT_EQ(ret, HC_SUCCESS);
125 
126     IsoAuthParams *params = static_cast<IsoAuthParams *>(HcMalloc(sizeof(IsoAuthParams), 0));
127     EXPECT_NE(params, nullptr);
128     params->localDevType = DEVICE_TYPE_CONTROLLER;
129     ret = AccountAuthGeneratePsk(params);
130     EXPECT_NE(ret, HC_SUCCESS);
131 
132     const char *userId = TEST_USER_ID.c_str();
133     uint32_t userIdLen = HcStrlen(userId) + 1;
134     params->userIdPeer = static_cast<char *>(HcMalloc(userIdLen, 0));
135     EXPECT_NE(params->userIdPeer, nullptr);
136     (void)memcpy_s(params->userIdPeer, userIdLen, userId, userIdLen);
137 
138     const char *udid = TEST_UDID.c_str();
139     uint32_t udidLen = HcStrlen(udid) + 1;
140     params->devIdPeer.val = static_cast<uint8_t *>(HcMalloc(udidLen, 0));
141     EXPECT_NE(params->devIdPeer.val, nullptr);
142     (void)memcpy_s(params->devIdPeer.val, udidLen, udid, udidLen);
143     params->devIdPeer.length = udidLen;
144 
145     params->isoBaseParams.loader = GetLoaderInstance();
146 
147     ret = AccountAuthGeneratePsk(params);
148     EXPECT_NE(ret, HC_SUCCESS);
149 
150     HcFree(params->devIdPeer.val);
151     HcFree(params->userIdPeer);
152     HcFree(params);
153     DestroyDeviceAuthService();
154 }
155 
GetSessionKey()156 static uint8_t *GetSessionKey()
157 {
158     uint8_t *sessionBytes = static_cast<uint8_t *>(HcMalloc(SESSION_BYTES_LENGTH, 0));
159     (void)HexStringToByte(TEST_SESSION_KEY.c_str(), sessionBytes, SESSION_BYTES_LENGTH);
160     return sessionBytes;
161 }
162 
163 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest003, TestSize.Level0)
164 {
165     IsoAuthParams params;
166     int32_t ret = AuthIsoSendFinalToOut(&params, nullptr);
167     EXPECT_EQ(ret, HC_ERR_JSON_ADD);
168 
169     params.isoBaseParams.sessionKey.val = GetSessionKey();
170     params.isoBaseParams.sessionKey.length = SESSION_BYTES_LENGTH;
171 
172     ret = AuthIsoSendFinalToOut(&params, nullptr);
173     EXPECT_EQ(ret, HC_ERR_JSON_ADD);
174 
175     params.isoBaseParams.sessionKey.val = GetSessionKey();
176     params.isoBaseParams.sessionKey.length = SESSION_BYTES_LENGTH;
177     params.userIdPeer = const_cast<char *>(TEST_USER_ID.c_str());
178 
179     ret = AuthIsoSendFinalToOut(&params, nullptr);
180     EXPECT_EQ(ret, HC_ERR_JSON_ADD);
181 
182     params.isoBaseParams.sessionKey.val = GetSessionKey();
183     params.isoBaseParams.sessionKey.length = SESSION_BYTES_LENGTH;
184     params.deviceIdPeer = const_cast<char *>(TEST_AUTH_ID.c_str());
185 
186     ret = AuthIsoSendFinalToOut(&params, nullptr);
187     EXPECT_EQ(ret, HC_ERR_JSON_ADD);
188 
189     params.isoBaseParams.sessionKey.val = GetSessionKey();
190     params.isoBaseParams.sessionKey.length = SESSION_BYTES_LENGTH;
191 
192     uint32_t udidLen = HcStrlen(TEST_UDID.c_str()) + 1;
193     uint8_t *udidVal = static_cast<uint8_t *>(HcMalloc(udidLen, 0));
194     EXPECT_NE(udidVal, nullptr);
195     (void)memcpy_s(udidVal, udidLen, TEST_UDID.c_str(), udidLen);
196 
197     params.devIdPeer.val = udidVal;
198     params.devIdPeer.length = udidLen;
199 
200     ret = AuthIsoSendFinalToOut(&params, nullptr);
201     EXPECT_EQ(ret, HC_ERR_JSON_ADD);
202 
203     HcFree(udidVal);
204 }
205 
CreateServerTask(void)206 static TaskBase *CreateServerTask(void)
207 {
208     CJson *inJson = CreateJson();
209     if (inJson == nullptr) {
210         return nullptr;
211     }
212     CJson *outJson = CreateJson();
213     if (outJson == nullptr) {
214         FreeJson(inJson);
215         return nullptr;
216     }
217     (void)AddIntToJson(inJson, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
218     (void)AddIntToJson(inJson, FIELD_AUTH_FORM, AUTH_FORM_IDENTICAL_ACCOUNT);
219     (void)AddIntToJson(inJson, FIELD_CREDENTIAL_TYPE, SYMMETRIC_CRED);
220     (void)AddIntToJson(inJson, FIELD_LOCAL_DEVICE_TYPE, DEVICE_TYPE_CONTROLLER);
221     (void)AddStringToJson(inJson, FIELD_SELF_USER_ID, TEST_USER_ID.c_str());
222     (void)AddStringToJson(inJson, FIELD_SELF_DEV_ID, TEST_UDID.c_str());
223     (void)AddStringToJson(inJson, FIELD_SELF_DEVICE_ID, TEST_AUTH_ID.c_str());
224     AccountVersionInfo info = { AUTH_PAKE_V2_EC_P256, PAKE_V2, PAKE_ALG_EC, CURVE_256, false, nullptr, nullptr};
225     TaskBase *task = CreateIsoAuthServerTask(inJson, outJson, &info);
226     FreeJson(inJson);
227     FreeJson(outJson);
228     return task;
229 }
230 
231 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest004, TestSize.Level0)
232 {
233     int32_t ret = InitDeviceAuthService();
234     ASSERT_EQ(ret, HC_SUCCESS);
235 
236     CJson *outJson = CreateJson();
237     EXPECT_NE(outJson, nullptr);
238     AccountVersionInfo info = { AUTH_PAKE_V2_EC_P256, PAKE_V2, PAKE_ALG_EC, CURVE_256, false, nullptr, nullptr};
239     TaskBase *task = CreateIsoAuthServerTask(nullptr, outJson, &info);
240     EXPECT_EQ(task, nullptr);
241 
242     CJson *inJson = CreateJson();
243     EXPECT_NE(inJson, nullptr);
244     task = CreateIsoAuthServerTask(inJson, nullptr, &info);
245     EXPECT_EQ(task, nullptr);
246 
247     task = CreateIsoAuthServerTask(inJson, outJson, nullptr);
248     EXPECT_EQ(task, nullptr);
249 
250     task = CreateIsoAuthServerTask(inJson, outJson, &info);
251     EXPECT_EQ(task, nullptr);
252 
253     FreeJson(inJson);
254     FreeJson(outJson);
255     DestroyDeviceAuthService();
256 }
257 
258 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest005, TestSize.Level0)
259 {
260     int32_t ret = InitDeviceAuthService();
261     ASSERT_EQ(ret, HC_SUCCESS);
262 
263     TaskBase *task = CreateServerTask();
264     EXPECT_NE(task, nullptr);
265 
266     (void)task->getTaskType();
267 
268     CJson *in = CreateJson();
269     EXPECT_NE(in, nullptr);
270     (void)AddIntToJson(in, FIELD_STEP, CMD_ISO_AUTH_MAIN_ONE);
271     CJson *out = CreateJson();
272     EXPECT_NE(out, nullptr);
273     int32_t status = 0;
274     ret = task->process(task, in, out, &status);
275     EXPECT_EQ(ret, HC_ERR_JSON_GET);
276 
277     task->destroyTask(task);
278     FreeJson(in);
279     FreeJson(out);
280     DestroyDeviceAuthService();
281 }
282 
283 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest006, TestSize.Level0)
284 {
285     int32_t ret = InitDeviceAuthService();
286     ASSERT_EQ(ret, HC_SUCCESS);
287 
288     TaskBase *task = CreateServerTask();
289     EXPECT_NE(task, nullptr);
290 
291     CJson *in = CreateJson();
292     EXPECT_NE(in, nullptr);
293     (void)AddIntToJson(in, FIELD_STEP, CMD_ISO_AUTH_MAIN_ONE);
294     (void)AddStringToJson(in, FIELD_USER_ID, TEST_USER_ID.c_str());
295     CJson *out = CreateJson();
296     EXPECT_NE(out, nullptr);
297     int32_t status = 0;
298     IsoAuthServerTask *innerTask = reinterpret_cast<IsoAuthServerTask *>(task);
299     HcFree(innerTask->params.userIdPeer);
300     innerTask->params.userIdPeer = nullptr;
301     ret = task->process(task, in, out, &status);
302     EXPECT_EQ(ret, HC_ERR_MEMORY_COPY);
303 
304     task->destroyTask(task);
305     FreeJson(in);
306     FreeJson(out);
307     DestroyDeviceAuthService();
308 }
309 
310 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest007, TestSize.Level0)
311 {
312     int32_t ret = InitDeviceAuthService();
313     ASSERT_EQ(ret, HC_SUCCESS);
314 
315     TaskBase *task = CreateServerTask();
316     EXPECT_NE(task, nullptr);
317 
318     CJson *in = CreateJson();
319     EXPECT_NE(in, nullptr);
320     (void)AddIntToJson(in, FIELD_STEP, CMD_ISO_AUTH_MAIN_ONE);
321     (void)AddStringToJson(in, FIELD_USER_ID, TEST_USER_ID.c_str());
322     CJson *out = CreateJson();
323     EXPECT_NE(out, nullptr);
324     int32_t status = 0;
325     ret = task->process(task, in, out, &status);
326     EXPECT_EQ(ret, HC_ERR_JSON_GET);
327 
328     task->destroyTask(task);
329     FreeJson(in);
330     FreeJson(out);
331     DestroyDeviceAuthService();
332 }
333 
334 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest008, TestSize.Level0)
335 {
336     int32_t ret = InitDeviceAuthService();
337     ASSERT_EQ(ret, HC_SUCCESS);
338 
339     TaskBase *task = CreateServerTask();
340     EXPECT_NE(task, nullptr);
341 
342     CJson *in = CreateJson();
343     EXPECT_NE(in, nullptr);
344     (void)AddIntToJson(in, FIELD_STEP, CMD_ISO_AUTH_MAIN_ONE);
345     (void)AddStringToJson(in, FIELD_USER_ID, TEST_USER_ID.c_str());
346     (void)AddStringToJson(in, FIELD_SEED, TEST_SEED.c_str());
347     CJson *out = CreateJson();
348     EXPECT_NE(out, nullptr);
349     int32_t status = 0;
350     ret = task->process(task, in, out, &status);
351     EXPECT_EQ(ret, HC_ERR_JSON_GET);
352 
353     task->destroyTask(task);
354     FreeJson(in);
355     FreeJson(out);
356     DestroyDeviceAuthService();
357 }
358 
359 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest009, TestSize.Level0)
360 {
361     int32_t ret = InitDeviceAuthService();
362     ASSERT_EQ(ret, HC_SUCCESS);
363 
364     TaskBase *task = CreateServerTask();
365     EXPECT_NE(task, nullptr);
366 
367     CJson *in = CreateJson();
368     EXPECT_NE(in, nullptr);
369     (void)AddIntToJson(in, FIELD_STEP, CMD_ISO_AUTH_MAIN_ONE);
370     (void)AddStringToJson(in, FIELD_USER_ID, TEST_USER_ID.c_str());
371     (void)AddStringToJson(in, FIELD_SEED, TEST_SEED.c_str());
372     (void)AddStringToJson(in, FIELD_SALT, TEST_SALT.c_str());
373     CJson *out = CreateJson();
374     EXPECT_NE(out, nullptr);
375     int32_t status = 0;
376     ret = task->process(task, in, out, &status);
377     EXPECT_EQ(ret, HC_ERR_JSON_GET);
378 
379     task->destroyTask(task);
380     FreeJson(in);
381     FreeJson(out);
382     DestroyDeviceAuthService();
383 }
384 
385 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest010, TestSize.Level0)
386 {
387     int32_t ret = InitDeviceAuthService();
388     ASSERT_EQ(ret, HC_SUCCESS);
389 
390     TaskBase *task = CreateServerTask();
391     EXPECT_NE(task, nullptr);
392 
393     CJson *in = CreateJson();
394     EXPECT_NE(in, nullptr);
395     (void)AddIntToJson(in, FIELD_STEP, CMD_ISO_AUTH_MAIN_ONE);
396     CJson *out = CreateJson();
397     EXPECT_NE(out, nullptr);
398     int32_t status = 0;
399     task->taskStatus = INVALID_TASK_STATUS;
400     ret = task->process(task, in, out, &status);
401     EXPECT_EQ(ret, HC_ERR_BAD_MESSAGE);
402 
403     task->destroyTask(task);
404     FreeJson(in);
405     FreeJson(out);
406     DestroyDeviceAuthService();
407 }
408 
409 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest011, TestSize.Level0)
410 {
411     int32_t ret = InitDeviceAuthService();
412     ASSERT_EQ(ret, HC_SUCCESS);
413 
414     TaskBase *task = CreateServerTask();
415     EXPECT_NE(task, nullptr);
416 
417     CJson *in = CreateJson();
418     EXPECT_NE(in, nullptr);
419     (void)AddIntToJson(in, FIELD_STEP, CMD_ISO_AUTH_MAIN_ONE);
420     CJson *out = CreateJson();
421     EXPECT_NE(out, nullptr);
422     int32_t status = 0;
423     task->taskStatus = TASK_STATUS_SERVER_GEN_SESSION_KEY;
424     ret = task->process(task, in, out, &status);
425     EXPECT_EQ(ret, HC_SUCCESS);
426 
427     task->destroyTask(task);
428     FreeJson(in);
429     FreeJson(out);
430     DestroyDeviceAuthService();
431 }
432 
433 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest012, TestSize.Level0)
434 {
435     int32_t ret = InitDeviceAuthService();
436     ASSERT_EQ(ret, HC_SUCCESS);
437 
438     TaskBase *task = CreateServerTask();
439     EXPECT_NE(task, nullptr);
440 
441     CJson *in = CreateJson();
442     EXPECT_NE(in, nullptr);
443     (void)AddIntToJson(in, FIELD_STEP, CMD_ISO_AUTH_MAIN_TWO);
444     CJson *out = CreateJson();
445     EXPECT_NE(out, nullptr);
446     int32_t status = 0;
447     task->taskStatus = TASK_STATUS_SERVER_BEGIN_TOKEN;
448     ret = task->process(task, in, out, &status);
449     EXPECT_EQ(ret, HC_ERR_BAD_MESSAGE);
450 
451     task->destroyTask(task);
452     FreeJson(in);
453     FreeJson(out);
454     DestroyDeviceAuthService();
455 }
456 
457 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest013, TestSize.Level0)
458 {
459     int32_t ret = InitDeviceAuthService();
460     ASSERT_EQ(ret, HC_SUCCESS);
461 
462     TaskBase *task = CreateServerTask();
463     EXPECT_NE(task, nullptr);
464 
465     CJson *in = CreateJson();
466     EXPECT_NE(in, nullptr);
467     (void)AddIntToJson(in, FIELD_STEP, CMD_ISO_AUTH_MAIN_TWO);
468     CJson *out = CreateJson();
469     EXPECT_NE(out, nullptr);
470     int32_t status = 0;
471     task->taskStatus = TASK_STATUS_SERVER_END;
472     ret = task->process(task, in, out, &status);
473     EXPECT_EQ(ret, HC_SUCCESS);
474 
475     task->destroyTask(task);
476     FreeJson(in);
477     FreeJson(out);
478     DestroyDeviceAuthService();
479 }
480 
481 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest014, TestSize.Level0)
482 {
483     int32_t ret = InitDeviceAuthService();
484     ASSERT_EQ(ret, HC_SUCCESS);
485 
486     TaskBase *task = CreateServerTask();
487     EXPECT_NE(task, nullptr);
488 
489     CJson *in = CreateJson();
490     EXPECT_NE(in, nullptr);
491     (void)AddIntToJson(in, FIELD_STEP, CMD_ISO_AUTH_MAIN_TWO);
492     CJson *out = CreateJson();
493     EXPECT_NE(out, nullptr);
494     int32_t status = 0;
495     task->taskStatus = TASK_STATUS_SERVER_GEN_SESSION_KEY;
496     ret = task->process(task, in, out, &status);
497     EXPECT_EQ(ret, HC_ERR_JSON_GET);
498 
499     task->destroyTask(task);
500     FreeJson(in);
501     FreeJson(out);
502     DestroyDeviceAuthService();
503 }
504 
505 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest015, TestSize.Level0)
506 {
507     int32_t ret = InitDeviceAuthService();
508     ASSERT_EQ(ret, HC_SUCCESS);
509 
510     TaskBase *task = CreateServerTask();
511     EXPECT_NE(task, nullptr);
512 
513     CJson *in = CreateJson();
514     EXPECT_NE(in, nullptr);
515     (void)AddIntToJson(in, FIELD_STEP, CMD_ISO_AUTH_MAIN_TWO);
516     (void)AddStringToJson(in, FIELD_TOKEN, TEST_AUTH_CODE.c_str());
517     CJson *out = CreateJson();
518     EXPECT_NE(out, nullptr);
519     int32_t status = 0;
520     task->taskStatus = TASK_STATUS_SERVER_GEN_SESSION_KEY;
521     ret = task->process(task, in, out, &status);
522     EXPECT_NE(ret, HC_SUCCESS);
523 
524     task->destroyTask(task);
525     FreeJson(in);
526     FreeJson(out);
527     DestroyDeviceAuthService();
528 }
529 
530 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest016, TestSize.Level0)
531 {
532     int32_t ret = InitDeviceAuthService();
533     ASSERT_EQ(ret, HC_SUCCESS);
534 
535     TaskBase *task = CreateServerTask();
536     EXPECT_NE(task, nullptr);
537 
538     int32_t status = 0;
539     ret = task->process(task, nullptr, nullptr, &status);
540     EXPECT_EQ(ret, HC_ERR_JSON_GET);
541 
542     task->destroyTask(task);
543     DestroyDeviceAuthService();
544 }
545 
546 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest017, TestSize.Level0)
547 {
548     int32_t ret = InitDeviceAuthService();
549     ASSERT_EQ(ret, HC_SUCCESS);
550 
551     CJson *outJson = CreateJson();
552     ASSERT_NE(outJson, nullptr);
553     AccountVersionInfo info = { AUTH_PAKE_V2_EC_P256, PAKE_V2, PAKE_ALG_EC, CURVE_256, false, nullptr, nullptr};
554     TaskBase *task = CreateIsoAuthClientTask(nullptr, outJson, &info);
555     EXPECT_EQ(task, nullptr);
556 
557     CJson *inJson = CreateJson();
558     ASSERT_NE(inJson, nullptr);
559     task = CreateIsoAuthClientTask(inJson, nullptr, &info);
560     EXPECT_EQ(task, nullptr);
561 
562     task = CreateIsoAuthClientTask(inJson, outJson, nullptr);
563     EXPECT_EQ(task, nullptr);
564 
565     task = CreateIsoAuthClientTask(inJson, outJson, &info);
566     EXPECT_EQ(task, nullptr);
567 
568     FreeJson(inJson);
569     FreeJson(outJson);
570     DestroyDeviceAuthService();
571 }
572 
CreateClientTask(void)573 static TaskBase *CreateClientTask(void)
574 {
575     CJson *inJson = CreateJson();
576     if (inJson == nullptr) {
577         return nullptr;
578     }
579     CJson *outJson = CreateJson();
580     if (outJson == nullptr) {
581         FreeJson(inJson);
582         return nullptr;
583     }
584     (void)AddIntToJson(inJson, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
585     (void)AddIntToJson(inJson, FIELD_AUTH_FORM, AUTH_FORM_IDENTICAL_ACCOUNT);
586     (void)AddIntToJson(inJson, FIELD_CREDENTIAL_TYPE, SYMMETRIC_CRED);
587     (void)AddIntToJson(inJson, FIELD_LOCAL_DEVICE_TYPE, DEVICE_TYPE_CONTROLLER);
588     (void)AddStringToJson(inJson, FIELD_SELF_USER_ID, TEST_USER_ID.c_str());
589     (void)AddStringToJson(inJson, FIELD_SELF_DEV_ID, TEST_UDID.c_str());
590     (void)AddStringToJson(inJson, FIELD_SELF_DEVICE_ID, TEST_AUTH_ID.c_str());
591     AccountVersionInfo info = { AUTH_PAKE_V2_EC_P256, PAKE_V2, PAKE_ALG_EC, CURVE_256, false, nullptr, nullptr};
592     TaskBase *task = CreateIsoAuthClientTask(inJson, outJson, &info);
593     FreeJson(inJson);
594     FreeJson(outJson);
595     return task;
596 }
597 
598 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest018, TestSize.Level0)
599 {
600     int32_t ret = InitDeviceAuthService();
601     ASSERT_EQ(ret, HC_SUCCESS);
602 
603     TaskBase *task = CreateClientTask();
604     EXPECT_NE(task, nullptr);
605 
606     (void)task->getTaskType();
607 
608     CJson *out = CreateJson();
609     EXPECT_NE(out, nullptr);
610     int32_t status = 0;
611     IsoAuthClientTask *innerTask = reinterpret_cast<IsoAuthClientTask *>(task);
612     HcFree(innerTask->params.isoBaseParams.authIdSelf.val);
613     innerTask->params.isoBaseParams.authIdSelf.val = nullptr;
614     ret = task->process(task, nullptr, out, &status);
615     EXPECT_EQ(ret, HC_ERR_JSON_ADD);
616 
617     task->destroyTask(task);
618     FreeJson(out);
619     DestroyDeviceAuthService();
620 }
621 
622 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest019, TestSize.Level0)
623 {
624     int32_t ret = InitDeviceAuthService();
625     ASSERT_EQ(ret, HC_SUCCESS);
626 
627     TaskBase *task = CreateClientTask();
628     EXPECT_NE(task, nullptr);
629 
630     CJson *out = CreateJson();
631     EXPECT_NE(out, nullptr);
632     int32_t status = 0;
633     IsoAuthClientTask *innerTask = reinterpret_cast<IsoAuthClientTask *>(task);
634     HcFree(innerTask->params.userIdSelf);
635     innerTask->params.userIdSelf = nullptr;
636     ret = task->process(task, nullptr, out, &status);
637     EXPECT_EQ(ret, HC_ERR_JSON_ADD);
638 
639     task->destroyTask(task);
640     FreeJson(out);
641     DestroyDeviceAuthService();
642 }
643 
644 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest020, TestSize.Level0)
645 {
646     int32_t ret = InitDeviceAuthService();
647     ASSERT_EQ(ret, HC_SUCCESS);
648 
649     TaskBase *task = CreateClientTask();
650     EXPECT_NE(task, nullptr);
651 
652     CJson *out = CreateJson();
653     EXPECT_NE(out, nullptr);
654     int32_t status = 0;
655     IsoAuthClientTask *innerTask = reinterpret_cast<IsoAuthClientTask *>(task);
656     HcFree(innerTask->params.devIdSelf.val);
657     innerTask->params.devIdSelf.val = nullptr;
658     ret = task->process(task, nullptr, out, &status);
659     EXPECT_EQ(ret, HC_ERR_JSON_ADD);
660 
661     task->destroyTask(task);
662     FreeJson(out);
663     DestroyDeviceAuthService();
664 }
665 
666 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest021, TestSize.Level0)
667 {
668     int32_t ret = InitDeviceAuthService();
669     ASSERT_EQ(ret, HC_SUCCESS);
670 
671     TaskBase *task = CreateClientTask();
672     EXPECT_NE(task, nullptr);
673 
674     CJson *out = CreateJson();
675     EXPECT_NE(out, nullptr);
676     int32_t status = 0;
677     IsoAuthClientTask *innerTask = reinterpret_cast<IsoAuthClientTask *>(task);
678     HcFree(innerTask->params.deviceIdSelf);
679     innerTask->params.deviceIdSelf = nullptr;
680     ret = task->process(task, nullptr, out, &status);
681     EXPECT_EQ(ret, HC_ERR_JSON_ADD);
682 
683     task->destroyTask(task);
684     FreeJson(out);
685     DestroyDeviceAuthService();
686 }
687 
688 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest022, TestSize.Level0)
689 {
690     int32_t ret = InitDeviceAuthService();
691     ASSERT_EQ(ret, HC_SUCCESS);
692 
693     TaskBase *task = CreateClientTask();
694     EXPECT_NE(task, nullptr);
695 
696     int32_t status = 0;
697     ret = task->process(task, nullptr, nullptr, &status);
698     EXPECT_EQ(ret, HC_ERR_JSON_ADD);
699 
700     task->destroyTask(task);
701     DestroyDeviceAuthService();
702 }
703 
704 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest023, TestSize.Level0)
705 {
706     int32_t ret = InitDeviceAuthService();
707     ASSERT_EQ(ret, HC_SUCCESS);
708 
709     TaskBase *task = CreateClientTask();
710     EXPECT_NE(task, nullptr);
711 
712     CJson *in = CreateJson();
713     EXPECT_NE(in, nullptr);
714     (void)AddIntToJson(in, FIELD_STEP, RET_ISO_AUTH_FOLLOWER_ONE);
715     CJson *out = CreateJson();
716     EXPECT_NE(out, nullptr);
717     task->taskStatus = TASK_STATUS_ISO_MAIN_STEP_ONE;
718     int32_t status = 0;
719     ret = task->process(task, in, out, &status);
720     EXPECT_EQ(ret, HC_ERR_JSON_GET);
721 
722     task->destroyTask(task);
723     FreeJson(in);
724     FreeJson(out);
725     DestroyDeviceAuthService();
726 }
727 
728 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest024, TestSize.Level0)
729 {
730     int32_t ret = InitDeviceAuthService();
731     ASSERT_EQ(ret, HC_SUCCESS);
732 
733     TaskBase *task = CreateClientTask();
734     EXPECT_NE(task, nullptr);
735 
736     CJson *in = CreateJson();
737     EXPECT_NE(in, nullptr);
738     (void)AddIntToJson(in, FIELD_STEP, RET_ISO_AUTH_FOLLOWER_ONE);
739     (void)AddStringToJson(in, FIELD_USER_ID, TEST_USER_ID.c_str());
740     CJson *out = CreateJson();
741     EXPECT_NE(out, nullptr);
742     task->taskStatus = TASK_STATUS_ISO_MAIN_STEP_ONE;
743     IsoAuthClientTask *innerTask = reinterpret_cast<IsoAuthClientTask *>(task);
744     HcFree(innerTask->params.userIdPeer);
745     innerTask->params.userIdPeer = nullptr;
746     int32_t status = 0;
747     ret = task->process(task, in, out, &status);
748     EXPECT_EQ(ret, HC_ERR_MEMORY_COPY);
749 
750     task->destroyTask(task);
751     FreeJson(in);
752     FreeJson(out);
753     DestroyDeviceAuthService();
754 }
755 
756 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest025, TestSize.Level0)
757 {
758     int32_t ret = InitDeviceAuthService();
759     ASSERT_EQ(ret, HC_SUCCESS);
760 
761     TaskBase *task = CreateClientTask();
762     EXPECT_NE(task, nullptr);
763 
764     CJson *in = CreateJson();
765     EXPECT_NE(in, nullptr);
766     (void)AddIntToJson(in, FIELD_STEP, RET_ISO_AUTH_FOLLOWER_ONE);
767     (void)AddStringToJson(in, FIELD_USER_ID, TEST_USER_ID.c_str());
768     (void)AddStringToJson(in, FIELD_SALT, TEST_SALT.c_str());
769     CJson *out = CreateJson();
770     EXPECT_NE(out, nullptr);
771     task->taskStatus = TASK_STATUS_ISO_MAIN_STEP_ONE;
772     int32_t status = 0;
773     ret = task->process(task, in, out, &status);
774     EXPECT_EQ(ret, HC_ERR_JSON_GET);
775 
776     task->destroyTask(task);
777     FreeJson(in);
778     FreeJson(out);
779     DestroyDeviceAuthService();
780 }
781 
782 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest026, TestSize.Level0)
783 {
784     int32_t ret = InitDeviceAuthService();
785     ASSERT_EQ(ret, HC_SUCCESS);
786 
787     TaskBase *task = CreateClientTask();
788     EXPECT_NE(task, nullptr);
789 
790     CJson *in = CreateJson();
791     EXPECT_NE(in, nullptr);
792     (void)AddIntToJson(in, FIELD_STEP, RET_ISO_AUTH_FOLLOWER_ONE);
793     (void)AddStringToJson(in, FIELD_USER_ID, TEST_USER_ID.c_str());
794     (void)AddStringToJson(in, FIELD_SALT, TEST_SALT.c_str());
795     (void)AddStringToJson(in, FIELD_TOKEN, TEST_AUTH_CODE.c_str());
796     CJson *out = CreateJson();
797     EXPECT_NE(out, nullptr);
798     task->taskStatus = TASK_STATUS_ISO_MAIN_STEP_ONE;
799     int32_t status = 0;
800     ret = task->process(task, in, out, &status);
801     EXPECT_EQ(ret, HC_ERR_JSON_GET);
802 
803     task->destroyTask(task);
804     FreeJson(in);
805     FreeJson(out);
806     DestroyDeviceAuthService();
807 }
808 
809 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest027, TestSize.Level0)
810 {
811     int32_t ret = InitDeviceAuthService();
812     ASSERT_EQ(ret, HC_SUCCESS);
813 
814     TaskBase *task = CreateClientTask();
815     EXPECT_NE(task, nullptr);
816 
817     CJson *in = CreateJson();
818     EXPECT_NE(in, nullptr);
819     (void)AddIntToJson(in, FIELD_STEP, RET_ISO_AUTH_FOLLOWER_ONE);
820     (void)AddStringToJson(in, FIELD_USER_ID, TEST_USER_ID.c_str());
821     (void)AddStringToJson(in, FIELD_SALT, TEST_SALT.c_str());
822     (void)AddStringToJson(in, FIELD_TOKEN, TEST_AUTH_CODE.c_str());
823     (void)AddStringToJson(in, FIELD_PAYLOAD, TEST_PAYLOAD.c_str());
824     CJson *out = CreateJson();
825     EXPECT_NE(out, nullptr);
826     task->taskStatus = TASK_STATUS_ISO_MAIN_STEP_ONE;
827     int32_t status = 0;
828     ret = task->process(task, in, out, &status);
829     EXPECT_EQ(ret, HC_ERR_JSON_GET);
830 
831     task->destroyTask(task);
832     FreeJson(in);
833     FreeJson(out);
834     DestroyDeviceAuthService();
835 }
836 
837 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest028, TestSize.Level0)
838 {
839     int32_t ret = InitDeviceAuthService();
840     ASSERT_EQ(ret, HC_SUCCESS);
841 
842     TaskBase *task = CreateClientTask();
843     EXPECT_NE(task, nullptr);
844 
845     CJson *in = CreateJson();
846     EXPECT_NE(in, nullptr);
847     (void)AddIntToJson(in, FIELD_STEP, RET_ISO_AUTH_FOLLOWER_ONE);
848     (void)AddStringToJson(in, FIELD_USER_ID, TEST_USER_ID.c_str());
849     (void)AddStringToJson(in, FIELD_SALT, TEST_SALT.c_str());
850     (void)AddStringToJson(in, FIELD_TOKEN, TEST_AUTH_CODE.c_str());
851     (void)AddStringToJson(in, FIELD_PAYLOAD, "");
852     CJson *out = CreateJson();
853     EXPECT_NE(out, nullptr);
854     task->taskStatus = TASK_STATUS_ISO_MAIN_STEP_ONE;
855     int32_t status = 0;
856     ret = task->process(task, in, out, &status);
857     EXPECT_EQ(ret, HC_ERR_ALLOC_MEMORY);
858 
859     task->destroyTask(task);
860     FreeJson(in);
861     FreeJson(out);
862     DestroyDeviceAuthService();
863 }
864 
865 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest029, TestSize.Level0)
866 {
867     int32_t ret = InitDeviceAuthService();
868     ASSERT_EQ(ret, HC_SUCCESS);
869 
870     TaskBase *task = CreateClientTask();
871     EXPECT_NE(task, nullptr);
872 
873     CJson *in = CreateJson();
874     EXPECT_NE(in, nullptr);
875     (void)AddIntToJson(in, FIELD_STEP, RET_ISO_AUTH_FOLLOWER_ONE);
876     (void)AddStringToJson(in, FIELD_USER_ID, TEST_USER_ID.c_str());
877     (void)AddStringToJson(in, FIELD_SALT, TEST_SALT.c_str());
878     (void)AddStringToJson(in, FIELD_TOKEN, TEST_AUTH_CODE.c_str());
879     (void)AddStringToJson(in, FIELD_PAYLOAD, TEST_PAYLOAD.c_str());
880     // GetPayloadValue convert hex string to byte failed
881     (void)AddStringToJson(in, FIELD_DEV_ID, TEST_UDID.c_str());
882     CJson *out = CreateJson();
883     EXPECT_NE(out, nullptr);
884     task->taskStatus = TASK_STATUS_ISO_MAIN_STEP_ONE;
885     int32_t status = 0;
886     ret = task->process(task, in, out, &status);
887     EXPECT_EQ(ret, HC_ERR_CONVERT_FAILED);
888 
889     task->destroyTask(task);
890     FreeJson(in);
891     FreeJson(out);
892     DestroyDeviceAuthService();
893 }
894 
895 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest030, TestSize.Level0)
896 {
897     int32_t ret = InitDeviceAuthService();
898     ASSERT_EQ(ret, HC_SUCCESS);
899 
900     TaskBase *task = CreateClientTask();
901     EXPECT_NE(task, nullptr);
902 
903     CJson *in = CreateJson();
904     EXPECT_NE(in, nullptr);
905     (void)AddIntToJson(in, FIELD_STEP, RET_ISO_AUTH_FOLLOWER_ONE);
906     (void)AddStringToJson(in, FIELD_USER_ID, TEST_USER_ID.c_str());
907     (void)AddStringToJson(in, FIELD_SALT, TEST_SALT.c_str());
908     (void)AddStringToJson(in, FIELD_TOKEN, TEST_AUTH_CODE.c_str());
909     (void)AddStringToJson(in, FIELD_PAYLOAD, TEST_PAYLOAD.c_str());
910     (void)AddStringToJson(in, FIELD_DEV_ID, TEST_DEV_ID.c_str());
911     CJson *out = CreateJson();
912     EXPECT_NE(out, nullptr);
913     task->taskStatus = TASK_STATUS_ISO_MAIN_STEP_ONE;
914     int32_t status = 0;
915     ret = task->process(task, in, out, &status);
916     EXPECT_EQ(ret, HC_ERR_JSON_GET);
917 
918     task->destroyTask(task);
919     FreeJson(in);
920     FreeJson(out);
921     DestroyDeviceAuthService();
922 }
923 
924 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest031, TestSize.Level0)
925 {
926     int32_t ret = InitDeviceAuthService();
927     ASSERT_EQ(ret, HC_SUCCESS);
928 
929     TaskBase *task = CreateClientTask();
930     EXPECT_NE(task, nullptr);
931 
932     CJson *in = CreateJson();
933     EXPECT_NE(in, nullptr);
934     (void)AddIntToJson(in, FIELD_STEP, RET_ISO_AUTH_FOLLOWER_ONE);
935     (void)AddStringToJson(in, FIELD_USER_ID, TEST_USER_ID.c_str());
936     (void)AddStringToJson(in, FIELD_SALT, TEST_SALT.c_str());
937     (void)AddStringToJson(in, FIELD_TOKEN, TEST_AUTH_CODE.c_str());
938     (void)AddStringToJson(in, FIELD_PAYLOAD, TEST_PAYLOAD.c_str());
939     (void)AddStringToJson(in, FIELD_DEV_ID, TEST_DEV_ID.c_str());
940     (void)AddStringToJson(in, FIELD_DEVICE_ID, TEST_AUTH_ID.c_str());
941     CJson *out = CreateJson();
942     EXPECT_NE(out, nullptr);
943     task->taskStatus = TASK_STATUS_ISO_MAIN_STEP_ONE;
944     int32_t status = 0;
945     ret = task->process(task, in, out, &status);
946     EXPECT_EQ(ret, HC_ERR_MEMORY_COMPARE);
947 
948     task->destroyTask(task);
949     FreeJson(in);
950     FreeJson(out);
951     DestroyDeviceAuthService();
952 }
953 
954 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest032, TestSize.Level0)
955 {
956     int32_t ret = InitDeviceAuthService();
957     ASSERT_EQ(ret, HC_SUCCESS);
958 
959     TaskBase *task = CreateClientTask();
960     EXPECT_NE(task, nullptr);
961 
962     CJson *in = CreateJson();
963     EXPECT_NE(in, nullptr);
964     (void)AddIntToJson(in, FIELD_STEP, RET_ISO_AUTH_FOLLOWER_ONE);
965     CJson *out = CreateJson();
966     EXPECT_NE(out, nullptr);
967     task->taskStatus = INVALID_TASK_STATUS;
968     int32_t status = 0;
969     ret = task->process(task, in, out, &status);
970     EXPECT_EQ(ret, HC_ERR_BAD_MESSAGE);
971 
972     task->destroyTask(task);
973     FreeJson(in);
974     FreeJson(out);
975     DestroyDeviceAuthService();
976 }
977 
978 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest033, TestSize.Level0)
979 {
980     int32_t ret = InitDeviceAuthService();
981     ASSERT_EQ(ret, HC_SUCCESS);
982 
983     TaskBase *task = CreateClientTask();
984     EXPECT_NE(task, nullptr);
985 
986     CJson *in = CreateJson();
987     EXPECT_NE(in, nullptr);
988     (void)AddIntToJson(in, FIELD_STEP, RET_ISO_AUTH_FOLLOWER_ONE);
989     CJson *out = CreateJson();
990     EXPECT_NE(out, nullptr);
991     task->taskStatus = TASK_STATUS_ISO_MAIN_STEP_TWO;
992     int32_t status = 0;
993     ret = task->process(task, in, out, &status);
994     EXPECT_EQ(ret, HC_SUCCESS);
995 
996     task->destroyTask(task);
997     FreeJson(in);
998     FreeJson(out);
999     DestroyDeviceAuthService();
1000 }
1001 
1002 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest034, TestSize.Level0)
1003 {
1004     int32_t ret = InitDeviceAuthService();
1005     ASSERT_EQ(ret, HC_SUCCESS);
1006 
1007     TaskBase *task = CreateClientTask();
1008     EXPECT_NE(task, nullptr);
1009 
1010     CJson *in = CreateJson();
1011     EXPECT_NE(in, nullptr);
1012     (void)AddIntToJson(in, FIELD_STEP, RET_ISO_AUTH_FOLLOWER_TWO);
1013     CJson *out = CreateJson();
1014     EXPECT_NE(out, nullptr);
1015     task->taskStatus = TASK_STATUS_ISO_MAIN_STEP_ONE;
1016     int32_t status = 0;
1017     ret = task->process(task, in, out, &status);
1018     EXPECT_EQ(ret, HC_ERR_BAD_MESSAGE);
1019 
1020     task->destroyTask(task);
1021     FreeJson(in);
1022     FreeJson(out);
1023     DestroyDeviceAuthService();
1024 }
1025 
1026 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest035, TestSize.Level0)
1027 {
1028     int32_t ret = InitDeviceAuthService();
1029     ASSERT_EQ(ret, HC_SUCCESS);
1030 
1031     TaskBase *task = CreateClientTask();
1032     EXPECT_NE(task, nullptr);
1033 
1034     CJson *in = CreateJson();
1035     EXPECT_NE(in, nullptr);
1036     (void)AddIntToJson(in, FIELD_STEP, RET_ISO_AUTH_FOLLOWER_TWO);
1037     CJson *out = CreateJson();
1038     EXPECT_NE(out, nullptr);
1039     task->taskStatus = TASK_STATUS_ISO_MAIN_END;
1040     int32_t status = 0;
1041     ret = task->process(task, in, out, &status);
1042     EXPECT_EQ(ret, HC_SUCCESS);
1043 
1044     task->destroyTask(task);
1045     FreeJson(in);
1046     FreeJson(out);
1047     DestroyDeviceAuthService();
1048 }
1049 
1050 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest036, TestSize.Level0)
1051 {
1052     int32_t ret = InitDeviceAuthService();
1053     ASSERT_EQ(ret, HC_SUCCESS);
1054 
1055     TaskBase *task = CreateClientTask();
1056     EXPECT_NE(task, nullptr);
1057 
1058     CJson *in = CreateJson();
1059     EXPECT_NE(in, nullptr);
1060     (void)AddIntToJson(in, FIELD_STEP, RET_ISO_AUTH_FOLLOWER_TWO);
1061     CJson *out = CreateJson();
1062     EXPECT_NE(out, nullptr);
1063     task->taskStatus = TASK_STATUS_ISO_MAIN_STEP_TWO;
1064     int32_t status = 0;
1065     ret = task->process(task, in, out, &status);
1066     EXPECT_EQ(ret, HC_ERR_JSON_GET);
1067 
1068     task->destroyTask(task);
1069     FreeJson(in);
1070     FreeJson(out);
1071     DestroyDeviceAuthService();
1072 }
1073 
1074 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest037, TestSize.Level0)
1075 {
1076     int32_t ret = InitDeviceAuthService();
1077     ASSERT_EQ(ret, HC_SUCCESS);
1078 
1079     TaskBase *task = CreateClientTask();
1080     EXPECT_NE(task, nullptr);
1081 
1082     CJson *in = CreateJson();
1083     EXPECT_NE(in, nullptr);
1084     (void)AddIntToJson(in, FIELD_STEP, RET_ISO_AUTH_FOLLOWER_TWO);
1085     (void)AddStringToJson(in, FIELD_AUTH_RESULT_MAC, TEST_AUTH_RESULT_MAC.c_str());
1086     CJson *out = CreateJson();
1087     EXPECT_NE(out, nullptr);
1088     task->taskStatus = TASK_STATUS_ISO_MAIN_STEP_TWO;
1089     int32_t status = 0;
1090     ret = task->process(task, in, out, &status);
1091     EXPECT_NE(ret, HC_SUCCESS);
1092 
1093     task->destroyTask(task);
1094     FreeJson(in);
1095     FreeJson(out);
1096     DestroyDeviceAuthService();
1097 }
1098 
1099 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest038, TestSize.Level0)
1100 {
1101     int32_t ret = InitDeviceAuthService();
1102     ASSERT_EQ(ret, HC_SUCCESS);
1103 
1104     TaskBase *task = CreateClientTask();
1105     EXPECT_NE(task, nullptr);
1106 
1107     task->taskStatus = TASK_STATUS_ISO_MAIN_STEP_ONE;
1108     int32_t status = 0;
1109     ret = task->process(task, nullptr, nullptr, &status);
1110     EXPECT_EQ(ret, HC_ERR_JSON_GET);
1111 
1112     task->destroyTask(task);
1113     DestroyDeviceAuthService();
1114 }
1115 }