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(¶ms, 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(¶ms, 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(¶ms, 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(¶ms, 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(¶ms, 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_AUTH_FORM, AUTH_FORM_IDENTICAL_ACCOUNT);
218 (void)AddIntToJson(inJson, FIELD_CREDENTIAL_TYPE, SYMMETRIC_CRED);
219 (void)AddIntToJson(inJson, FIELD_LOCAL_DEVICE_TYPE, DEVICE_TYPE_CONTROLLER);
220 (void)AddStringToJson(inJson, FIELD_SELF_USER_ID, TEST_USER_ID.c_str());
221 (void)AddStringToJson(inJson, FIELD_SELF_DEV_ID, TEST_UDID.c_str());
222 (void)AddStringToJson(inJson, FIELD_SELF_DEVICE_ID, TEST_AUTH_ID.c_str());
223 AccountVersionInfo info = { AUTH_PAKE_V2_EC_P256, PAKE_V2, PAKE_ALG_EC, CURVE_256, false, nullptr, nullptr};
224 TaskBase *task = CreateIsoAuthServerTask(inJson, outJson, &info);
225 FreeJson(inJson);
226 FreeJson(outJson);
227 return task;
228 }
229
230 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest004, TestSize.Level0)
231 {
232 int32_t ret = InitDeviceAuthService();
233 ASSERT_EQ(ret, HC_SUCCESS);
234
235 CJson *outJson = CreateJson();
236 EXPECT_NE(outJson, nullptr);
237 AccountVersionInfo info = { AUTH_PAKE_V2_EC_P256, PAKE_V2, PAKE_ALG_EC, CURVE_256, false, nullptr, nullptr};
238 TaskBase *task = CreateIsoAuthServerTask(nullptr, outJson, &info);
239 EXPECT_EQ(task, nullptr);
240
241 CJson *inJson = CreateJson();
242 EXPECT_NE(inJson, nullptr);
243 task = CreateIsoAuthServerTask(inJson, nullptr, &info);
244 EXPECT_EQ(task, nullptr);
245
246 task = CreateIsoAuthServerTask(inJson, outJson, nullptr);
247 EXPECT_EQ(task, nullptr);
248
249 task = CreateIsoAuthServerTask(inJson, outJson, &info);
250 EXPECT_EQ(task, nullptr);
251
252 FreeJson(inJson);
253 FreeJson(outJson);
254 DestroyDeviceAuthService();
255 }
256
257 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest005, TestSize.Level0)
258 {
259 int32_t ret = InitDeviceAuthService();
260 ASSERT_EQ(ret, HC_SUCCESS);
261
262 TaskBase *task = CreateServerTask();
263 EXPECT_NE(task, nullptr);
264
265 (void)task->getTaskType();
266
267 CJson *in = CreateJson();
268 EXPECT_NE(in, nullptr);
269 (void)AddIntToJson(in, FIELD_STEP, CMD_ISO_AUTH_MAIN_ONE);
270 CJson *out = CreateJson();
271 EXPECT_NE(out, nullptr);
272 int32_t status = 0;
273 ret = task->process(task, in, out, &status);
274 EXPECT_EQ(ret, HC_ERR_JSON_GET);
275
276 task->destroyTask(task);
277 FreeJson(in);
278 FreeJson(out);
279 DestroyDeviceAuthService();
280 }
281
282 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest006, TestSize.Level0)
283 {
284 int32_t ret = InitDeviceAuthService();
285 ASSERT_EQ(ret, HC_SUCCESS);
286
287 TaskBase *task = CreateServerTask();
288 EXPECT_NE(task, nullptr);
289
290 CJson *in = CreateJson();
291 EXPECT_NE(in, nullptr);
292 (void)AddIntToJson(in, FIELD_STEP, CMD_ISO_AUTH_MAIN_ONE);
293 (void)AddStringToJson(in, FIELD_USER_ID, TEST_USER_ID.c_str());
294 CJson *out = CreateJson();
295 EXPECT_NE(out, nullptr);
296 int32_t status = 0;
297 IsoAuthServerTask *innerTask = reinterpret_cast<IsoAuthServerTask *>(task);
298 HcFree(innerTask->params.userIdPeer);
299 innerTask->params.userIdPeer = nullptr;
300 ret = task->process(task, in, out, &status);
301 EXPECT_EQ(ret, HC_ERR_MEMORY_COPY);
302
303 task->destroyTask(task);
304 FreeJson(in);
305 FreeJson(out);
306 DestroyDeviceAuthService();
307 }
308
309 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest007, TestSize.Level0)
310 {
311 int32_t ret = InitDeviceAuthService();
312 ASSERT_EQ(ret, HC_SUCCESS);
313
314 TaskBase *task = CreateServerTask();
315 EXPECT_NE(task, nullptr);
316
317 CJson *in = CreateJson();
318 EXPECT_NE(in, nullptr);
319 (void)AddIntToJson(in, FIELD_STEP, CMD_ISO_AUTH_MAIN_ONE);
320 (void)AddStringToJson(in, FIELD_USER_ID, TEST_USER_ID.c_str());
321 CJson *out = CreateJson();
322 EXPECT_NE(out, nullptr);
323 int32_t status = 0;
324 ret = task->process(task, in, out, &status);
325 EXPECT_EQ(ret, HC_ERR_JSON_GET);
326
327 task->destroyTask(task);
328 FreeJson(in);
329 FreeJson(out);
330 DestroyDeviceAuthService();
331 }
332
333 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest008, TestSize.Level0)
334 {
335 int32_t ret = InitDeviceAuthService();
336 ASSERT_EQ(ret, HC_SUCCESS);
337
338 TaskBase *task = CreateServerTask();
339 EXPECT_NE(task, nullptr);
340
341 CJson *in = CreateJson();
342 EXPECT_NE(in, nullptr);
343 (void)AddIntToJson(in, FIELD_STEP, CMD_ISO_AUTH_MAIN_ONE);
344 (void)AddStringToJson(in, FIELD_USER_ID, TEST_USER_ID.c_str());
345 (void)AddStringToJson(in, FIELD_SEED, TEST_SEED.c_str());
346 CJson *out = CreateJson();
347 EXPECT_NE(out, nullptr);
348 int32_t status = 0;
349 ret = task->process(task, in, out, &status);
350 EXPECT_EQ(ret, HC_ERR_JSON_GET);
351
352 task->destroyTask(task);
353 FreeJson(in);
354 FreeJson(out);
355 DestroyDeviceAuthService();
356 }
357
358 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest009, TestSize.Level0)
359 {
360 int32_t ret = InitDeviceAuthService();
361 ASSERT_EQ(ret, HC_SUCCESS);
362
363 TaskBase *task = CreateServerTask();
364 EXPECT_NE(task, nullptr);
365
366 CJson *in = CreateJson();
367 EXPECT_NE(in, nullptr);
368 (void)AddIntToJson(in, FIELD_STEP, CMD_ISO_AUTH_MAIN_ONE);
369 (void)AddStringToJson(in, FIELD_USER_ID, TEST_USER_ID.c_str());
370 (void)AddStringToJson(in, FIELD_SEED, TEST_SEED.c_str());
371 (void)AddStringToJson(in, FIELD_SALT, TEST_SALT.c_str());
372 CJson *out = CreateJson();
373 EXPECT_NE(out, nullptr);
374 int32_t status = 0;
375 ret = task->process(task, in, out, &status);
376 EXPECT_EQ(ret, HC_ERR_JSON_GET);
377
378 task->destroyTask(task);
379 FreeJson(in);
380 FreeJson(out);
381 DestroyDeviceAuthService();
382 }
383
384 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest010, TestSize.Level0)
385 {
386 int32_t ret = InitDeviceAuthService();
387 ASSERT_EQ(ret, HC_SUCCESS);
388
389 TaskBase *task = CreateServerTask();
390 EXPECT_NE(task, nullptr);
391
392 CJson *in = CreateJson();
393 EXPECT_NE(in, nullptr);
394 (void)AddIntToJson(in, FIELD_STEP, CMD_ISO_AUTH_MAIN_ONE);
395 CJson *out = CreateJson();
396 EXPECT_NE(out, nullptr);
397 int32_t status = 0;
398 task->taskStatus = INVALID_TASK_STATUS;
399 ret = task->process(task, in, out, &status);
400 EXPECT_EQ(ret, HC_ERR_BAD_MESSAGE);
401
402 task->destroyTask(task);
403 FreeJson(in);
404 FreeJson(out);
405 DestroyDeviceAuthService();
406 }
407
408 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest011, TestSize.Level0)
409 {
410 int32_t ret = InitDeviceAuthService();
411 ASSERT_EQ(ret, HC_SUCCESS);
412
413 TaskBase *task = CreateServerTask();
414 EXPECT_NE(task, nullptr);
415
416 CJson *in = CreateJson();
417 EXPECT_NE(in, nullptr);
418 (void)AddIntToJson(in, FIELD_STEP, CMD_ISO_AUTH_MAIN_ONE);
419 CJson *out = CreateJson();
420 EXPECT_NE(out, nullptr);
421 int32_t status = 0;
422 task->taskStatus = TASK_STATUS_SERVER_GEN_SESSION_KEY;
423 ret = task->process(task, in, out, &status);
424 EXPECT_EQ(ret, HC_SUCCESS);
425
426 task->destroyTask(task);
427 FreeJson(in);
428 FreeJson(out);
429 DestroyDeviceAuthService();
430 }
431
432 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest012, TestSize.Level0)
433 {
434 int32_t ret = InitDeviceAuthService();
435 ASSERT_EQ(ret, HC_SUCCESS);
436
437 TaskBase *task = CreateServerTask();
438 EXPECT_NE(task, nullptr);
439
440 CJson *in = CreateJson();
441 EXPECT_NE(in, nullptr);
442 (void)AddIntToJson(in, FIELD_STEP, CMD_ISO_AUTH_MAIN_TWO);
443 CJson *out = CreateJson();
444 EXPECT_NE(out, nullptr);
445 int32_t status = 0;
446 task->taskStatus = TASK_STATUS_SERVER_BEGIN_TOKEN;
447 ret = task->process(task, in, out, &status);
448 EXPECT_EQ(ret, HC_ERR_BAD_MESSAGE);
449
450 task->destroyTask(task);
451 FreeJson(in);
452 FreeJson(out);
453 DestroyDeviceAuthService();
454 }
455
456 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest013, TestSize.Level0)
457 {
458 int32_t ret = InitDeviceAuthService();
459 ASSERT_EQ(ret, HC_SUCCESS);
460
461 TaskBase *task = CreateServerTask();
462 EXPECT_NE(task, nullptr);
463
464 CJson *in = CreateJson();
465 EXPECT_NE(in, nullptr);
466 (void)AddIntToJson(in, FIELD_STEP, CMD_ISO_AUTH_MAIN_TWO);
467 CJson *out = CreateJson();
468 EXPECT_NE(out, nullptr);
469 int32_t status = 0;
470 task->taskStatus = TASK_STATUS_SERVER_END;
471 ret = task->process(task, in, out, &status);
472 EXPECT_EQ(ret, HC_SUCCESS);
473
474 task->destroyTask(task);
475 FreeJson(in);
476 FreeJson(out);
477 DestroyDeviceAuthService();
478 }
479
480 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest014, TestSize.Level0)
481 {
482 int32_t ret = InitDeviceAuthService();
483 ASSERT_EQ(ret, HC_SUCCESS);
484
485 TaskBase *task = CreateServerTask();
486 EXPECT_NE(task, nullptr);
487
488 CJson *in = CreateJson();
489 EXPECT_NE(in, nullptr);
490 (void)AddIntToJson(in, FIELD_STEP, CMD_ISO_AUTH_MAIN_TWO);
491 CJson *out = CreateJson();
492 EXPECT_NE(out, nullptr);
493 int32_t status = 0;
494 task->taskStatus = TASK_STATUS_SERVER_GEN_SESSION_KEY;
495 ret = task->process(task, in, out, &status);
496 EXPECT_EQ(ret, HC_ERR_JSON_GET);
497
498 task->destroyTask(task);
499 FreeJson(in);
500 FreeJson(out);
501 DestroyDeviceAuthService();
502 }
503
504 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest015, TestSize.Level0)
505 {
506 int32_t ret = InitDeviceAuthService();
507 ASSERT_EQ(ret, HC_SUCCESS);
508
509 TaskBase *task = CreateServerTask();
510 EXPECT_NE(task, nullptr);
511
512 CJson *in = CreateJson();
513 EXPECT_NE(in, nullptr);
514 (void)AddIntToJson(in, FIELD_STEP, CMD_ISO_AUTH_MAIN_TWO);
515 (void)AddStringToJson(in, FIELD_TOKEN, TEST_AUTH_CODE.c_str());
516 CJson *out = CreateJson();
517 EXPECT_NE(out, nullptr);
518 int32_t status = 0;
519 task->taskStatus = TASK_STATUS_SERVER_GEN_SESSION_KEY;
520 ret = task->process(task, in, out, &status);
521 EXPECT_NE(ret, HC_SUCCESS);
522
523 task->destroyTask(task);
524 FreeJson(in);
525 FreeJson(out);
526 DestroyDeviceAuthService();
527 }
528
529 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest016, TestSize.Level0)
530 {
531 int32_t ret = InitDeviceAuthService();
532 ASSERT_EQ(ret, HC_SUCCESS);
533
534 TaskBase *task = CreateServerTask();
535 EXPECT_NE(task, nullptr);
536
537 int32_t status = 0;
538 ret = task->process(task, nullptr, nullptr, &status);
539 EXPECT_EQ(ret, HC_ERR_JSON_GET);
540
541 task->destroyTask(task);
542 DestroyDeviceAuthService();
543 }
544
545 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest017, TestSize.Level0)
546 {
547 int32_t ret = InitDeviceAuthService();
548 ASSERT_EQ(ret, HC_SUCCESS);
549
550 CJson *outJson = CreateJson();
551 ASSERT_NE(outJson, nullptr);
552 AccountVersionInfo info = { AUTH_PAKE_V2_EC_P256, PAKE_V2, PAKE_ALG_EC, CURVE_256, false, nullptr, nullptr};
553 TaskBase *task = CreateIsoAuthClientTask(nullptr, outJson, &info);
554 EXPECT_EQ(task, nullptr);
555
556 CJson *inJson = CreateJson();
557 ASSERT_NE(inJson, nullptr);
558 task = CreateIsoAuthClientTask(inJson, nullptr, &info);
559 EXPECT_EQ(task, nullptr);
560
561 task = CreateIsoAuthClientTask(inJson, outJson, nullptr);
562 EXPECT_EQ(task, nullptr);
563
564 task = CreateIsoAuthClientTask(inJson, outJson, &info);
565 EXPECT_EQ(task, nullptr);
566
567 FreeJson(inJson);
568 FreeJson(outJson);
569 DestroyDeviceAuthService();
570 }
571
CreateClientTask(void)572 static TaskBase *CreateClientTask(void)
573 {
574 CJson *inJson = CreateJson();
575 if (inJson == nullptr) {
576 return nullptr;
577 }
578 CJson *outJson = CreateJson();
579 if (outJson == nullptr) {
580 FreeJson(inJson);
581 return nullptr;
582 }
583 (void)AddIntToJson(inJson, FIELD_AUTH_FORM, AUTH_FORM_IDENTICAL_ACCOUNT);
584 (void)AddIntToJson(inJson, FIELD_CREDENTIAL_TYPE, SYMMETRIC_CRED);
585 (void)AddIntToJson(inJson, FIELD_LOCAL_DEVICE_TYPE, DEVICE_TYPE_CONTROLLER);
586 (void)AddStringToJson(inJson, FIELD_SELF_USER_ID, TEST_USER_ID.c_str());
587 (void)AddStringToJson(inJson, FIELD_SELF_DEV_ID, TEST_UDID.c_str());
588 (void)AddStringToJson(inJson, FIELD_SELF_DEVICE_ID, TEST_AUTH_ID.c_str());
589 AccountVersionInfo info = { AUTH_PAKE_V2_EC_P256, PAKE_V2, PAKE_ALG_EC, CURVE_256, false, nullptr, nullptr};
590 TaskBase *task = CreateIsoAuthClientTask(inJson, outJson, &info);
591 FreeJson(inJson);
592 FreeJson(outJson);
593 return task;
594 }
595
596 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest018, TestSize.Level0)
597 {
598 int32_t ret = InitDeviceAuthService();
599 ASSERT_EQ(ret, HC_SUCCESS);
600
601 TaskBase *task = CreateClientTask();
602 EXPECT_NE(task, nullptr);
603
604 (void)task->getTaskType();
605
606 CJson *out = CreateJson();
607 EXPECT_NE(out, nullptr);
608 int32_t status = 0;
609 IsoAuthClientTask *innerTask = reinterpret_cast<IsoAuthClientTask *>(task);
610 HcFree(innerTask->params.isoBaseParams.authIdSelf.val);
611 innerTask->params.isoBaseParams.authIdSelf.val = nullptr;
612 ret = task->process(task, nullptr, out, &status);
613 EXPECT_EQ(ret, HC_ERR_JSON_ADD);
614
615 task->destroyTask(task);
616 FreeJson(out);
617 DestroyDeviceAuthService();
618 }
619
620 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest019, TestSize.Level0)
621 {
622 int32_t ret = InitDeviceAuthService();
623 ASSERT_EQ(ret, HC_SUCCESS);
624
625 TaskBase *task = CreateClientTask();
626 EXPECT_NE(task, nullptr);
627
628 CJson *out = CreateJson();
629 EXPECT_NE(out, nullptr);
630 int32_t status = 0;
631 IsoAuthClientTask *innerTask = reinterpret_cast<IsoAuthClientTask *>(task);
632 HcFree(innerTask->params.userIdSelf);
633 innerTask->params.userIdSelf = nullptr;
634 ret = task->process(task, nullptr, out, &status);
635 EXPECT_EQ(ret, HC_ERR_JSON_ADD);
636
637 task->destroyTask(task);
638 FreeJson(out);
639 DestroyDeviceAuthService();
640 }
641
642 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest020, TestSize.Level0)
643 {
644 int32_t ret = InitDeviceAuthService();
645 ASSERT_EQ(ret, HC_SUCCESS);
646
647 TaskBase *task = CreateClientTask();
648 EXPECT_NE(task, nullptr);
649
650 CJson *out = CreateJson();
651 EXPECT_NE(out, nullptr);
652 int32_t status = 0;
653 IsoAuthClientTask *innerTask = reinterpret_cast<IsoAuthClientTask *>(task);
654 HcFree(innerTask->params.devIdSelf.val);
655 innerTask->params.devIdSelf.val = nullptr;
656 ret = task->process(task, nullptr, out, &status);
657 EXPECT_EQ(ret, HC_ERR_JSON_ADD);
658
659 task->destroyTask(task);
660 FreeJson(out);
661 DestroyDeviceAuthService();
662 }
663
664 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest021, TestSize.Level0)
665 {
666 int32_t ret = InitDeviceAuthService();
667 ASSERT_EQ(ret, HC_SUCCESS);
668
669 TaskBase *task = CreateClientTask();
670 EXPECT_NE(task, nullptr);
671
672 CJson *out = CreateJson();
673 EXPECT_NE(out, nullptr);
674 int32_t status = 0;
675 IsoAuthClientTask *innerTask = reinterpret_cast<IsoAuthClientTask *>(task);
676 HcFree(innerTask->params.deviceIdSelf);
677 innerTask->params.deviceIdSelf = nullptr;
678 ret = task->process(task, nullptr, out, &status);
679 EXPECT_EQ(ret, HC_ERR_JSON_ADD);
680
681 task->destroyTask(task);
682 FreeJson(out);
683 DestroyDeviceAuthService();
684 }
685
686 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest022, TestSize.Level0)
687 {
688 int32_t ret = InitDeviceAuthService();
689 ASSERT_EQ(ret, HC_SUCCESS);
690
691 TaskBase *task = CreateClientTask();
692 EXPECT_NE(task, nullptr);
693
694 int32_t status = 0;
695 ret = task->process(task, nullptr, nullptr, &status);
696 EXPECT_EQ(ret, HC_ERR_JSON_ADD);
697
698 task->destroyTask(task);
699 DestroyDeviceAuthService();
700 }
701
702 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest023, TestSize.Level0)
703 {
704 int32_t ret = InitDeviceAuthService();
705 ASSERT_EQ(ret, HC_SUCCESS);
706
707 TaskBase *task = CreateClientTask();
708 EXPECT_NE(task, nullptr);
709
710 CJson *in = CreateJson();
711 EXPECT_NE(in, nullptr);
712 (void)AddIntToJson(in, FIELD_STEP, RET_ISO_AUTH_FOLLOWER_ONE);
713 CJson *out = CreateJson();
714 EXPECT_NE(out, nullptr);
715 task->taskStatus = TASK_STATUS_ISO_MAIN_STEP_ONE;
716 int32_t status = 0;
717 ret = task->process(task, in, out, &status);
718 EXPECT_EQ(ret, HC_ERR_JSON_GET);
719
720 task->destroyTask(task);
721 FreeJson(in);
722 FreeJson(out);
723 DestroyDeviceAuthService();
724 }
725
726 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest024, TestSize.Level0)
727 {
728 int32_t ret = InitDeviceAuthService();
729 ASSERT_EQ(ret, HC_SUCCESS);
730
731 TaskBase *task = CreateClientTask();
732 EXPECT_NE(task, nullptr);
733
734 CJson *in = CreateJson();
735 EXPECT_NE(in, nullptr);
736 (void)AddIntToJson(in, FIELD_STEP, RET_ISO_AUTH_FOLLOWER_ONE);
737 (void)AddStringToJson(in, FIELD_USER_ID, TEST_USER_ID.c_str());
738 CJson *out = CreateJson();
739 EXPECT_NE(out, nullptr);
740 task->taskStatus = TASK_STATUS_ISO_MAIN_STEP_ONE;
741 IsoAuthClientTask *innerTask = reinterpret_cast<IsoAuthClientTask *>(task);
742 HcFree(innerTask->params.userIdPeer);
743 innerTask->params.userIdPeer = nullptr;
744 int32_t status = 0;
745 ret = task->process(task, in, out, &status);
746 EXPECT_EQ(ret, HC_ERR_MEMORY_COPY);
747
748 task->destroyTask(task);
749 FreeJson(in);
750 FreeJson(out);
751 DestroyDeviceAuthService();
752 }
753
754 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest025, TestSize.Level0)
755 {
756 int32_t ret = InitDeviceAuthService();
757 ASSERT_EQ(ret, HC_SUCCESS);
758
759 TaskBase *task = CreateClientTask();
760 EXPECT_NE(task, nullptr);
761
762 CJson *in = CreateJson();
763 EXPECT_NE(in, nullptr);
764 (void)AddIntToJson(in, FIELD_STEP, RET_ISO_AUTH_FOLLOWER_ONE);
765 (void)AddStringToJson(in, FIELD_USER_ID, TEST_USER_ID.c_str());
766 (void)AddStringToJson(in, FIELD_SALT, TEST_SALT.c_str());
767 CJson *out = CreateJson();
768 EXPECT_NE(out, nullptr);
769 task->taskStatus = TASK_STATUS_ISO_MAIN_STEP_ONE;
770 int32_t status = 0;
771 ret = task->process(task, in, out, &status);
772 EXPECT_EQ(ret, HC_ERR_JSON_GET);
773
774 task->destroyTask(task);
775 FreeJson(in);
776 FreeJson(out);
777 DestroyDeviceAuthService();
778 }
779
780 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest026, TestSize.Level0)
781 {
782 int32_t ret = InitDeviceAuthService();
783 ASSERT_EQ(ret, HC_SUCCESS);
784
785 TaskBase *task = CreateClientTask();
786 EXPECT_NE(task, nullptr);
787
788 CJson *in = CreateJson();
789 EXPECT_NE(in, nullptr);
790 (void)AddIntToJson(in, FIELD_STEP, RET_ISO_AUTH_FOLLOWER_ONE);
791 (void)AddStringToJson(in, FIELD_USER_ID, TEST_USER_ID.c_str());
792 (void)AddStringToJson(in, FIELD_SALT, TEST_SALT.c_str());
793 (void)AddStringToJson(in, FIELD_TOKEN, TEST_AUTH_CODE.c_str());
794 CJson *out = CreateJson();
795 EXPECT_NE(out, nullptr);
796 task->taskStatus = TASK_STATUS_ISO_MAIN_STEP_ONE;
797 int32_t status = 0;
798 ret = task->process(task, in, out, &status);
799 EXPECT_EQ(ret, HC_ERR_JSON_GET);
800
801 task->destroyTask(task);
802 FreeJson(in);
803 FreeJson(out);
804 DestroyDeviceAuthService();
805 }
806
807 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest027, TestSize.Level0)
808 {
809 int32_t ret = InitDeviceAuthService();
810 ASSERT_EQ(ret, HC_SUCCESS);
811
812 TaskBase *task = CreateClientTask();
813 EXPECT_NE(task, nullptr);
814
815 CJson *in = CreateJson();
816 EXPECT_NE(in, nullptr);
817 (void)AddIntToJson(in, FIELD_STEP, RET_ISO_AUTH_FOLLOWER_ONE);
818 (void)AddStringToJson(in, FIELD_USER_ID, TEST_USER_ID.c_str());
819 (void)AddStringToJson(in, FIELD_SALT, TEST_SALT.c_str());
820 (void)AddStringToJson(in, FIELD_TOKEN, TEST_AUTH_CODE.c_str());
821 (void)AddStringToJson(in, FIELD_PAYLOAD, TEST_PAYLOAD.c_str());
822 CJson *out = CreateJson();
823 EXPECT_NE(out, nullptr);
824 task->taskStatus = TASK_STATUS_ISO_MAIN_STEP_ONE;
825 int32_t status = 0;
826 ret = task->process(task, in, out, &status);
827 EXPECT_EQ(ret, HC_ERR_JSON_GET);
828
829 task->destroyTask(task);
830 FreeJson(in);
831 FreeJson(out);
832 DestroyDeviceAuthService();
833 }
834
835 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest028, TestSize.Level0)
836 {
837 int32_t ret = InitDeviceAuthService();
838 ASSERT_EQ(ret, HC_SUCCESS);
839
840 TaskBase *task = CreateClientTask();
841 EXPECT_NE(task, nullptr);
842
843 CJson *in = CreateJson();
844 EXPECT_NE(in, nullptr);
845 (void)AddIntToJson(in, FIELD_STEP, RET_ISO_AUTH_FOLLOWER_ONE);
846 (void)AddStringToJson(in, FIELD_USER_ID, TEST_USER_ID.c_str());
847 (void)AddStringToJson(in, FIELD_SALT, TEST_SALT.c_str());
848 (void)AddStringToJson(in, FIELD_TOKEN, TEST_AUTH_CODE.c_str());
849 (void)AddStringToJson(in, FIELD_PAYLOAD, "");
850 CJson *out = CreateJson();
851 EXPECT_NE(out, nullptr);
852 task->taskStatus = TASK_STATUS_ISO_MAIN_STEP_ONE;
853 int32_t status = 0;
854 ret = task->process(task, in, out, &status);
855 EXPECT_EQ(ret, HC_ERR_ALLOC_MEMORY);
856
857 task->destroyTask(task);
858 FreeJson(in);
859 FreeJson(out);
860 DestroyDeviceAuthService();
861 }
862
863 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest029, TestSize.Level0)
864 {
865 int32_t ret = InitDeviceAuthService();
866 ASSERT_EQ(ret, HC_SUCCESS);
867
868 TaskBase *task = CreateClientTask();
869 EXPECT_NE(task, nullptr);
870
871 CJson *in = CreateJson();
872 EXPECT_NE(in, nullptr);
873 (void)AddIntToJson(in, FIELD_STEP, RET_ISO_AUTH_FOLLOWER_ONE);
874 (void)AddStringToJson(in, FIELD_USER_ID, TEST_USER_ID.c_str());
875 (void)AddStringToJson(in, FIELD_SALT, TEST_SALT.c_str());
876 (void)AddStringToJson(in, FIELD_TOKEN, TEST_AUTH_CODE.c_str());
877 (void)AddStringToJson(in, FIELD_PAYLOAD, TEST_PAYLOAD.c_str());
878 // GetPayloadValue convert hex string to byte failed
879 (void)AddStringToJson(in, FIELD_DEV_ID, TEST_UDID.c_str());
880 CJson *out = CreateJson();
881 EXPECT_NE(out, nullptr);
882 task->taskStatus = TASK_STATUS_ISO_MAIN_STEP_ONE;
883 int32_t status = 0;
884 ret = task->process(task, in, out, &status);
885 EXPECT_EQ(ret, HC_ERR_CONVERT_FAILED);
886
887 task->destroyTask(task);
888 FreeJson(in);
889 FreeJson(out);
890 DestroyDeviceAuthService();
891 }
892
893 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest030, TestSize.Level0)
894 {
895 int32_t ret = InitDeviceAuthService();
896 ASSERT_EQ(ret, HC_SUCCESS);
897
898 TaskBase *task = CreateClientTask();
899 EXPECT_NE(task, nullptr);
900
901 CJson *in = CreateJson();
902 EXPECT_NE(in, nullptr);
903 (void)AddIntToJson(in, FIELD_STEP, RET_ISO_AUTH_FOLLOWER_ONE);
904 (void)AddStringToJson(in, FIELD_USER_ID, TEST_USER_ID.c_str());
905 (void)AddStringToJson(in, FIELD_SALT, TEST_SALT.c_str());
906 (void)AddStringToJson(in, FIELD_TOKEN, TEST_AUTH_CODE.c_str());
907 (void)AddStringToJson(in, FIELD_PAYLOAD, TEST_PAYLOAD.c_str());
908 (void)AddStringToJson(in, FIELD_DEV_ID, TEST_DEV_ID.c_str());
909 CJson *out = CreateJson();
910 EXPECT_NE(out, nullptr);
911 task->taskStatus = TASK_STATUS_ISO_MAIN_STEP_ONE;
912 int32_t status = 0;
913 ret = task->process(task, in, out, &status);
914 EXPECT_EQ(ret, HC_ERR_JSON_GET);
915
916 task->destroyTask(task);
917 FreeJson(in);
918 FreeJson(out);
919 DestroyDeviceAuthService();
920 }
921
922 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest031, TestSize.Level0)
923 {
924 int32_t ret = InitDeviceAuthService();
925 ASSERT_EQ(ret, HC_SUCCESS);
926
927 TaskBase *task = CreateClientTask();
928 EXPECT_NE(task, nullptr);
929
930 CJson *in = CreateJson();
931 EXPECT_NE(in, nullptr);
932 (void)AddIntToJson(in, FIELD_STEP, RET_ISO_AUTH_FOLLOWER_ONE);
933 (void)AddStringToJson(in, FIELD_USER_ID, TEST_USER_ID.c_str());
934 (void)AddStringToJson(in, FIELD_SALT, TEST_SALT.c_str());
935 (void)AddStringToJson(in, FIELD_TOKEN, TEST_AUTH_CODE.c_str());
936 (void)AddStringToJson(in, FIELD_PAYLOAD, TEST_PAYLOAD.c_str());
937 (void)AddStringToJson(in, FIELD_DEV_ID, TEST_DEV_ID.c_str());
938 (void)AddStringToJson(in, FIELD_DEVICE_ID, TEST_AUTH_ID.c_str());
939 CJson *out = CreateJson();
940 EXPECT_NE(out, nullptr);
941 task->taskStatus = TASK_STATUS_ISO_MAIN_STEP_ONE;
942 int32_t status = 0;
943 ret = task->process(task, in, out, &status);
944 EXPECT_EQ(ret, HC_ERR_MEMORY_COMPARE);
945
946 task->destroyTask(task);
947 FreeJson(in);
948 FreeJson(out);
949 DestroyDeviceAuthService();
950 }
951
952 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest032, TestSize.Level0)
953 {
954 int32_t ret = InitDeviceAuthService();
955 ASSERT_EQ(ret, HC_SUCCESS);
956
957 TaskBase *task = CreateClientTask();
958 EXPECT_NE(task, nullptr);
959
960 CJson *in = CreateJson();
961 EXPECT_NE(in, nullptr);
962 (void)AddIntToJson(in, FIELD_STEP, RET_ISO_AUTH_FOLLOWER_ONE);
963 CJson *out = CreateJson();
964 EXPECT_NE(out, nullptr);
965 task->taskStatus = INVALID_TASK_STATUS;
966 int32_t status = 0;
967 ret = task->process(task, in, out, &status);
968 EXPECT_EQ(ret, HC_ERR_BAD_MESSAGE);
969
970 task->destroyTask(task);
971 FreeJson(in);
972 FreeJson(out);
973 DestroyDeviceAuthService();
974 }
975
976 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest033, TestSize.Level0)
977 {
978 int32_t ret = InitDeviceAuthService();
979 ASSERT_EQ(ret, HC_SUCCESS);
980
981 TaskBase *task = CreateClientTask();
982 EXPECT_NE(task, nullptr);
983
984 CJson *in = CreateJson();
985 EXPECT_NE(in, nullptr);
986 (void)AddIntToJson(in, FIELD_STEP, RET_ISO_AUTH_FOLLOWER_ONE);
987 CJson *out = CreateJson();
988 EXPECT_NE(out, nullptr);
989 task->taskStatus = TASK_STATUS_ISO_MAIN_STEP_TWO;
990 int32_t status = 0;
991 ret = task->process(task, in, out, &status);
992 EXPECT_EQ(ret, HC_SUCCESS);
993
994 task->destroyTask(task);
995 FreeJson(in);
996 FreeJson(out);
997 DestroyDeviceAuthService();
998 }
999
1000 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest034, TestSize.Level0)
1001 {
1002 int32_t ret = InitDeviceAuthService();
1003 ASSERT_EQ(ret, HC_SUCCESS);
1004
1005 TaskBase *task = CreateClientTask();
1006 EXPECT_NE(task, nullptr);
1007
1008 CJson *in = CreateJson();
1009 EXPECT_NE(in, nullptr);
1010 (void)AddIntToJson(in, FIELD_STEP, RET_ISO_AUTH_FOLLOWER_TWO);
1011 CJson *out = CreateJson();
1012 EXPECT_NE(out, nullptr);
1013 task->taskStatus = TASK_STATUS_ISO_MAIN_STEP_ONE;
1014 int32_t status = 0;
1015 ret = task->process(task, in, out, &status);
1016 EXPECT_EQ(ret, HC_ERR_BAD_MESSAGE);
1017
1018 task->destroyTask(task);
1019 FreeJson(in);
1020 FreeJson(out);
1021 DestroyDeviceAuthService();
1022 }
1023
1024 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest035, TestSize.Level0)
1025 {
1026 int32_t ret = InitDeviceAuthService();
1027 ASSERT_EQ(ret, HC_SUCCESS);
1028
1029 TaskBase *task = CreateClientTask();
1030 EXPECT_NE(task, nullptr);
1031
1032 CJson *in = CreateJson();
1033 EXPECT_NE(in, nullptr);
1034 (void)AddIntToJson(in, FIELD_STEP, RET_ISO_AUTH_FOLLOWER_TWO);
1035 CJson *out = CreateJson();
1036 EXPECT_NE(out, nullptr);
1037 task->taskStatus = TASK_STATUS_ISO_MAIN_END;
1038 int32_t status = 0;
1039 ret = task->process(task, in, out, &status);
1040 EXPECT_EQ(ret, HC_SUCCESS);
1041
1042 task->destroyTask(task);
1043 FreeJson(in);
1044 FreeJson(out);
1045 DestroyDeviceAuthService();
1046 }
1047
1048 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest036, TestSize.Level0)
1049 {
1050 int32_t ret = InitDeviceAuthService();
1051 ASSERT_EQ(ret, HC_SUCCESS);
1052
1053 TaskBase *task = CreateClientTask();
1054 EXPECT_NE(task, nullptr);
1055
1056 CJson *in = CreateJson();
1057 EXPECT_NE(in, nullptr);
1058 (void)AddIntToJson(in, FIELD_STEP, RET_ISO_AUTH_FOLLOWER_TWO);
1059 CJson *out = CreateJson();
1060 EXPECT_NE(out, nullptr);
1061 task->taskStatus = TASK_STATUS_ISO_MAIN_STEP_TWO;
1062 int32_t status = 0;
1063 ret = task->process(task, in, out, &status);
1064 EXPECT_EQ(ret, HC_ERR_JSON_GET);
1065
1066 task->destroyTask(task);
1067 FreeJson(in);
1068 FreeJson(out);
1069 DestroyDeviceAuthService();
1070 }
1071
1072 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest037, TestSize.Level0)
1073 {
1074 int32_t ret = InitDeviceAuthService();
1075 ASSERT_EQ(ret, HC_SUCCESS);
1076
1077 TaskBase *task = CreateClientTask();
1078 EXPECT_NE(task, nullptr);
1079
1080 CJson *in = CreateJson();
1081 EXPECT_NE(in, nullptr);
1082 (void)AddIntToJson(in, FIELD_STEP, RET_ISO_AUTH_FOLLOWER_TWO);
1083 (void)AddStringToJson(in, FIELD_AUTH_RESULT_MAC, TEST_AUTH_RESULT_MAC.c_str());
1084 CJson *out = CreateJson();
1085 EXPECT_NE(out, nullptr);
1086 task->taskStatus = TASK_STATUS_ISO_MAIN_STEP_TWO;
1087 int32_t status = 0;
1088 ret = task->process(task, in, out, &status);
1089 EXPECT_NE(ret, HC_SUCCESS);
1090
1091 task->destroyTask(task);
1092 FreeJson(in);
1093 FreeJson(out);
1094 DestroyDeviceAuthService();
1095 }
1096
1097 HWTEST_F(IsoAuthTaskTest, IsoAuthTaskTest038, TestSize.Level0)
1098 {
1099 int32_t ret = InitDeviceAuthService();
1100 ASSERT_EQ(ret, HC_SUCCESS);
1101
1102 TaskBase *task = CreateClientTask();
1103 EXPECT_NE(task, nullptr);
1104
1105 task->taskStatus = TASK_STATUS_ISO_MAIN_STEP_ONE;
1106 int32_t status = 0;
1107 ret = task->process(task, nullptr, nullptr, &status);
1108 EXPECT_EQ(ret, HC_ERR_JSON_GET);
1109
1110 task->destroyTask(task);
1111 DestroyDeviceAuthService();
1112 }
1113 }