1 /*
2  * Copyright (C) 2023 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 <gtest/gtest.h>
17 #include <string>
18 #include "securec.h"
19 
20 #include "asy_key_generator.h"
21 #include "detailed_ecc_key_params.h"
22 #include "ecc_asy_key_common.h"
23 #include "ecc_asy_key_generator_openssl.h"
24 #include "ecc_openssl_common.h"
25 #include "ecc_openssl_common_param_spec.h"
26 #include "ecc_common.h"
27 #include "blob.h"
28 #include "memory_mock.h"
29 #include "openssl_adapter_mock.h"
30 #include "openssl_class.h"
31 #include "openssl_common.h"
32 #include "params_parser.h"
33 
34 using namespace std;
35 using namespace testing::ext;
36 
37 namespace {
38 class CryptoEccAsyKeyGeneratorBySpecTest : public testing::Test {
39 public:
SetUpTestCase()40     static void SetUpTestCase() {};
TearDownTestCase()41     static void TearDownTestCase() {};
SetUp()42     void SetUp() {};
TearDown()43     void TearDown() {};
44 };
45 
GetMockClass(void)46 static const char *GetMockClass(void)
47 {
48     return "HcfSymKeyGenerator";
49 }
50 
51 HcfObjectBase g_obj = {
52     .getClass = GetMockClass,
53     .destroy = nullptr
54 };
55 
56 /**
57  * @tc.name: CryptoEccAsyKeyGeneratorBySpecTest.CryptoEccAsyKeyGeneratorBySpecTest001
58  * @tc.desc: Verify that the creation of the ECC224 key pair generator is normal.
59  * @tc.type: FUNC
60  * @tc.require: I5QWEI
61  */
62 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest001_1, TestSize.Level0)
63 {
64     HcfAsyKeyParamsSpec *paramSpec = nullptr;
65     int32_t res = ConstructEcc224CommParamsSpec(&paramSpec);
66 
67     ASSERT_EQ(res, HCF_SUCCESS);
68 
69     HcfAsyKeyGeneratorBySpec *generator = nullptr;
70     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
71 
72     ASSERT_EQ(res, HCF_SUCCESS);
73     ASSERT_NE(generator, nullptr);
74 
75     HcfObjDestroy(generator);
76 }
77 
78 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest001_2, TestSize.Level0)
79 {
80     HcfAsyKeyParamsSpec *paramSpec = nullptr;
81     int32_t res = ConstructEcc224PubKeyParamsSpec(&paramSpec);
82 
83     ASSERT_EQ(res, HCF_SUCCESS);
84 
85     HcfAsyKeyGeneratorBySpec *generator = nullptr;
86     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
87 
88     ASSERT_EQ(res, HCF_SUCCESS);
89     ASSERT_NE(generator, nullptr);
90 
91     HcfObjDestroy(generator);
92 }
93 
94 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest001_3, TestSize.Level0)
95 {
96     HcfAsyKeyParamsSpec *paramSpec = nullptr;
97     int32_t res = ConstructEcc224PriKeyParamsSpec(&paramSpec);
98 
99     ASSERT_EQ(res, HCF_SUCCESS);
100 
101     HcfAsyKeyGeneratorBySpec *generator = nullptr;
102     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
103 
104     ASSERT_EQ(res, HCF_SUCCESS);
105     ASSERT_NE(generator, nullptr);
106 
107     HcfObjDestroy(generator);
108 }
109 
110 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest001_4, TestSize.Level0)
111 {
112     HcfAsyKeyParamsSpec *paramSpec = nullptr;
113     int32_t res = ConstructEcc224KeyPairParamsSpec(&paramSpec);
114 
115     ASSERT_EQ(res, HCF_SUCCESS);
116 
117     HcfAsyKeyGeneratorBySpec *generator = nullptr;
118     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
119 
120     ASSERT_EQ(res, HCF_SUCCESS);
121     ASSERT_NE(generator, nullptr);
122 
123     HcfObjDestroy(generator);
124 }
125 
126 /**
127  * @tc.name: CryptoEccAsyKeyGeneratorBySpecTest.CryptoEccAsyKeyGeneratorBySpecTest001
128  * @tc.desc: Verify that the creation of the ECC256 key pair generator is normal.
129  * @tc.type: FUNC
130  * @tc.require: I5QWEI
131  */
132 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest001_5, TestSize.Level0)
133 {
134     HcfAsyKeyParamsSpec *paramSpec = nullptr;
135     int32_t res = ConstructEcc256CommParamsSpec(&paramSpec);
136 
137     ASSERT_EQ(res, HCF_SUCCESS);
138 
139     HcfAsyKeyGeneratorBySpec *generator = nullptr;
140     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
141 
142     ASSERT_EQ(res, HCF_SUCCESS);
143     ASSERT_NE(generator, nullptr);
144 
145     HcfObjDestroy(generator);
146 }
147 
148 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest001_6, TestSize.Level0)
149 {
150     HcfAsyKeyParamsSpec *paramSpec = nullptr;
151     int32_t res = ConstructEcc256PubKeyParamsSpec(&paramSpec);
152 
153     ASSERT_EQ(res, HCF_SUCCESS);
154 
155     HcfAsyKeyGeneratorBySpec *generator = nullptr;
156     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
157 
158     ASSERT_EQ(res, HCF_SUCCESS);
159     ASSERT_NE(generator, nullptr);
160 
161     HcfObjDestroy(generator);
162 }
163 
164 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest001_7, TestSize.Level0)
165 {
166     HcfAsyKeyParamsSpec *paramSpec = nullptr;
167     int32_t res = ConstructEcc256PriKeyParamsSpec(&paramSpec);
168 
169     ASSERT_EQ(res, HCF_SUCCESS);
170 
171     HcfAsyKeyGeneratorBySpec *generator = nullptr;
172     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
173 
174     ASSERT_EQ(res, HCF_SUCCESS);
175     ASSERT_NE(generator, nullptr);
176 
177     HcfObjDestroy(generator);
178 }
179 
180 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest001_8, TestSize.Level0)
181 {
182     HcfAsyKeyParamsSpec *paramSpec = nullptr;
183     int32_t res = ConstructEcc256KeyPairParamsSpec(&paramSpec);
184 
185     ASSERT_EQ(res, HCF_SUCCESS);
186 
187     HcfAsyKeyGeneratorBySpec *generator = nullptr;
188     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
189 
190     ASSERT_EQ(res, HCF_SUCCESS);
191     ASSERT_NE(generator, nullptr);
192 
193     HcfObjDestroy(generator);
194 }
195 
196 /**
197  * @tc.name: CryptoEccAsyKeyGeneratorBySpecTest.CryptoEccAsyKeyGeneratorBySpecTest001
198  * @tc.desc: Verify that the creation of the ECC384 key pair generator is normal.
199  * @tc.type: FUNC
200  * @tc.require: I5QWEI
201  */
202 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest001_9, TestSize.Level0)
203 {
204     HcfAsyKeyParamsSpec *paramSpec = nullptr;
205     int32_t res = ConstructEcc384CommParamsSpec(&paramSpec);
206 
207     ASSERT_EQ(res, HCF_SUCCESS);
208 
209     HcfAsyKeyGeneratorBySpec *generator = nullptr;
210     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
211 
212     ASSERT_EQ(res, HCF_SUCCESS);
213     ASSERT_NE(generator, nullptr);
214 
215     HcfObjDestroy(generator);
216 }
217 
218 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest001_10, TestSize.Level0)
219 {
220     HcfAsyKeyParamsSpec *paramSpec = nullptr;
221     int32_t res = ConstructEcc384PubKeyParamsSpec(&paramSpec);
222 
223     ASSERT_EQ(res, HCF_SUCCESS);
224 
225     HcfAsyKeyGeneratorBySpec *generator = nullptr;
226     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
227 
228     ASSERT_EQ(res, HCF_SUCCESS);
229     ASSERT_NE(generator, nullptr);
230 
231     HcfObjDestroy(generator);
232 }
233 
234 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest001_11, TestSize.Level0)
235 {
236     HcfAsyKeyParamsSpec *paramSpec = nullptr;
237     int32_t res = ConstructEcc384PriKeyParamsSpec(&paramSpec);
238 
239     ASSERT_EQ(res, HCF_SUCCESS);
240 
241     HcfAsyKeyGeneratorBySpec *generator = nullptr;
242     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
243 
244     ASSERT_EQ(res, HCF_SUCCESS);
245     ASSERT_NE(generator, nullptr);
246 
247     HcfObjDestroy(generator);
248 }
249 
250 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest001_12, TestSize.Level0)
251 {
252     HcfAsyKeyParamsSpec *paramSpec = nullptr;
253     int32_t res = ConstructEcc384KeyPairParamsSpec(&paramSpec);
254 
255     ASSERT_EQ(res, HCF_SUCCESS);
256 
257     HcfAsyKeyGeneratorBySpec *generator = nullptr;
258     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
259 
260     ASSERT_EQ(res, HCF_SUCCESS);
261     ASSERT_NE(generator, nullptr);
262 
263     HcfObjDestroy(generator);
264 }
265 
266 /**
267  * @tc.name: CryptoEccAsyKeyGeneratorBySpecTest.CryptoEccAsyKeyGeneratorBySpecTest001
268  * @tc.desc: Verify that the creation of the ECC521 key pair generator is normal.
269  * @tc.type: FUNC
270  * @tc.require: I5QWEI
271  */
272 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest001_13, TestSize.Level0)
273 {
274     HcfAsyKeyParamsSpec *paramSpec = nullptr;
275     int32_t res = ConstructEcc521CommParamsSpec(&paramSpec);
276 
277     ASSERT_EQ(res, HCF_SUCCESS);
278 
279     HcfAsyKeyGeneratorBySpec *generator = nullptr;
280     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
281 
282     ASSERT_EQ(res, HCF_SUCCESS);
283     ASSERT_NE(generator, nullptr);
284 
285     HcfObjDestroy(generator);
286 }
287 
288 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest001_14, TestSize.Level0)
289 {
290     HcfAsyKeyParamsSpec *paramSpec = nullptr;
291     int32_t res = ConstructEcc521PubKeyParamsSpec(&paramSpec);
292 
293     ASSERT_EQ(res, HCF_SUCCESS);
294 
295     HcfAsyKeyGeneratorBySpec *generator = nullptr;
296     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
297 
298     ASSERT_EQ(res, HCF_SUCCESS);
299     ASSERT_NE(generator, nullptr);
300 
301     HcfObjDestroy(generator);
302 }
303 
304 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest001_15, TestSize.Level0)
305 {
306     HcfAsyKeyParamsSpec *paramSpec = nullptr;
307     int32_t res = ConstructEcc521PriKeyParamsSpec(&paramSpec);
308 
309     ASSERT_EQ(res, HCF_SUCCESS);
310 
311     HcfAsyKeyGeneratorBySpec *generator = nullptr;
312     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
313 
314     ASSERT_EQ(res, HCF_SUCCESS);
315     ASSERT_NE(generator, nullptr);
316 
317     HcfObjDestroy(generator);
318 }
319 
320 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest001_16, TestSize.Level0)
321 {
322     HcfAsyKeyParamsSpec *paramSpec = nullptr;
323     int32_t res = ConstructEcc521KeyPairParamsSpec(&paramSpec);
324 
325     ASSERT_EQ(res, HCF_SUCCESS);
326 
327     HcfAsyKeyGeneratorBySpec *generator = nullptr;
328     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
329 
330     ASSERT_EQ(res, HCF_SUCCESS);
331     ASSERT_NE(generator, nullptr);
332 
333     HcfObjDestroy(generator);
334 }
335 
336 // 192 -> 不在4条曲线中的fp曲线
337 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest001_17, TestSize.Level0)
338 {
339     HcfAsyKeyParamsSpec *paramSpec = nullptr;
340     int32_t res = ConstructEcc192CommParamsSpec(&paramSpec);
341 
342     ASSERT_EQ(res, HCF_SUCCESS);
343 
344     HcfAsyKeyGeneratorBySpec *generator = nullptr;
345     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
346 
347     ASSERT_EQ(res, HCF_SUCCESS);
348     ASSERT_NE(generator, nullptr);
349 
350     HcfKeyPair *keyPair = nullptr;
351     res = generator->generateKeyPair(generator, &keyPair);
352 
353     ASSERT_EQ(res, HCF_SUCCESS);
354     ASSERT_NE(keyPair, nullptr);
355 
356     HcfObjDestroy(keyPair);
357 
358     HcfObjDestroy(generator);
359 }
360 
361 // for test:Generator的异常用例
362 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest002, TestSize.Level0)
363 {
364     HcfAsyKeyGeneratorBySpec *generator = nullptr;
365     int32_t res = HcfAsyKeyGeneratorBySpecCreate(nullptr, &generator);
366 
367     ASSERT_EQ(res, HCF_INVALID_PARAMS);
368     ASSERT_EQ(generator, nullptr);
369 }
370 
371 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest003, TestSize.Level0)
372 {
373     HcfAsyKeyParamsSpec *paramSpec = nullptr;
374     int32_t res = ConstructEcc224CommParamsSpec(&paramSpec);
375 
376     ASSERT_EQ(res, HCF_SUCCESS);
377 
378     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, nullptr);
379 
380     ASSERT_EQ(res, HCF_INVALID_PARAMS);
381 }
382 
383 // for test:generator函数指针测试（正常）
384 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest101, TestSize.Level0)
385 {
386     HcfAsyKeyParamsSpec *paramSpec = nullptr;
387     int32_t res = ConstructEcc224CommParamsSpec(&paramSpec);
388 
389     ASSERT_EQ(res, HCF_SUCCESS);
390 
391     HcfAsyKeyGeneratorBySpec *generator = nullptr;
392     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
393 
394     ASSERT_EQ(res, HCF_SUCCESS);
395     ASSERT_NE(generator, nullptr);
396 
397     const char *className = generator->base.getClass();
398     ASSERT_NE(className, nullptr);
399 
400     HcfObjDestroy(generator);
401 }
402 
403 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest102_1, TestSize.Level0)
404 {
405     HcfAsyKeyParamsSpec *paramSpec = nullptr;
406     int32_t res = ConstructEcc224CommParamsSpec(&paramSpec);
407 
408     ASSERT_EQ(res, HCF_SUCCESS);
409 
410     HcfAsyKeyGeneratorBySpec *generator = nullptr;
411     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
412 
413     ASSERT_EQ(res, HCF_SUCCESS);
414     ASSERT_NE(generator, nullptr);
415 
416     generator->base.destroy((HcfObjectBase *)generator);
417 }
418 
419 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest102_2, TestSize.Level0)
420 {
421     HcfAsyKeyParamsSpec *paramSpec = nullptr;
422     int32_t res = ConstructEcc224PubKeyParamsSpec(&paramSpec);
423 
424     ASSERT_EQ(res, HCF_SUCCESS);
425 
426     HcfAsyKeyGeneratorBySpec *generator = nullptr;
427     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
428 
429     ASSERT_EQ(res, HCF_SUCCESS);
430     ASSERT_NE(generator, nullptr);
431 
432     generator->base.destroy((HcfObjectBase *)generator);
433 }
434 
435 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest102_3, TestSize.Level0)
436 {
437     HcfAsyKeyParamsSpec *paramSpec = nullptr;
438     int32_t res = ConstructEcc224PriKeyParamsSpec(&paramSpec);
439 
440     ASSERT_EQ(res, HCF_SUCCESS);
441 
442     HcfAsyKeyGeneratorBySpec *generator = nullptr;
443     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
444 
445     ASSERT_EQ(res, HCF_SUCCESS);
446     ASSERT_NE(generator, nullptr);
447 
448     generator->base.destroy((HcfObjectBase *)generator);
449 }
450 
451 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest102_4, TestSize.Level0)
452 {
453     HcfAsyKeyParamsSpec *paramSpec = nullptr;
454     int32_t res = ConstructEcc224KeyPairParamsSpec(&paramSpec);
455 
456     ASSERT_EQ(res, HCF_SUCCESS);
457 
458     HcfAsyKeyGeneratorBySpec *generator = nullptr;
459     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
460 
461     ASSERT_EQ(res, HCF_SUCCESS);
462     ASSERT_NE(generator, nullptr);
463 
464     generator->base.destroy((HcfObjectBase *)generator);
465 }
466 
467 // for test:generator函数指针测试（异常）
468 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest103, TestSize.Level0)
469 {
470     HcfAsyKeyParamsSpec *paramSpec = nullptr;
471     int32_t res = ConstructEcc224CommParamsSpec(&paramSpec);
472 
473     ASSERT_EQ(res, HCF_SUCCESS);
474 
475     HcfAsyKeyGeneratorBySpec *generator = nullptr;
476     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
477 
478     ASSERT_EQ(res, HCF_SUCCESS);
479     ASSERT_NE(generator, nullptr);
480 
481     generator->base.destroy(nullptr);
482 
483     HcfObjDestroy(generator);
484 }
485 
486 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest104, TestSize.Level0)
487 {
488     HcfAsyKeyParamsSpec *paramSpec = nullptr;
489     int32_t res = ConstructEcc224CommParamsSpec(&paramSpec);
490 
491     ASSERT_EQ(res, HCF_SUCCESS);
492 
493     HcfAsyKeyGeneratorBySpec *generator = nullptr;
494     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
495 
496     ASSERT_EQ(res, HCF_SUCCESS);
497     ASSERT_NE(generator, nullptr);
498 
499     generator->base.destroy(&g_obj);
500 
501     HcfObjDestroy(generator);
502 }
503 
504 // for test:generator函数指针测试（正常）
505 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest105, TestSize.Level0)
506 {
507     HcfAsyKeyParamsSpec *paramSpec = nullptr;
508     int32_t res = ConstructEcc224CommParamsSpec(&paramSpec);
509 
510     ASSERT_EQ(res, HCF_SUCCESS);
511 
512     HcfAsyKeyGeneratorBySpec *generator = nullptr;
513     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
514 
515     ASSERT_EQ(res, HCF_SUCCESS);
516     ASSERT_NE(generator, nullptr);
517 
518     const char *algName = generator->getAlgName(generator);
519 
520     ASSERT_NE(algName, nullptr);
521 
522     HcfObjDestroy(generator);
523 }
524 
525 // for test:generator函数指针测试（异常）
526 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest106, TestSize.Level0)
527 {
528     HcfAsyKeyParamsSpec *paramSpec = nullptr;
529     int32_t res = ConstructEcc224CommParamsSpec(&paramSpec);
530 
531     ASSERT_EQ(res, HCF_SUCCESS);
532 
533     HcfAsyKeyGeneratorBySpec *generator = nullptr;
534     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
535 
536     ASSERT_EQ(res, HCF_SUCCESS);
537     ASSERT_NE(generator, nullptr);
538 
539     const char *algName = generator->getAlgName(nullptr);
540 
541     ASSERT_EQ(algName, nullptr);
542 
543     HcfObjDestroy(generator);
544 }
545 
546 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest107, TestSize.Level0)
547 {
548     HcfAsyKeyParamsSpec *paramSpec = nullptr;
549     int32_t res = ConstructEcc224CommParamsSpec(&paramSpec);
550 
551     ASSERT_EQ(res, HCF_SUCCESS);
552 
553     HcfAsyKeyGeneratorBySpec *generator = nullptr;
554     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
555 
556     ASSERT_EQ(res, HCF_SUCCESS);
557     ASSERT_NE(generator, nullptr);
558 
559     const char *algName = generator->getAlgName((HcfAsyKeyGeneratorBySpec *)&g_obj);
560 
561     ASSERT_EQ(algName, nullptr);
562 
563     HcfObjDestroy(generator);
564 }
565 
566 // for test:测试keyPair生成函数（正常）
567 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest201_1, TestSize.Level0)
568 {
569     HcfAsyKeyParamsSpec *paramSpec = nullptr;
570     int32_t res = ConstructEcc224CommParamsSpec(&paramSpec);
571 
572     ASSERT_EQ(res, HCF_SUCCESS);
573 
574     HcfAsyKeyGeneratorBySpec *generator = nullptr;
575     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
576 
577     ASSERT_EQ(res, HCF_SUCCESS);
578     ASSERT_NE(generator, nullptr);
579 
580     HcfKeyPair *keyPair = nullptr;
581     res = generator->generateKeyPair(generator, &keyPair);
582 
583     ASSERT_EQ(res, HCF_SUCCESS);
584     ASSERT_NE(keyPair, nullptr);
585 
586     HcfObjDestroy(keyPair);
587     HcfObjDestroy(generator);
588 }
589 
590 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest201_2, TestSize.Level0)
591 {
592     HcfAsyKeyParamsSpec *paramSpec = nullptr;
593     int32_t res = ConstructEcc224PubKeyParamsSpec(&paramSpec);
594 
595     ASSERT_EQ(res, HCF_SUCCESS);
596 
597     HcfAsyKeyGeneratorBySpec *generator = nullptr;
598     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
599 
600     ASSERT_EQ(res, HCF_SUCCESS);
601     ASSERT_NE(generator, nullptr);
602 
603     HcfPubKey *pubKey = nullptr;
604     res = generator->generatePubKey(generator, &pubKey);
605 
606     ASSERT_EQ(res, HCF_SUCCESS);
607     ASSERT_NE(pubKey, nullptr);
608 
609     HcfObjDestroy(pubKey);
610     HcfObjDestroy(generator);
611 }
612 
613 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest201_3, TestSize.Level0)
614 {
615     HcfAsyKeyParamsSpec *paramSpec = nullptr;
616     int32_t res = ConstructEcc224PriKeyParamsSpec(&paramSpec);
617 
618     ASSERT_EQ(res, HCF_SUCCESS);
619 
620     HcfAsyKeyGeneratorBySpec *generator = nullptr;
621     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
622 
623     ASSERT_EQ(res, HCF_SUCCESS);
624     ASSERT_NE(generator, nullptr);
625 
626     HcfPriKey *priKey = nullptr;
627     res = generator->generatePriKey(generator, &priKey);
628 
629     ASSERT_EQ(res, HCF_SUCCESS);
630     ASSERT_NE(priKey, nullptr);
631 
632     HcfObjDestroy(priKey);
633     HcfObjDestroy(generator);
634 }
635 
636 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest201_4, TestSize.Level0)
637 {
638     HcfAsyKeyParamsSpec *paramSpec = nullptr;
639     int32_t res = ConstructEcc224KeyPairParamsSpec(&paramSpec);
640 
641     ASSERT_EQ(res, HCF_SUCCESS);
642 
643     HcfAsyKeyGeneratorBySpec *generator = nullptr;
644     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
645 
646     ASSERT_EQ(res, HCF_SUCCESS);
647     ASSERT_NE(generator, nullptr);
648 
649     HcfKeyPair *keyPair = nullptr;
650     res = generator->generateKeyPair(generator, &keyPair);
651 
652     ASSERT_EQ(res, HCF_SUCCESS);
653     ASSERT_NE(keyPair, nullptr);
654 
655     HcfObjDestroy(keyPair);
656     HcfObjDestroy(generator);
657 }
658 
659 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest201_5, TestSize.Level0)
660 {
661     HcfAsyKeyParamsSpec *paramSpec = nullptr;
662     int32_t res = ConstructEcc224KeyPairParamsSpec(&paramSpec);
663 
664     ASSERT_EQ(res, HCF_SUCCESS);
665 
666     HcfAsyKeyGeneratorBySpec *generator = nullptr;
667     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
668 
669     ASSERT_EQ(res, HCF_SUCCESS);
670     ASSERT_NE(generator, nullptr);
671 
672     HcfPubKey *pubKey = nullptr;
673     res = generator->generatePubKey(generator, &pubKey);
674 
675     ASSERT_EQ(res, HCF_SUCCESS);
676     ASSERT_NE(pubKey, nullptr);
677 
678     HcfObjDestroy(pubKey);
679     HcfObjDestroy(generator);
680 }
681 
682 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest201_6, TestSize.Level0)
683 {
684     HcfAsyKeyParamsSpec *paramSpec = nullptr;
685     int32_t res = ConstructEcc224KeyPairParamsSpec(&paramSpec);
686 
687     ASSERT_EQ(res, HCF_SUCCESS);
688 
689     HcfAsyKeyGeneratorBySpec *generator = nullptr;
690     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
691 
692     ASSERT_EQ(res, HCF_SUCCESS);
693     ASSERT_NE(generator, nullptr);
694 
695     HcfPriKey *priKey = nullptr;
696     res = generator->generatePriKey(generator, &priKey);
697 
698     ASSERT_EQ(res, HCF_SUCCESS);
699     ASSERT_NE(priKey, nullptr);
700 
701     HcfObjDestroy(priKey);
702     HcfObjDestroy(generator);
703 }
704 
705 // for test:测试keyPair生成函数（异常）
706 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest202, TestSize.Level0)
707 {
708     HcfAsyKeyParamsSpec *paramSpec = nullptr;
709     int32_t res = ConstructEcc224CommParamsSpec(&paramSpec);
710 
711     ASSERT_EQ(res, HCF_SUCCESS);
712 
713     HcfAsyKeyGeneratorBySpec *generator = nullptr;
714     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
715 
716     ASSERT_EQ(res, HCF_SUCCESS);
717     ASSERT_NE(generator, nullptr);
718 
719     HcfKeyPair *keyPair = nullptr;
720     res = generator->generateKeyPair(nullptr, &keyPair);
721 
722     ASSERT_EQ(res, HCF_INVALID_PARAMS);
723     ASSERT_EQ(keyPair, nullptr);
724 
725     HcfObjDestroy(generator);
726 }
727 
728 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest203, TestSize.Level0)
729 {
730     HcfAsyKeyParamsSpec *paramSpec = nullptr;
731     int32_t res = ConstructEcc224CommParamsSpec(&paramSpec);
732 
733     ASSERT_EQ(res, HCF_SUCCESS);
734 
735     HcfAsyKeyGeneratorBySpec *generator = nullptr;
736     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
737 
738     ASSERT_EQ(res, HCF_SUCCESS);
739     ASSERT_NE(generator, nullptr);
740 
741     HcfKeyPair *keyPair = nullptr;
742     res = generator->generateKeyPair((HcfAsyKeyGeneratorBySpec *)&g_obj, &keyPair);
743 
744     ASSERT_EQ(res, HCF_INVALID_PARAMS);
745     ASSERT_EQ(keyPair, nullptr);
746 
747     HcfObjDestroy(generator);
748 }
749 
750 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest204, TestSize.Level0)
751 {
752     HcfAsyKeyParamsSpec *paramSpec = nullptr;
753     int32_t res = ConstructEcc224CommParamsSpec(&paramSpec);
754 
755     ASSERT_EQ(res, HCF_SUCCESS);
756 
757     HcfAsyKeyGeneratorBySpec *generator = nullptr;
758     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
759 
760     ASSERT_EQ(res, HCF_SUCCESS);
761     ASSERT_NE(generator, nullptr);
762 
763     res = generator->generateKeyPair(generator, nullptr);
764 
765     ASSERT_EQ(res, HCF_INVALID_PARAMS);
766 
767     HcfObjDestroy(generator);
768 }
769 
770 // for test:测试keyPair的函数指针（正常）
771 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest301_1, TestSize.Level0)
772 {
773     HcfAsyKeyParamsSpec *paramSpec = nullptr;
774     int32_t res = ConstructEcc224CommParamsSpec(&paramSpec);
775 
776     ASSERT_EQ(res, HCF_SUCCESS);
777 
778     HcfAsyKeyGeneratorBySpec *generator = nullptr;
779     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
780 
781     HcfKeyPair *keyPair = nullptr;
782     res = generator->generateKeyPair(generator, &keyPair);
783 
784     ASSERT_EQ(res, HCF_SUCCESS);
785     ASSERT_NE(keyPair, nullptr);
786 
787     const char *className = keyPair->base.getClass();
788 
789     ASSERT_NE(className, nullptr);
790 
791     HcfObjDestroy(keyPair);
792     HcfObjDestroy(generator);
793 }
794 
795 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest301_2, TestSize.Level0)
796 {
797     HcfAsyKeyParamsSpec *paramSpec = nullptr;
798     int32_t res = ConstructEcc224PubKeyParamsSpec(&paramSpec);
799 
800     ASSERT_EQ(res, HCF_SUCCESS);
801 
802     HcfAsyKeyGeneratorBySpec *generator = nullptr;
803     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
804 
805     HcfPubKey *pubKey = nullptr;
806     res = generator->generatePubKey(generator, &pubKey);
807 
808     ASSERT_EQ(res, HCF_SUCCESS);
809     ASSERT_NE(pubKey, nullptr);
810 
811     const char *className = pubKey->base.base.getClass();
812 
813     ASSERT_NE(className, nullptr);
814 
815     HcfObjDestroy(pubKey);
816     HcfObjDestroy(generator);
817 }
818 
819 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest301_3, TestSize.Level0)
820 {
821     HcfAsyKeyParamsSpec *paramSpec = nullptr;
822     int32_t res = ConstructEcc224PriKeyParamsSpec(&paramSpec);
823 
824     ASSERT_EQ(res, HCF_SUCCESS);
825 
826     HcfAsyKeyGeneratorBySpec *generator = nullptr;
827     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
828 
829     HcfPriKey *priKey = nullptr;
830     res = generator->generatePriKey(generator, &priKey);
831 
832     ASSERT_EQ(res, HCF_SUCCESS);
833     ASSERT_NE(priKey, nullptr);
834 
835     const char *className = priKey->base.base.getClass();
836 
837     ASSERT_NE(className, nullptr);
838 
839     HcfObjDestroy(priKey);
840     HcfObjDestroy(generator);
841 }
842 
843 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest301_4, TestSize.Level0)
844 {
845     HcfAsyKeyParamsSpec *paramSpec = nullptr;
846     int32_t res = ConstructEcc224KeyPairParamsSpec(&paramSpec);
847 
848     ASSERT_EQ(res, HCF_SUCCESS);
849 
850     HcfAsyKeyGeneratorBySpec *generator = nullptr;
851     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
852 
853     HcfKeyPair *keyPair = nullptr;
854     res = generator->generateKeyPair(generator, &keyPair);
855 
856     ASSERT_EQ(res, HCF_SUCCESS);
857     ASSERT_NE(keyPair, nullptr);
858 
859     const char *className = keyPair->base.getClass();
860 
861     ASSERT_NE(className, nullptr);
862 
863     HcfObjDestroy(keyPair);
864     HcfObjDestroy(generator);
865 }
866 
867 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest301_5, TestSize.Level0)
868 {
869     HcfAsyKeyParamsSpec *paramSpec = nullptr;
870     int32_t res = ConstructEcc224KeyPairParamsSpec(&paramSpec);
871 
872     ASSERT_EQ(res, HCF_SUCCESS);
873 
874     HcfAsyKeyGeneratorBySpec *generator = nullptr;
875     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
876 
877     HcfPubKey *pubKey = nullptr;
878     res = generator->generatePubKey(generator, &pubKey);
879 
880     ASSERT_EQ(res, HCF_SUCCESS);
881     ASSERT_NE(pubKey, nullptr);
882 
883     const char *className = pubKey->base.base.getClass();
884 
885     ASSERT_NE(className, nullptr);
886 
887     HcfObjDestroy(pubKey);
888     HcfObjDestroy(generator);
889 }
890 
891 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest301_6, TestSize.Level0)
892 {
893     HcfAsyKeyParamsSpec *paramSpec = nullptr;
894     int32_t res = ConstructEcc224KeyPairParamsSpec(&paramSpec);
895 
896     ASSERT_EQ(res, HCF_SUCCESS);
897 
898     HcfAsyKeyGeneratorBySpec *generator = nullptr;
899     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
900 
901     HcfPriKey *priKey = nullptr;
902     res = generator->generatePriKey(generator, &priKey);
903 
904     ASSERT_EQ(res, HCF_SUCCESS);
905     ASSERT_NE(priKey, nullptr);
906 
907     const char *className = priKey->base.base.getClass();
908 
909     ASSERT_NE(className, nullptr);
910 
911     HcfObjDestroy(priKey);
912     HcfObjDestroy(generator);
913 }
914 
915 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest302_1, TestSize.Level0)
916 {
917     HcfAsyKeyParamsSpec *paramSpec = nullptr;
918     int32_t res = ConstructEcc224CommParamsSpec(&paramSpec);
919 
920     ASSERT_EQ(res, HCF_SUCCESS);
921 
922     HcfAsyKeyGeneratorBySpec *generator = nullptr;
923     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
924 
925     HcfKeyPair *keyPair = nullptr;
926     res = generator->generateKeyPair(generator, &keyPair);
927 
928     ASSERT_EQ(res, HCF_SUCCESS);
929     ASSERT_NE(keyPair, nullptr);
930 
931     keyPair->base.destroy((HcfObjectBase *)(&(keyPair->base)));
932 
933     HcfObjDestroy(generator);
934 }
935 
936 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest302_2, TestSize.Level0)
937 {
938     HcfAsyKeyParamsSpec *paramSpec = nullptr;
939     int32_t res = ConstructEcc224PubKeyParamsSpec(&paramSpec);
940 
941     ASSERT_EQ(res, HCF_SUCCESS);
942 
943     HcfAsyKeyGeneratorBySpec *generator = nullptr;
944     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
945 
946     HcfPubKey *pubKey = nullptr;
947     res = generator->generatePubKey(generator, &pubKey);
948 
949     ASSERT_EQ(res, HCF_SUCCESS);
950     ASSERT_NE(pubKey, nullptr);
951 
952     pubKey->base.base.destroy((HcfObjectBase *)(&(pubKey->base.base)));
953 
954     HcfObjDestroy(generator);
955 }
956 
957 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest302_3, TestSize.Level0)
958 {
959     HcfAsyKeyParamsSpec *paramSpec = nullptr;
960     int32_t res = ConstructEcc224PriKeyParamsSpec(&paramSpec);
961 
962     ASSERT_EQ(res, HCF_SUCCESS);
963 
964     HcfAsyKeyGeneratorBySpec *generator = nullptr;
965     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
966 
967     HcfPriKey *priKey = nullptr;
968     res = generator->generatePriKey(generator, &priKey);
969 
970     ASSERT_EQ(res, HCF_SUCCESS);
971     ASSERT_NE(priKey, nullptr);
972 
973     priKey->base.base.destroy((HcfObjectBase *)(&(priKey->base.base)));
974 
975     HcfObjDestroy(generator);
976 }
977 
978 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest302_4, TestSize.Level0)
979 {
980     HcfAsyKeyParamsSpec *paramSpec = nullptr;
981     int32_t res = ConstructEcc224KeyPairParamsSpec(&paramSpec);
982 
983     ASSERT_EQ(res, HCF_SUCCESS);
984 
985     HcfAsyKeyGeneratorBySpec *generator = nullptr;
986     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
987 
988     HcfKeyPair *keyPair = nullptr;
989     res = generator->generateKeyPair(generator, &keyPair);
990 
991     ASSERT_EQ(res, HCF_SUCCESS);
992     ASSERT_NE(keyPair, nullptr);
993 
994     keyPair->base.destroy((HcfObjectBase *)(&(keyPair->base)));
995 
996     HcfObjDestroy(generator);
997 }
998 
999 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest302_5, TestSize.Level0)
1000 {
1001     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1002     int32_t res = ConstructEcc224KeyPairParamsSpec(&paramSpec);
1003 
1004     ASSERT_EQ(res, HCF_SUCCESS);
1005 
1006     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1007     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1008 
1009     HcfPubKey *pubKey = nullptr;
1010     res = generator->generatePubKey(generator, &pubKey);
1011 
1012     ASSERT_EQ(res, HCF_SUCCESS);
1013     ASSERT_NE(pubKey, nullptr);
1014 
1015     pubKey->base.base.destroy((HcfObjectBase *)(&(pubKey->base.base)));
1016 
1017     HcfObjDestroy(generator);
1018 }
1019 
1020 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest302_6, TestSize.Level0)
1021 {
1022     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1023     int32_t res = ConstructEcc224KeyPairParamsSpec(&paramSpec);
1024 
1025     ASSERT_EQ(res, HCF_SUCCESS);
1026 
1027     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1028     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1029 
1030     HcfPriKey *priKey = nullptr;
1031     res = generator->generatePriKey(generator, &priKey);
1032 
1033     ASSERT_EQ(res, HCF_SUCCESS);
1034     ASSERT_NE(priKey, nullptr);
1035 
1036     priKey->base.base.destroy((HcfObjectBase *)(&(priKey->base.base)));
1037 
1038     HcfObjDestroy(generator);
1039 }
1040 
1041 // for test:测试keyPair的函数指针（异常）
1042 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest303, TestSize.Level0)
1043 {
1044     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1045     int32_t res = ConstructEcc224CommParamsSpec(&paramSpec);
1046 
1047     ASSERT_EQ(res, HCF_SUCCESS);
1048 
1049     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1050     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1051 
1052     HcfKeyPair *keyPair = nullptr;
1053     res = generator->generateKeyPair(generator, &keyPair);
1054 
1055     ASSERT_EQ(res, HCF_SUCCESS);
1056     ASSERT_NE(keyPair, nullptr);
1057 
1058     keyPair->base.destroy(nullptr);
1059 
1060     HcfObjDestroy(keyPair);
1061     HcfObjDestroy(generator);
1062 }
1063 
1064 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest304, TestSize.Level0)
1065 {
1066     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1067     int32_t res = ConstructEcc224CommParamsSpec(&paramSpec);
1068 
1069     ASSERT_EQ(res, HCF_SUCCESS);
1070 
1071     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1072     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1073 
1074     HcfKeyPair *keyPair = nullptr;
1075     res = generator->generateKeyPair(generator, &keyPair);
1076 
1077     ASSERT_EQ(res, HCF_SUCCESS);
1078     ASSERT_NE(keyPair, nullptr);
1079 
1080     keyPair->base.destroy(&g_obj);
1081 
1082     HcfObjDestroy(keyPair);
1083     HcfObjDestroy(generator);
1084 }
1085 
1086 // for test:测试keyPair的函数指针（正常）
1087 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest305_1, TestSize.Level0)
1088 {
1089     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1090     int32_t res = ConstructEcc224CommParamsSpec(&paramSpec);
1091 
1092     ASSERT_EQ(res, HCF_SUCCESS);
1093 
1094     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1095     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1096 
1097     HcfKeyPair *keyPair = nullptr;
1098     res = generator->generateKeyPair(generator, &keyPair);
1099 
1100     ASSERT_EQ(res, HCF_SUCCESS);
1101     ASSERT_NE(keyPair, nullptr);
1102 
1103     const char *className = keyPair->pubKey->base.base.getClass();
1104     ASSERT_NE(className, nullptr);
1105 
1106     HcfObjDestroy(keyPair);
1107     HcfObjDestroy(generator);
1108 }
1109 
1110 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest305_2, TestSize.Level0)
1111 {
1112     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1113     int32_t res = ConstructEcc224KeyPairParamsSpec(&paramSpec);
1114 
1115     ASSERT_EQ(res, HCF_SUCCESS);
1116 
1117     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1118     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1119 
1120     HcfKeyPair *keyPair = nullptr;
1121     res = generator->generateKeyPair(generator, &keyPair);
1122 
1123     ASSERT_EQ(res, HCF_SUCCESS);
1124     ASSERT_NE(keyPair, nullptr);
1125 
1126     const char *className = keyPair->pubKey->base.base.getClass();
1127     ASSERT_NE(className, nullptr);
1128 
1129     HcfObjDestroy(keyPair);
1130     HcfObjDestroy(generator);
1131 }
1132 
1133 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest305_3, TestSize.Level0)
1134 {
1135     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1136     int32_t res = ConstructEcc224CommParamsSpec(&paramSpec);
1137 
1138     ASSERT_EQ(res, HCF_SUCCESS);
1139 
1140     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1141     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1142 
1143     HcfKeyPair *keyPair = nullptr;
1144     res = generator->generateKeyPair(generator, &keyPair);
1145 
1146     ASSERT_EQ(res, HCF_SUCCESS);
1147     ASSERT_NE(keyPair, nullptr);
1148 
1149     keyPair->pubKey->base.base.destroy((HcfObjectBase *)(&(keyPair->pubKey->base.base)));
1150     keyPair->pubKey = nullptr;
1151 
1152     HcfObjDestroy(keyPair);
1153     HcfObjDestroy(generator);
1154 }
1155 
1156 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest305_4, TestSize.Level0)
1157 {
1158     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1159     int32_t res = ConstructEcc224KeyPairParamsSpec(&paramSpec);
1160 
1161     ASSERT_EQ(res, HCF_SUCCESS);
1162 
1163     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1164     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1165 
1166     HcfKeyPair *keyPair = nullptr;
1167     res = generator->generateKeyPair(generator, &keyPair);
1168 
1169     ASSERT_EQ(res, HCF_SUCCESS);
1170     ASSERT_NE(keyPair, nullptr);
1171 
1172     keyPair->pubKey->base.base.destroy((HcfObjectBase *)(&(keyPair->pubKey->base.base)));
1173     keyPair->pubKey = nullptr;
1174 
1175     HcfObjDestroy(keyPair);
1176     HcfObjDestroy(generator);
1177 }
1178 
1179 // for test:测试keyPair的函数指针（异常）
1180 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest306, TestSize.Level0)
1181 {
1182     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1183     int32_t res = ConstructEcc224CommParamsSpec(&paramSpec);
1184 
1185     ASSERT_EQ(res, HCF_SUCCESS);
1186 
1187     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1188     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1189 
1190     HcfKeyPair *keyPair = nullptr;
1191     res = generator->generateKeyPair(generator, &keyPair);
1192 
1193     ASSERT_EQ(res, HCF_SUCCESS);
1194     ASSERT_NE(keyPair, nullptr);
1195 
1196     keyPair->pubKey->base.base.destroy(nullptr);
1197 
1198     HcfObjDestroy(keyPair);
1199     HcfObjDestroy(generator);
1200 }
1201 
1202 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest307, TestSize.Level0)
1203 {
1204     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1205     int32_t res = ConstructEcc224CommParamsSpec(&paramSpec);
1206 
1207     ASSERT_EQ(res, HCF_SUCCESS);
1208 
1209     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1210     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1211 
1212     HcfKeyPair *keyPair = nullptr;
1213     res = generator->generateKeyPair(generator, &keyPair);
1214 
1215     ASSERT_EQ(res, HCF_SUCCESS);
1216     ASSERT_NE(keyPair, nullptr);
1217 
1218     keyPair->pubKey->base.base.destroy(&g_obj);
1219 
1220     HcfObjDestroy(keyPair);
1221     HcfObjDestroy(generator);
1222 }
1223 
1224 // for test:测试keyPair的函数指针（正常）
1225 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest308_1, TestSize.Level0)
1226 {
1227     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1228     int32_t res = ConstructEcc224CommParamsSpec(&paramSpec);
1229 
1230     ASSERT_EQ(res, HCF_SUCCESS);
1231 
1232     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1233     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1234 
1235     HcfKeyPair *keyPair = nullptr;
1236     res = generator->generateKeyPair(generator, &keyPair);
1237 
1238     ASSERT_EQ(res, HCF_SUCCESS);
1239     ASSERT_NE(keyPair, nullptr);
1240 
1241     const char *format = keyPair->pubKey->base.getFormat(&(keyPair->pubKey->base));
1242 
1243     ASSERT_NE(format, nullptr);
1244 
1245     HcfObjDestroy(keyPair);
1246     HcfObjDestroy(generator);
1247 }
1248 
1249 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest308_2, TestSize.Level0)
1250 {
1251     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1252     int32_t res = ConstructEcc224PubKeyParamsSpec(&paramSpec);
1253 
1254     ASSERT_EQ(res, HCF_SUCCESS);
1255 
1256     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1257     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1258 
1259     HcfPubKey *pubKey = nullptr;
1260     res = generator->generatePubKey(generator, &pubKey);
1261 
1262     ASSERT_EQ(res, HCF_SUCCESS);
1263     ASSERT_NE(pubKey, nullptr);
1264 
1265     const char *format = pubKey->base.getFormat(&(pubKey->base));
1266 
1267     ASSERT_NE(format, nullptr);
1268 
1269     HcfObjDestroy(pubKey);
1270     HcfObjDestroy(generator);
1271 }
1272 
1273 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest308_3, TestSize.Level0)
1274 {
1275     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1276     int32_t res = ConstructEcc224PriKeyParamsSpec(&paramSpec);
1277 
1278     ASSERT_EQ(res, HCF_SUCCESS);
1279 
1280     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1281     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1282 
1283     HcfPriKey *priKey = nullptr;
1284     res = generator->generatePriKey(generator, &priKey);
1285 
1286     ASSERT_EQ(res, HCF_SUCCESS);
1287     ASSERT_NE(priKey, nullptr);
1288 
1289     const char *format = priKey->base.getFormat(&(priKey->base));
1290 
1291     ASSERT_NE(format, nullptr);
1292 
1293     HcfObjDestroy(priKey);
1294     HcfObjDestroy(generator);
1295 }
1296 
1297 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest308_4, TestSize.Level0)
1298 {
1299     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1300     int32_t res = ConstructEcc224KeyPairParamsSpec(&paramSpec);
1301 
1302     ASSERT_EQ(res, HCF_SUCCESS);
1303 
1304     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1305     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1306 
1307     HcfKeyPair *keyPair = nullptr;
1308     res = generator->generateKeyPair(generator, &keyPair);
1309 
1310     ASSERT_EQ(res, HCF_SUCCESS);
1311     ASSERT_NE(keyPair, nullptr);
1312 
1313     const char *format = keyPair->pubKey->base.getFormat(&(keyPair->pubKey->base));
1314 
1315     ASSERT_NE(format, nullptr);
1316 
1317     HcfObjDestroy(keyPair);
1318     HcfObjDestroy(generator);
1319 }
1320 
1321 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest308_5, TestSize.Level0)
1322 {
1323     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1324     int32_t res = ConstructEcc224KeyPairParamsSpec(&paramSpec);
1325 
1326     ASSERT_EQ(res, HCF_SUCCESS);
1327 
1328     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1329     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1330 
1331     HcfPubKey *pubKey = nullptr;
1332     res = generator->generatePubKey(generator, &pubKey);
1333 
1334     ASSERT_EQ(res, HCF_SUCCESS);
1335     ASSERT_NE(pubKey, nullptr);
1336 
1337     const char *format = pubKey->base.getFormat(&(pubKey->base));
1338 
1339     ASSERT_NE(format, nullptr);
1340 
1341     HcfObjDestroy(pubKey);
1342     HcfObjDestroy(generator);
1343 }
1344 
1345 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest308_6, TestSize.Level0)
1346 {
1347     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1348     int32_t res = ConstructEcc224KeyPairParamsSpec(&paramSpec);
1349 
1350     ASSERT_EQ(res, HCF_SUCCESS);
1351 
1352     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1353     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1354 
1355     HcfPriKey *priKey = nullptr;
1356     res = generator->generatePriKey(generator, &priKey);
1357 
1358     ASSERT_EQ(res, HCF_SUCCESS);
1359     ASSERT_NE(priKey, nullptr);
1360 
1361     const char *format = priKey->base.getFormat(&(priKey->base));
1362 
1363     ASSERT_NE(format, nullptr);
1364 
1365     HcfObjDestroy(priKey);
1366     HcfObjDestroy(generator);
1367 }
1368 
1369 // for test:测试keyPair的函数指针（异常）
1370 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest309, TestSize.Level0)
1371 {
1372     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1373     int32_t res = ConstructEcc224CommParamsSpec(&paramSpec);
1374 
1375     ASSERT_EQ(res, HCF_SUCCESS);
1376 
1377     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1378     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1379 
1380     HcfKeyPair *keyPair = nullptr;
1381     res = generator->generateKeyPair(generator, &keyPair);
1382 
1383     ASSERT_EQ(res, HCF_SUCCESS);
1384     ASSERT_NE(keyPair, nullptr);
1385 
1386     const char *format = keyPair->pubKey->base.getFormat(nullptr);
1387 
1388     ASSERT_EQ(format, nullptr);
1389 
1390     HcfObjDestroy(keyPair);
1391     HcfObjDestroy(generator);
1392 }
1393 
1394 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest310, TestSize.Level0)
1395 {
1396     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1397     int32_t res = ConstructEcc224CommParamsSpec(&paramSpec);
1398 
1399     ASSERT_EQ(res, HCF_SUCCESS);
1400 
1401     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1402     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1403 
1404     HcfKeyPair *keyPair = nullptr;
1405     res = generator->generateKeyPair(generator, &keyPair);
1406 
1407     ASSERT_EQ(res, HCF_SUCCESS);
1408     ASSERT_NE(keyPair, nullptr);
1409 
1410     const char *format = keyPair->pubKey->base.getFormat((HcfKey *)&g_obj);
1411 
1412     ASSERT_EQ(format, nullptr);
1413 
1414     HcfObjDestroy(keyPair);
1415     HcfObjDestroy(generator);
1416 }
1417 
1418 // for test:测试keyPair的函数指针（正常）
1419 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest311_1, TestSize.Level0)
1420 {
1421     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1422     int32_t res = ConstructEcc224CommParamsSpec(&paramSpec);
1423 
1424     ASSERT_EQ(res, HCF_SUCCESS);
1425 
1426     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1427     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1428 
1429     HcfKeyPair *keyPair = nullptr;
1430     res = generator->generateKeyPair(generator, &keyPair);
1431 
1432     ASSERT_EQ(res, HCF_SUCCESS);
1433     ASSERT_NE(keyPair, nullptr);
1434 
1435     const char *algName = keyPair->pubKey->base.getAlgorithm(&(keyPair->pubKey->base));
1436 
1437     ASSERT_NE(algName, nullptr);
1438 
1439     HcfObjDestroy(keyPair);
1440     HcfObjDestroy(generator);
1441 }
1442 
1443 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest311_2, TestSize.Level0)
1444 {
1445     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1446     int32_t res = ConstructEcc224PubKeyParamsSpec(&paramSpec);
1447 
1448     ASSERT_EQ(res, HCF_SUCCESS);
1449 
1450     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1451     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1452 
1453     HcfPubKey *pubKey = nullptr;
1454     res = generator->generatePubKey(generator, &pubKey);
1455 
1456     ASSERT_EQ(res, HCF_SUCCESS);
1457     ASSERT_NE(pubKey, nullptr);
1458 
1459     const char *algName = pubKey->base.getAlgorithm(&(pubKey->base));
1460 
1461     ASSERT_NE(algName, nullptr);
1462 
1463     HcfObjDestroy(pubKey);
1464     HcfObjDestroy(generator);
1465 }
1466 
1467 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest311_3, TestSize.Level0)
1468 {
1469     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1470     int32_t res = ConstructEcc224PriKeyParamsSpec(&paramSpec);
1471 
1472     ASSERT_EQ(res, HCF_SUCCESS);
1473 
1474     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1475     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1476 
1477     HcfPriKey *priKey = nullptr;
1478     res = generator->generatePriKey(generator, &priKey);
1479 
1480     ASSERT_EQ(res, HCF_SUCCESS);
1481     ASSERT_NE(priKey, nullptr);
1482 
1483     const char *algName = priKey->base.getAlgorithm(&(priKey->base));
1484 
1485     ASSERT_NE(algName, nullptr);
1486 
1487     HcfObjDestroy(priKey);
1488     HcfObjDestroy(generator);
1489 }
1490 
1491 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest311_4, TestSize.Level0)
1492 {
1493     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1494     int32_t res = ConstructEcc224KeyPairParamsSpec(&paramSpec);
1495 
1496     ASSERT_EQ(res, HCF_SUCCESS);
1497 
1498     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1499     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1500 
1501     HcfKeyPair *keyPair = nullptr;
1502     res = generator->generateKeyPair(generator, &keyPair);
1503 
1504     ASSERT_EQ(res, HCF_SUCCESS);
1505     ASSERT_NE(keyPair, nullptr);
1506 
1507     const char *algName = keyPair->pubKey->base.getAlgorithm(&(keyPair->pubKey->base));
1508 
1509     ASSERT_NE(algName, nullptr);
1510 
1511     HcfObjDestroy(keyPair);
1512     HcfObjDestroy(generator);
1513 }
1514 
1515 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest311_5, TestSize.Level0)
1516 {
1517     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1518     int32_t res = ConstructEcc224KeyPairParamsSpec(&paramSpec);
1519 
1520     ASSERT_EQ(res, HCF_SUCCESS);
1521 
1522     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1523     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1524 
1525     HcfPubKey *pubKey = nullptr;
1526     res = generator->generatePubKey(generator, &pubKey);
1527 
1528     ASSERT_EQ(res, HCF_SUCCESS);
1529     ASSERT_NE(pubKey, nullptr);
1530 
1531     const char *algName = pubKey->base.getAlgorithm(&(pubKey->base));
1532 
1533     ASSERT_NE(algName, nullptr);
1534 
1535     HcfObjDestroy(pubKey);
1536     HcfObjDestroy(generator);
1537 }
1538 
1539 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest311_6, TestSize.Level0)
1540 {
1541     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1542     int32_t res = ConstructEcc224KeyPairParamsSpec(&paramSpec);
1543 
1544     ASSERT_EQ(res, HCF_SUCCESS);
1545 
1546     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1547     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1548 
1549     HcfPriKey *priKey = nullptr;
1550     res = generator->generatePriKey(generator, &priKey);
1551 
1552     ASSERT_EQ(res, HCF_SUCCESS);
1553     ASSERT_NE(priKey, nullptr);
1554 
1555     const char *algName = priKey->base.getAlgorithm(&(priKey->base));
1556 
1557     ASSERT_NE(algName, nullptr);
1558 
1559     HcfObjDestroy(priKey);
1560     HcfObjDestroy(generator);
1561 }
1562 
1563 // for test:测试keyPair的函数指针（异常）
1564 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest312, TestSize.Level0)
1565 {
1566     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1567     int32_t res = ConstructEcc224CommParamsSpec(&paramSpec);
1568 
1569     ASSERT_EQ(res, HCF_SUCCESS);
1570 
1571     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1572     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1573 
1574     HcfKeyPair *keyPair = nullptr;
1575     res = generator->generateKeyPair(generator, &keyPair);
1576 
1577     ASSERT_EQ(res, HCF_SUCCESS);
1578     ASSERT_NE(keyPair, nullptr);
1579 
1580     const char *algName = keyPair->pubKey->base.getAlgorithm(nullptr);
1581 
1582     ASSERT_EQ(algName, nullptr);
1583 
1584     HcfObjDestroy(keyPair);
1585     HcfObjDestroy(generator);
1586 }
1587 
1588 HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest313, TestSize.Level0)
1589 {
1590     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1591     int32_t res = ConstructEcc224CommParamsSpec(&paramSpec);
1592 
1593     ASSERT_EQ(res, HCF_SUCCESS);
1594 
1595     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1596     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1597 
1598     HcfKeyPair *keyPair = nullptr;
1599     res = generator->generateKeyPair(generator, &keyPair);
1600 
1601     ASSERT_EQ(res, HCF_SUCCESS);
1602     ASSERT_NE(keyPair, nullptr);
1603 
1604     const char *algName = keyPair->pubKey->base.getAlgorithm((HcfKey *)&g_obj);
1605 
1606     ASSERT_EQ(algName, nullptr);
1607 
1608     HcfObjDestroy(keyPair);
1609     HcfObjDestroy(generator);
1610 }
1611 }
1612