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 "huks_access_test.h"
17
18 #include <gtest/gtest.h>
19
20 #include "file_ex.h"
21 #include "huks_access.h"
22 #include "huks_core_hal_mock.h"
23
24 #include "hks_log.h"
25
26 using namespace testing::ext;
27 namespace Unittest::HuksAccessTest {
28 class HuksAccessTest : public testing::Test {
29 public:
30 static void SetUpTestCase(void);
31
32 static void TearDownTestCase(void);
33
34 void SetUp();
35
36 void TearDown();
37 };
38
SetUpTestCase(void)39 void HuksAccessTest::SetUpTestCase(void)
40 {
41 }
42
TearDownTestCase(void)43 void HuksAccessTest::TearDownTestCase(void)
44 {
45 }
46
SetUp()47 void HuksAccessTest::SetUp()
48 {
49 }
50
TearDown()51 void HuksAccessTest::TearDown()
52 {
53 }
54
55 /**
56 * @tc.name: HuksAccessTest.HuksAccessTest001
57 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
58 * @tc.type: FUNC
59 */
60 HWTEST_F(HuksAccessTest, HuksAccessTest001, TestSize.Level0)
61 {
62 HksEnableCreateOrDestroy(false);
63 HksEnableSetHid(false);
64 int32_t ret = HuksAccessModuleInit();
65 EXPECT_NE(ret, HKS_SUCCESS);
66 }
67
68 /**
69 * @tc.name: HuksAccessTest.HuksAccessTest002
70 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
71 * @tc.type: FUNC
72 */
73 HWTEST_F(HuksAccessTest, HuksAccessTest002, TestSize.Level0)
74 {
75 HksEnableCreateOrDestroy(true);
76 HksEnableSetHid(false);
77 int32_t ret = HuksAccessModuleInit();
78 EXPECT_NE(ret, HKS_SUCCESS);
79 }
80
81 /**
82 * @tc.name: HuksAccessTest.HuksAccessTest003
83 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
84 * @tc.type: FUNC
85 */
86 HWTEST_F(HuksAccessTest, HuksAccessTest003, TestSize.Level0)
87 {
88 HksEnableCreateOrDestroy(false);
89 HksEnableSetHid(false);
90 int32_t ret = HuksAccessRefresh();
91 EXPECT_NE(ret, HKS_SUCCESS);
92 }
93
94 /**
95 * @tc.name: HuksAccessTest.HuksAccessTest004
96 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
97 * @tc.type: FUNC
98 */
99 HWTEST_F(HuksAccessTest, HuksAccessTest004, TestSize.Level0)
100 {
101 HksEnableCreateOrDestroy(true);
102 HksEnableSetHid(false);
103 int32_t ret = HuksAccessRefresh();
104 EXPECT_NE(ret, HKS_SUCCESS);
105 }
106
107 /**
108 * @tc.name: HuksAccessTest.HuksAccessTest005
109 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
110 * @tc.type: FUNC
111 */
112 HWTEST_F(HuksAccessTest, HuksAccessTest005, TestSize.Level0)
113 {
114 HksEnableCreateOrDestroy(false);
115 HksEnableSetHid(false);
116 int32_t ret = HuksAccessGenerateKey(nullptr, nullptr, nullptr, nullptr);
117 EXPECT_NE(ret, HKS_SUCCESS);
118 }
119
120 /**
121 * @tc.name: HuksAccessTest.HuksAccessTest006
122 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
123 * @tc.type: FUNC
124 */
125 HWTEST_F(HuksAccessTest, HuksAccessTest006, TestSize.Level0)
126 {
127 HksEnableCreateOrDestroy(true);
128 HksEnableSetHid(false);
129 int32_t ret = HuksAccessGenerateKey(nullptr, nullptr, nullptr, nullptr);
130 EXPECT_NE(ret, HKS_SUCCESS);
131 }
132
133 /**
134 * @tc.name: HuksAccessTest.HuksAccessTest007
135 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
136 * @tc.type: FUNC
137 */
138 HWTEST_F(HuksAccessTest, HuksAccessTest007, TestSize.Level0)
139 {
140 HksEnableCreateOrDestroy(false);
141 HksEnableSetHid(false);
142 int32_t ret = HuksAccessImportKey(nullptr, nullptr, nullptr, nullptr);
143 EXPECT_NE(ret, HKS_SUCCESS);
144 }
145
146 /**
147 * @tc.name: HuksAccessTest.HuksAccessTest008
148 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
149 * @tc.type: FUNC
150 */
151 HWTEST_F(HuksAccessTest, HuksAccessTest008, TestSize.Level0)
152 {
153 HksEnableCreateOrDestroy(true);
154 HksEnableSetHid(false);
155 int32_t ret = HuksAccessImportKey(nullptr, nullptr, nullptr, nullptr);
156 EXPECT_NE(ret, HKS_SUCCESS);
157 }
158
159 /**
160 * @tc.name: HuksAccessTest.HuksAccessTest009
161 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
162 * @tc.type: FUNC
163 */
164 HWTEST_F(HuksAccessTest, HuksAccessTest009, TestSize.Level0)
165 {
166 HksEnableCreateOrDestroy(false);
167 HksEnableSetHid(false);
168 int32_t ret = HuksAccessImportWrappedKey(nullptr, nullptr, nullptr, nullptr, nullptr);
169 EXPECT_NE(ret, HKS_SUCCESS);
170 }
171
172 /**
173 * @tc.name: HuksAccessTest.HuksAccessTest010
174 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
175 * @tc.type: FUNC
176 */
177 HWTEST_F(HuksAccessTest, HuksAccessTest010, TestSize.Level0)
178 {
179 HksEnableCreateOrDestroy(true);
180 HksEnableSetHid(false);
181 int32_t ret = HuksAccessImportWrappedKey(nullptr, nullptr, nullptr, nullptr, nullptr);
182 EXPECT_NE(ret, HKS_SUCCESS);
183 }
184
185 /**
186 * @tc.name: HuksAccessTest.HuksAccessTest011
187 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
188 * @tc.type: FUNC
189 */
190 HWTEST_F(HuksAccessTest, HuksAccessTest011, TestSize.Level0)
191 {
192 HksEnableCreateOrDestroy(false);
193 HksEnableSetHid(false);
194 int32_t ret = HuksAccessExportPublicKey(nullptr, nullptr, nullptr);
195 EXPECT_NE(ret, HKS_SUCCESS);
196 }
197
198 /**
199 * @tc.name: HuksAccessTest.HuksAccessTest012
200 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
201 * @tc.type: FUNC
202 */
203 HWTEST_F(HuksAccessTest, HuksAccessTest012, TestSize.Level0)
204 {
205 HksEnableCreateOrDestroy(true);
206 HksEnableSetHid(false);
207 int32_t ret = HuksAccessExportPublicKey(nullptr, nullptr, nullptr);
208 EXPECT_NE(ret, HKS_SUCCESS);
209 }
210
211 /**
212 * @tc.name: HuksAccessTest.HuksAccessTest013
213 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
214 * @tc.type: FUNC
215 */
216 HWTEST_F(HuksAccessTest, HuksAccessTest013, TestSize.Level0)
217 {
218 HksEnableCreateOrDestroy(false);
219 HksEnableSetHid(false);
220 int32_t ret = HuksAccessInit(nullptr, nullptr, nullptr, nullptr);
221 EXPECT_NE(ret, HKS_SUCCESS);
222 }
223
224 /**
225 * @tc.name: HuksAccessTest.HuksAccessTest014
226 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
227 * @tc.type: FUNC
228 */
229 HWTEST_F(HuksAccessTest, HuksAccessTest014, TestSize.Level0)
230 {
231 HksEnableCreateOrDestroy(true);
232 HksEnableSetHid(false);
233 int32_t ret = HuksAccessInit(nullptr, nullptr, nullptr, nullptr);
234 EXPECT_NE(ret, HKS_SUCCESS);
235 }
236
237 /**
238 * @tc.name: HuksAccessTest.HuksAccessTest015
239 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
240 * @tc.type: FUNC
241 */
242 HWTEST_F(HuksAccessTest, HuksAccessTest015, TestSize.Level0)
243 {
244 HksEnableCreateOrDestroy(false);
245 HksEnableSetHid(false);
246 int32_t ret = HuksAccessUpdate(nullptr, nullptr, nullptr, nullptr);
247 EXPECT_NE(ret, HKS_SUCCESS);
248 }
249
250 /**
251 * @tc.name: HuksAccessTest.HuksAccessTest016
252 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
253 * @tc.type: FUNC
254 */
255 HWTEST_F(HuksAccessTest, HuksAccessTest016, TestSize.Level0)
256 {
257 HksEnableCreateOrDestroy(true);
258 HksEnableSetHid(false);
259 int32_t ret = HuksAccessUpdate(nullptr, nullptr, nullptr, nullptr);
260 EXPECT_NE(ret, HKS_SUCCESS);
261 }
262
263 /**
264 * @tc.name: HuksAccessTest.HuksAccessTest017
265 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
266 * @tc.type: FUNC
267 */
268 HWTEST_F(HuksAccessTest, HuksAccessTest017, TestSize.Level0)
269 {
270 HksEnableCreateOrDestroy(false);
271 HksEnableSetHid(false);
272 int32_t ret = HuksAccessFinish(nullptr, nullptr, nullptr, nullptr);
273 EXPECT_NE(ret, HKS_SUCCESS);
274 }
275
276 /**
277 * @tc.name: HuksAccessTest.HuksAccessTest018
278 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
279 * @tc.type: FUNC
280 */
281 HWTEST_F(HuksAccessTest, HuksAccessTest018, TestSize.Level0)
282 {
283 HksEnableCreateOrDestroy(true);
284 HksEnableSetHid(false);
285 int32_t ret = HuksAccessFinish(nullptr, nullptr, nullptr, nullptr);
286 EXPECT_NE(ret, HKS_SUCCESS);
287 }
288
289 /**
290 * @tc.name: HuksAccessTest.HuksAccessTest019
291 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
292 * @tc.type: FUNC
293 */
294 HWTEST_F(HuksAccessTest, HuksAccessTest019, TestSize.Level0)
295 {
296 HksEnableCreateOrDestroy(false);
297 HksEnableSetHid(false);
298 int32_t ret = HuksAccessAbort(nullptr, nullptr);
299 EXPECT_NE(ret, HKS_SUCCESS);
300 }
301
302 /**
303 * @tc.name: HuksAccessTest.HuksAccessTest020
304 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
305 * @tc.type: FUNC
306 */
307 HWTEST_F(HuksAccessTest, HuksAccessTest020, TestSize.Level0)
308 {
309 HksEnableCreateOrDestroy(true);
310 HksEnableSetHid(false);
311 int32_t ret = HuksAccessAbort(nullptr, nullptr);
312 EXPECT_NE(ret, HKS_SUCCESS);
313 }
314
315 /**
316 * @tc.name: HuksAccessTest.HuksAccessTest021
317 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
318 * @tc.type: FUNC
319 */
320 HWTEST_F(HuksAccessTest, HuksAccessTest021, TestSize.Level0)
321 {
322 HksEnableCreateOrDestroy(false);
323 HksEnableSetHid(false);
324 int32_t ret = HuksAccessGetKeyProperties(nullptr, nullptr);
325 EXPECT_NE(ret, HKS_SUCCESS);
326 }
327
328 /**
329 * @tc.name: HuksAccessTest.HuksAccessTest022
330 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
331 * @tc.type: FUNC
332 */
333 HWTEST_F(HuksAccessTest, HuksAccessTest022, TestSize.Level0)
334 {
335 HksEnableCreateOrDestroy(true);
336 HksEnableSetHid(false);
337 int32_t ret = HuksAccessGetKeyProperties(nullptr, nullptr);
338 EXPECT_NE(ret, HKS_SUCCESS);
339 }
340
341 /**
342 * @tc.name: HuksAccessTest.HuksAccessTest023
343 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
344 * @tc.type: FUNC
345 */
346 HWTEST_F(HuksAccessTest, HuksAccessTest023, TestSize.Level0)
347 {
348 HksEnableCreateOrDestroy(false);
349 HksEnableSetHid(false);
350 int32_t ret = HuksAccessGetAbility(0);
351 EXPECT_NE(ret, HKS_SUCCESS);
352 }
353
354 /**
355 * @tc.name: HuksAccessTest.HuksAccessTest024
356 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
357 * @tc.type: FUNC
358 */
359 HWTEST_F(HuksAccessTest, HuksAccessTest024, TestSize.Level0)
360 {
361 HksEnableCreateOrDestroy(true);
362 HksEnableSetHid(false);
363 int32_t ret = HuksAccessGetAbility(0);
364 EXPECT_NE(ret, HKS_SUCCESS);
365 }
366
367 /**
368 * @tc.name: HuksAccessTest.HuksAccessTest025
369 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
370 * @tc.type: FUNC
371 */
372 HWTEST_F(HuksAccessTest, HuksAccessTest025, TestSize.Level0)
373 {
374 HksEnableCreateOrDestroy(false);
375 HksEnableSetHid(false);
376 int32_t ret = HuksAccessGetHardwareInfo();
377 EXPECT_NE(ret, HKS_SUCCESS);
378 }
379
380 /**
381 * @tc.name: HuksAccessTest.HuksAccessTest026
382 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
383 * @tc.type: FUNC
384 */
385 HWTEST_F(HuksAccessTest, HuksAccessTest026, TestSize.Level0)
386 {
387 HksEnableCreateOrDestroy(true);
388 HksEnableSetHid(false);
389 int32_t ret = HuksAccessGetHardwareInfo();
390 EXPECT_NE(ret, HKS_SUCCESS);
391 }
392
393 /**
394 * @tc.name: HuksAccessTest.HuksAccessTest027
395 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
396 * @tc.type: FUNC
397 */
398 HWTEST_F(HuksAccessTest, HuksAccessTest027, TestSize.Level0)
399 {
400 HksEnableCreateOrDestroy(false);
401 HksEnableSetHid(false);
402 int32_t ret = HuksAccessSign(nullptr, nullptr, nullptr, nullptr);
403 EXPECT_NE(ret, HKS_SUCCESS);
404 }
405
406 /**
407 * @tc.name: HuksAccessTest.HuksAccessTest028
408 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
409 * @tc.type: FUNC
410 */
411 HWTEST_F(HuksAccessTest, HuksAccessTest028, TestSize.Level0)
412 {
413 HksEnableCreateOrDestroy(true);
414 HksEnableSetHid(false);
415 int32_t ret = HuksAccessSign(nullptr, nullptr, nullptr, nullptr);
416 EXPECT_NE(ret, HKS_SUCCESS);
417 }
418
419 /**
420 * @tc.name: HuksAccessTest.HuksAccessTest029
421 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
422 * @tc.type: FUNC
423 */
424 HWTEST_F(HuksAccessTest, HuksAccessTest029, TestSize.Level0)
425 {
426 HksEnableCreateOrDestroy(false);
427 HksEnableSetHid(false);
428 int32_t ret = HuksAccessVerify(nullptr, nullptr, nullptr, nullptr);
429 EXPECT_NE(ret, HKS_SUCCESS);
430 }
431
432 /**
433 * @tc.name: HuksAccessTest.HuksAccessTest030
434 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
435 * @tc.type: FUNC
436 */
437 HWTEST_F(HuksAccessTest, HuksAccessTest030, TestSize.Level0)
438 {
439 HksEnableCreateOrDestroy(true);
440 HksEnableSetHid(false);
441 int32_t ret = HuksAccessVerify(nullptr, nullptr, nullptr, nullptr);
442 EXPECT_NE(ret, HKS_SUCCESS);
443 }
444
445 /**
446 * @tc.name: HuksAccessTest.HuksAccessTest031
447 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
448 * @tc.type: FUNC
449 */
450 HWTEST_F(HuksAccessTest, HuksAccessTest031, TestSize.Level0)
451 {
452 HksEnableCreateOrDestroy(false);
453 HksEnableSetHid(false);
454 int32_t ret = HuksAccessEncrypt(nullptr, nullptr, nullptr, nullptr);
455 EXPECT_NE(ret, HKS_SUCCESS);
456 }
457
458 /**
459 * @tc.name: HuksAccessTest.HuksAccessTest032
460 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
461 * @tc.type: FUNC
462 */
463 HWTEST_F(HuksAccessTest, HuksAccessTest032, TestSize.Level0)
464 {
465 HksEnableCreateOrDestroy(true);
466 HksEnableSetHid(false);
467 int32_t ret = HuksAccessEncrypt(nullptr, nullptr, nullptr, nullptr);
468 EXPECT_NE(ret, HKS_SUCCESS);
469 }
470
471 /**
472 * @tc.name: HuksAccessTest.HuksAccessTest033
473 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
474 * @tc.type: FUNC
475 */
476 HWTEST_F(HuksAccessTest, HuksAccessTest033, TestSize.Level0)
477 {
478 HksEnableCreateOrDestroy(false);
479 HksEnableSetHid(false);
480 int32_t ret = HuksAccessDecrypt(nullptr, nullptr, nullptr, nullptr);
481 EXPECT_NE(ret, HKS_SUCCESS);
482 }
483
484 /**
485 * @tc.name: HuksAccessTest.HuksAccessTest034
486 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
487 * @tc.type: FUNC
488 */
489 HWTEST_F(HuksAccessTest, HuksAccessTest034, TestSize.Level0)
490 {
491 HksEnableCreateOrDestroy(true);
492 HksEnableSetHid(false);
493 int32_t ret = HuksAccessDecrypt(nullptr, nullptr, nullptr, nullptr);
494 EXPECT_NE(ret, HKS_SUCCESS);
495 }
496
497 /**
498 * @tc.name: HuksAccessTest.HuksAccessTest035
499 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
500 * @tc.type: FUNC
501 */
502 HWTEST_F(HuksAccessTest, HuksAccessTest035, TestSize.Level0)
503 {
504 HksEnableCreateOrDestroy(false);
505 HksEnableSetHid(false);
506 int32_t ret = HuksAccessAgreeKey(nullptr, nullptr, nullptr, nullptr);
507 EXPECT_NE(ret, HKS_SUCCESS);
508 }
509
510 /**
511 * @tc.name: HuksAccessTest.HuksAccessTest036
512 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
513 * @tc.type: FUNC
514 */
515 HWTEST_F(HuksAccessTest, HuksAccessTest036, TestSize.Level0)
516 {
517 HksEnableCreateOrDestroy(true);
518 HksEnableSetHid(false);
519 int32_t ret = HuksAccessAgreeKey(nullptr, nullptr, nullptr, nullptr);
520 EXPECT_NE(ret, HKS_SUCCESS);
521 }
522
523 /**
524 * @tc.name: HuksAccessTest.HuksAccessTest037
525 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
526 * @tc.type: FUNC
527 */
528 HWTEST_F(HuksAccessTest, HuksAccessTest037, TestSize.Level0)
529 {
530 HksEnableCreateOrDestroy(false);
531 HksEnableSetHid(false);
532 int32_t ret = HuksAccessDeriveKey(nullptr, nullptr, nullptr);
533 EXPECT_NE(ret, HKS_SUCCESS);
534 }
535
536 /**
537 * @tc.name: HuksAccessTest.HuksAccessTest038
538 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
539 * @tc.type: FUNC
540 */
541 HWTEST_F(HuksAccessTest, HuksAccessTest038, TestSize.Level0)
542 {
543 HksEnableCreateOrDestroy(true);
544 HksEnableSetHid(false);
545 int32_t ret = HuksAccessDeriveKey(nullptr, nullptr, nullptr);
546 EXPECT_NE(ret, HKS_SUCCESS);
547 }
548
549 /**
550 * @tc.name: HuksAccessTest.HuksAccessTest039
551 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
552 * @tc.type: FUNC
553 */
554 HWTEST_F(HuksAccessTest, HuksAccessTest039, TestSize.Level0)
555 {
556 HksEnableCreateOrDestroy(false);
557 HksEnableSetHid(false);
558 int32_t ret = HuksAccessMac(nullptr, nullptr, nullptr, nullptr);
559 EXPECT_NE(ret, HKS_SUCCESS);
560 }
561
562 /**
563 * @tc.name: HuksAccessTest.HuksAccessTest040
564 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
565 * @tc.type: FUNC
566 */
567 HWTEST_F(HuksAccessTest, HuksAccessTest040, TestSize.Level0)
568 {
569 HksEnableCreateOrDestroy(true);
570 HksEnableSetHid(false);
571 int32_t ret = HuksAccessMac(nullptr, nullptr, nullptr, nullptr);
572 EXPECT_NE(ret, HKS_SUCCESS);
573 }
574
575 #ifdef _STORAGE_LITE_
576
577 /**
578 * @tc.name: HuksAccessTest.HuksAccessTest041
579 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
580 * @tc.type: FUNC
581 */
582 HWTEST_F(HuksAccessTest, HuksAccessTest041, TestSize.Level0)
583 {
584 HksEnableCreateOrDestroy(false);
585 HksEnableSetHid(false);
586 int32_t ret = HuksAccessCalcHeaderMac(nullptr, nullptr, nullptr, nullptr);
587 EXPECT_NE(ret, HKS_SUCCESS);
588 }
589
590 /**
591 * @tc.name: HuksAccessTest.HuksAccessTest042
592 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
593 * @tc.type: FUNC
594 */
595 HWTEST_F(HuksAccessTest, HuksAccessTest042, TestSize.Level0)
596 {
597 HksEnableCreateOrDestroy(true);
598 HksEnableSetHid(false);
599 int32_t ret = HuksAccessCalcHeaderMac(nullptr, nullptr, nullptr, nullptr);
600 EXPECT_NE(ret, HKS_SUCCESS);
601 }
602
603 #endif
604
605 /**
606 * @tc.name: HuksAccessTest.HuksAccessTest045
607 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
608 * @tc.type: FUNC
609 */
610 HWTEST_F(HuksAccessTest, HuksAccessTest045, TestSize.Level0)
611 {
612 HksEnableCreateOrDestroy(false);
613 HksEnableSetHid(false);
614 int32_t ret = HuksAccessAttestKey(nullptr, nullptr, nullptr);
615 EXPECT_NE(ret, HKS_SUCCESS);
616 }
617
618 /**
619 * @tc.name: HuksAccessTest.HuksAccessTest046
620 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
621 * @tc.type: FUNC
622 */
623 HWTEST_F(HuksAccessTest, HuksAccessTest046, TestSize.Level0)
624 {
625 HksEnableCreateOrDestroy(true);
626 HksEnableSetHid(false);
627 int32_t ret = HuksAccessAttestKey(nullptr, nullptr, nullptr);
628 EXPECT_NE(ret, HKS_SUCCESS);
629 }
630
631 /**
632 * @tc.name: HuksAccessTest.HuksAccessTest047
633 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
634 * @tc.type: FUNC
635 */
636 HWTEST_F(HuksAccessTest, HuksAccessTest047, TestSize.Level0)
637 {
638 HksEnableCreateOrDestroy(false);
639 HksEnableSetHid(false);
640 int32_t ret = HuksAccessGenerateRandom(nullptr, nullptr);
641 EXPECT_NE(ret, HKS_SUCCESS);
642 }
643
644 /**
645 * @tc.name: HuksAccessTest.HuksAccessTest048
646 * @tc.desc: tdd HksCreateHuksHdiDevice, expect HKS_ERROR_NULL_POINTER
647 * @tc.type: FUNC
648 */
649 HWTEST_F(HuksAccessTest, HuksAccessTest048, TestSize.Level0)
650 {
651 HksEnableCreateOrDestroy(true);
652 HksEnableSetHid(false);
653 int32_t ret = HuksAccessGenerateRandom(nullptr, nullptr);
654 EXPECT_NE(ret, HKS_SUCCESS);
655 }
656 }
657