1/*
2 * Copyright (c) 2021 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 <stdio.h>
17#include <stdlib.h>
18#include <unistd.h>
19
20#include "ComplexTest.h"
21#include "log.h"
22#include "gtest/gtest.h"
23
24using namespace testing::ext;
25
26class MathComplexApiTest : public testing::Test {
27};
28
29/**
30* @tc.number     SUB_KERNEL_MATH_COMPLEX_CABS_0100
31* @tc.name       test cabs api
32* @tc.desc       [C- SOFTWARE -0100]
33*/
34HWTEST_F(MathComplexApiTest, testCabs, Function | MediumTest | Level1) {
35    int ret = TestCabs();
36    ASSERT_EQ(ret, 0);
37}
38/**
39* @tc.number     SUB_KERNEL_MATH_COMPLEX_CABSF_0100
40* @tc.name       test cabsf api
41* @tc.desc       [C- SOFTWARE -0100]
42*/
43HWTEST_F(MathComplexApiTest, testCabsf, Function | MediumTest | Level1) {
44    int ret = TestCabsf();
45    ASSERT_EQ(ret, 0);
46}
47
48/**
49* @tc.number     SUB_KERNEL_MATH_COMPLEX_CABSL_0100
50* @tc.name       test cabsl api
51* @tc.desc       [C- SOFTWARE -0100]
52*/
53HWTEST_F(MathComplexApiTest, testCabsl, Function | MediumTest | Level1) {
54    int ret = TestCabsl();
55    ASSERT_EQ(ret, 0);
56}
57
58/**
59* @tc.number     SUB_KERNEL_MATH_COMPLEX_CACOS_0100
60* @tc.name       test cacos api
61* @tc.desc       [C- SOFTWARE -0100]
62*/
63HWTEST_F(MathComplexApiTest, testCacos, Function | MediumTest | Level1) {
64    int ret = TestCacos();
65    ASSERT_EQ(ret, 0);
66}
67
68/**
69* @tc.number     SUB_KERNEL_MATH_COMPLEX_CACOSF_0100
70* @tc.name       test cacosf api
71* @tc.desc       [C- SOFTWARE -0100]
72*/
73HWTEST_F(MathComplexApiTest, testCacosf, Function | MediumTest | Level1) {
74    int ret = TestCacosf();
75    ASSERT_EQ(ret, 0);
76}
77
78/**
79* @tc.number     SUB_KERNEL_MATH_COMPLEX_CACOSHF_0100
80* @tc.name       test cacoshf api
81* @tc.desc       [C- SOFTWARE -0100]
82*/
83HWTEST_F(MathComplexApiTest, testCacoshf, Function | MediumTest | Level1) {
84    int ret = TestCacoshf();
85    ASSERT_EQ(ret, 0);
86}
87
88/**
89* @tc.number     SUB_KERNEL_MATH_COMPLEX_CACOSHL_0100
90* @tc.name       test cacoshl api
91* @tc.desc       [C- SOFTWARE -0100]
92*/
93HWTEST_F(MathComplexApiTest, testCacoshl, Function | MediumTest | Level1) {
94    int ret = TestCacoshl();
95    ASSERT_EQ(ret, 0);
96}
97
98/**
99* @tc.number     SUB_KERNEL_MATH_COMPLEX_CACOSL_0100
100* @tc.name       test cacosl api
101* @tc.desc       [C- SOFTWARE -0100]
102*/
103HWTEST_F(MathComplexApiTest, testCacosl, Function | MediumTest | Level1) {
104    int ret = TestCacosl();
105    ASSERT_EQ(ret, 0);
106}
107
108/**
109* @tc.number     SUB_KERNEL_MATH_COMPLEX_CARG_0100
110* @tc.name       test carg api
111* @tc.desc       [C- SOFTWARE -0100]
112*/
113HWTEST_F(MathComplexApiTest, testCarg, Function | MediumTest | Level1) {
114    int ret = TestCarg();
115    ASSERT_EQ(ret, 0);
116}
117
118/**
119* @tc.number     SUB_KERNEL_MATH_COMPLEX_CARGF_0100
120* @tc.name       test cargf api
121* @tc.desc       [C- SOFTWARE -0100]
122*/
123HWTEST_F(MathComplexApiTest, testCargf, Function | MediumTest | Level1) {
124    int ret = TestCargf();
125    ASSERT_EQ(ret, 0);
126}
127
128/**
129* @tc.number     SUB_KERNEL_MATH_COMPLEX_CARGL_0100
130* @tc.name       test cargl api
131* @tc.desc       [C- SOFTWARE -0100]
132*/
133HWTEST_F(MathComplexApiTest, testCargl, Function | MediumTest | Level1) {
134    int ret = TestCargl();
135    ASSERT_EQ(ret, 0);
136}
137
138/**
139* @tc.number     SUB_KERNEL_MATH_COMPLEX_CASIN_0100
140* @tc.name       test casin api
141* @tc.desc       [C- SOFTWARE -0100]
142*/
143HWTEST_F(MathComplexApiTest, testCasin, Function | MediumTest | Level1) {
144    int ret = TestCasin();
145    ASSERT_EQ(ret, 0);
146}
147
148/**
149* @tc.number     SUB_KERNEL_MATH_COMPLEX_CASINF_0100
150* @tc.name       test casinf api
151* @tc.desc       [C- SOFTWARE -0100]
152*/
153HWTEST_F(MathComplexApiTest, testCasinf, Function | MediumTest | Level1) {
154    int ret = TestCasinf();
155    ASSERT_EQ(ret, 0);
156}
157
158/**
159* @tc.number     SUB_KERNEL_MATH_COMPLEX_CASINH_0100
160* @tc.name       test casinh api
161* @tc.desc       [C- SOFTWARE -0100]
162*/
163HWTEST_F(MathComplexApiTest, testCasinh, Function | MediumTest | Level1) {
164    int ret = TestCasinh();
165    ASSERT_EQ(ret, 0);
166}
167
168/**
169* @tc.number     SUB_KERNEL_MATH_COMPLEX_CASINHF_0100
170* @tc.name       test casinhf api
171* @tc.desc       [C- SOFTWARE -0100]
172*/
173HWTEST_F(MathComplexApiTest, testCasinhf, Function | MediumTest | Level1) {
174    int ret = TestCasinhf();
175    ASSERT_EQ(ret, 0);
176}
177
178/**
179* @tc.number     SUB_KERNEL_MATH_COMPLEX_CASINHL_0100
180* @tc.name       test casinhl api
181* @tc.desc       [C- SOFTWARE -0100]
182*/
183HWTEST_F(MathComplexApiTest, testCasinhl, Function | MediumTest | Level1) {
184    int ret = TestCasinhl();
185    ASSERT_EQ(ret, 0);
186}
187
188/**
189* @tc.number     SUB_KERNEL_MATH_COMPLEX_CASINL_0100
190* @tc.name       test casinl api
191* @tc.desc       [C- SOFTWARE -0100]
192*/
193HWTEST_F(MathComplexApiTest, TestCasinl, Function | MediumTest | Level1) {
194    int ret = TestCasinl();
195    ASSERT_EQ(ret, 0);
196}
197
198/**
199* @tc.number     SUB_KERNEL_MATH_COMPLEX_CATAN_0100
200* @tc.name       test catan api
201* @tc.desc       [C- SOFTWARE -0100]
202*/
203HWTEST_F(MathComplexApiTest, TestCatan, Function | MediumTest | Level1) {
204    int ret = TestCatan();
205    ASSERT_EQ(ret, 0);
206}
207
208/**
209* @tc.number     SUB_KERNEL_MATH_COMPLEX_CATANF_0100
210* @tc.name       test catanf api
211* @tc.desc       [C- SOFTWARE -0100]
212*/
213HWTEST_F(MathComplexApiTest, TestCatanf, Function | MediumTest | Level1) {
214    int ret = TestCatanf();
215    ASSERT_EQ(ret, 0);
216}
217
218/**
219* @tc.number     SUB_KERNEL_MATH_COMPLEX_CATANH_0100
220* @tc.name       test catanh api
221* @tc.desc       [C- SOFTWARE -0100]
222*/
223HWTEST_F(MathComplexApiTest, TestCatanh, Function | MediumTest | Level1) {
224    int ret = TestCatanh();
225    ASSERT_EQ(ret, 0);
226}
227
228/**
229* @tc.number     SUB_KERNEL_MATH_COMPLEX_CATANHF_0100
230* @tc.name       test catanhf api
231* @tc.desc       [C- SOFTWARE -0100]
232*/
233HWTEST_F(MathComplexApiTest, TestCatanhf, Function | MediumTest | Level1) {
234    int ret = TestCatanhf();
235    ASSERT_EQ(ret, 0);
236}
237
238/**
239* @tc.number     SUB_KERNEL_MATH_COMPLEX_CATANHL_0100
240* @tc.name       test catanhl api
241* @tc.desc       [C- SOFTWARE -0100]
242*/
243HWTEST_F(MathComplexApiTest, TestCatanhl, Function | MediumTest | Level1) {
244    int ret = TestCatanhl();
245    ASSERT_EQ(ret, 0);
246}
247
248/**
249* @tc.number     SUB_KERNEL_MATH_COMPLEX_CATANL_0100
250* @tc.name       test catanl api
251* @tc.desc       [C- SOFTWARE -0100]
252*/
253HWTEST_F(MathComplexApiTest, TestCatanl, Function | MediumTest | Level1) {
254    int ret = TestCatanl();
255    ASSERT_EQ(ret, 0);
256}
257
258/**
259* @tc.number     SUB_KERNEL_MATH_COMPLEX_CCOS_0100
260* @tc.name       test ccos api
261* @tc.desc       [C- SOFTWARE -0100]
262*/
263HWTEST_F(MathComplexApiTest, TestCcos, Function | MediumTest | Level1) {
264    int ret = TestCcos();
265    ASSERT_EQ(ret, 0);
266}
267
268/**
269* @tc.number     SUB_KERNEL_MATH_COMPLEX_CCOSF_0100
270* @tc.name       test ccosf api
271* @tc.desc       [C- SOFTWARE -0100]
272*/
273HWTEST_F(MathComplexApiTest, TestCcosf, Function | MediumTest | Level1) {
274    int ret = TestCcosf();
275    ASSERT_EQ(ret, 0);
276}
277
278/**
279* @tc.number     SUB_KERNEL_MATH_COMPLEX_CCOSH_0100
280* @tc.name       test ccosh api
281* @tc.desc       [C- SOFTWARE -0100]
282*/
283HWTEST_F(MathComplexApiTest, TestCcosh, Function | MediumTest | Level1) {
284    int ret = TestCcosh();
285    ASSERT_EQ(ret, 0);
286}
287
288/**
289* @tc.number     SUB_KERNEL_MATH_COMPLEX_CCOSHF_0100
290* @tc.name       test ccoshf api
291* @tc.desc       [C- SOFTWARE -0100]
292*/
293HWTEST_F(MathComplexApiTest, TestCcoshf, Function | MediumTest | Level1) {
294    int ret = TestCcoshf();
295    ASSERT_EQ(ret, 0);
296}
297
298/**
299* @tc.number     SUB_KERNEL_MATH_COMPLEX_CCOSHL_0100
300* @tc.name       test ccoshl api
301* @tc.desc       [C- SOFTWARE -0100]
302*/
303HWTEST_F(MathComplexApiTest, TestCcoshl, Function | MediumTest | Level1) {
304    int ret = TestCcoshl();
305    ASSERT_EQ(ret, 0);
306}
307
308/**
309* @tc.number     SUB_KERNEL_MATH_COMPLEX_CCOSL_0100
310* @tc.name       test ccosl api
311* @tc.desc       [C- SOFTWARE -0100]
312*/
313HWTEST_F(MathComplexApiTest, TestCcosl, Function | MediumTest | Level1) {
314    int ret = TestCcosl();
315    ASSERT_EQ(ret, 0);
316}
317
318/**
319* @tc.number     SUB_KERNEL_MATH_COMPLEX_CEXP_0100
320* @tc.name       test cexp api
321* @tc.desc       [C- SOFTWARE -0100]
322*/
323HWTEST_F(MathComplexApiTest, TestCexp, Function | MediumTest | Level1) {
324    int ret = TestCexp();
325    ASSERT_EQ(ret, 0);
326}
327
328/**
329* @tc.number     SUB_KERNEL_MATH_COMPLEX_CEXPF_0100
330* @tc.name       test cexpf api
331* @tc.desc       [C- SOFTWARE -0100]
332*/
333HWTEST_F(MathComplexApiTest, TestCexpf, Function | MediumTest | Level1) {
334    int ret = TestCexpf();
335    ASSERT_EQ(ret, 0);
336}
337
338/**
339* @tc.number     SUB_KERNEL_MATH_COMPLEX_CEXPL_0100
340* @tc.name       test cexpl api
341* @tc.desc       [C- SOFTWARE -0100]
342*/
343HWTEST_F(MathComplexApiTest, TestCexpl, Function | MediumTest | Level1) {
344    int ret = TestCexpl();
345    ASSERT_EQ(ret, 0);
346}
347
348/**
349* @tc.number     SUB_KERNEL_MATH_COMPLEX_CIMAG_0100
350* @tc.name       test cimag api
351* @tc.desc       [C- SOFTWARE -0100]
352*/
353HWTEST_F(MathComplexApiTest, TestCimag, Function | MediumTest | Level1) {
354    int ret = TestCimag();
355    ASSERT_EQ(ret, 0);
356}
357
358/**
359* @tc.number     SUB_KERNEL_MATH_COMPLEX_CIMAGF_0100
360* @tc.name       test cimagf api
361* @tc.desc       [C- SOFTWARE -0100]
362*/
363HWTEST_F(MathComplexApiTest, TestCimagf, Function | MediumTest | Level1) {
364    int ret = TestCimagf();
365    ASSERT_EQ(ret, 0);
366}
367
368/**
369* @tc.number     SUB_KERNEL_MATH_COMPLEX_CIMAGL_0100
370* @tc.name       test cimagl api
371* @tc.desc       [C- SOFTWARE -0100]
372*/
373HWTEST_F(MathComplexApiTest, TestCimagl, Function | MediumTest | Level1) {
374    int ret = TestCimagl();
375    ASSERT_EQ(ret, 0);
376}
377
378/**
379* @tc.number     SUB_KERNEL_MATH_COMPLEX_CLOG_0100
380* @tc.name       test clog api
381* @tc.desc       [C- SOFTWARE -0100]
382*/
383HWTEST_F(MathComplexApiTest, TestClog, Function | MediumTest | Level1) {
384    int ret = TestClog();
385    ASSERT_EQ(ret, 0);
386}
387
388/**
389* @tc.number     SUB_KERNEL_MATH_COMPLEX_CLOGF_0100
390* @tc.name       test clogf api
391* @tc.desc       [C- SOFTWARE -0100]
392*/
393HWTEST_F(MathComplexApiTest, TestClogf, Function | MediumTest | Level1) {
394    int ret = TestClogf();
395    ASSERT_EQ(ret, 0);
396}
397
398/**
399* @tc.number     SUB_KERNEL_MATH_COMPLEX_CLOGL_0100
400* @tc.name       test clogl api
401* @tc.desc       [C- SOFTWARE -0100]
402*/
403HWTEST_F(MathComplexApiTest, TestClogl, Function | MediumTest | Level1) {
404    int ret = TestClogl();
405    ASSERT_EQ(ret, 0);
406}
407
408/**
409* @tc.number     SUB_KERNEL_MATH_COMPLEX_CONJ_0100
410* @tc.name       test conj api
411* @tc.desc       [C- SOFTWARE -0100]
412*/
413HWTEST_F(MathComplexApiTest, testConj, Function | MediumTest | Level1) {
414    int ret = TestConj();
415    ASSERT_EQ(ret, 0);
416}
417
418/**
419* @tc.number     SUB_KERNEL_MATH_COMPLEX_CONJF_0100
420* @tc.name       test conjf api
421* @tc.desc       [C- SOFTWARE -0100]
422*/
423HWTEST_F(MathComplexApiTest, testConjf, Function | MediumTest | Level1) {
424    int ret = TestConjf();
425    ASSERT_EQ(ret, 0);
426}
427
428/**
429* @tc.number     SUB_KERNEL_MATH_COMPLEX_CONJL_0100
430* @tc.name       test conjl api
431* @tc.desc       [C- SOFTWARE -0100]
432*/
433HWTEST_F(MathComplexApiTest, testConjl, Function | MediumTest | Level1) {
434    int ret = TestConjl();
435    ASSERT_EQ(ret, 0);
436}
437
438/**
439* @tc.number     SUB_KERNEL_MATH_COMPLEX_CPOW_0100
440* @tc.name       test cpow api
441* @tc.desc       [C- SOFTWARE -0100]
442*/
443HWTEST_F(MathComplexApiTest, TestCpow, Function | MediumTest | Level1) {
444    int ret = TestCpow();
445    ASSERT_EQ(ret, 0);
446}
447
448/**
449* @tc.number     SUB_KERNEL_MATH_COMPLEX_CPOWF_0100
450* @tc.name       test cpowf api
451* @tc.desc       [C- SOFTWARE -0100]
452*/
453HWTEST_F(MathComplexApiTest, TestCpowf, Function | MediumTest | Level1) {
454    int ret = TestCpowf();
455    ASSERT_EQ(ret, 0);
456}
457
458/**
459* @tc.number     SUB_KERNEL_MATH_COMPLEX_CPOWL_0100
460* @tc.name       test cpowl api
461* @tc.desc       [C- SOFTWARE -0100]
462*/
463HWTEST_F(MathComplexApiTest, TestCpowl, Function | MediumTest | Level1) {
464    int ret = TestCpowl();
465    ASSERT_EQ(ret, 0);
466}
467
468/**
469* @tc.number     SUB_KERNEL_MATH_COMPLEX_CPROJ_0100
470* @tc.name       test cproj api
471* @tc.desc       [C- SOFTWARE -0100]
472*/
473HWTEST_F(MathComplexApiTest, testCproj, Function | MediumTest | Level1) {
474    int ret = TestCproj();
475    ASSERT_EQ(ret, 0);
476}
477
478/**
479* @tc.number     SUB_KERNEL_MATH_COMPLEX_CPROJF_0100
480* @tc.name       test cprojf api
481* @tc.desc       [C- SOFTWARE -0100]
482*/
483HWTEST_F(MathComplexApiTest, testCprojf, Function | MediumTest | Level1) {
484    int ret = TestCprojf();
485    ASSERT_EQ(ret, 0);
486}
487
488/**
489* @tc.number     SUB_KERNEL_MATH_COMPLEX_CPROJL_0100
490* @tc.name       test cprofl api
491* @tc.desc       [C- SOFTWARE -0100]
492*/
493HWTEST_F(MathComplexApiTest, testCprojl, Function | MediumTest | Level1) {
494    int ret = TestCprojl();
495    ASSERT_EQ(ret, 0);
496}
497
498/**
499* @tc.number     SUB_KERNEL_MATH_COMPLEX_CREAL_0100
500* @tc.name       test creal api
501* @tc.desc       [C- SOFTWARE -0100]
502*/
503HWTEST_F(MathComplexApiTest, testCreal, Function | MediumTest | Level1) {
504    int ret = TestCreal();
505    ASSERT_EQ(ret, 0);
506}
507
508/**
509* @tc.number     SUB_KERNEL_MATH_COMPLEX_CREALF_0100
510* @tc.name       test crealf api
511* @tc.desc       [C- SOFTWARE -0100]
512*/
513HWTEST_F(MathComplexApiTest, testCrealf, Function | MediumTest | Level1) {
514    int ret = TestCrealf();
515    ASSERT_EQ(ret, 0);
516}
517
518/**
519* @tc.number     SUB_KERNEL_MATH_COMPLEX_CREALL_0100
520* @tc.name       test creall api
521* @tc.desc       [C- SOFTWARE -0100]
522*/
523HWTEST_F(MathComplexApiTest, testCreall, Function | MediumTest | Level1) {
524    int ret = TestCreall();
525    ASSERT_EQ(ret, 0);
526}
527
528/**
529* @tc.number     SUB_KERNEL_MATH_COMPLEX_CSIN_0100
530* @tc.name       test csin api
531* @tc.desc       [C- SOFTWARE -0100]
532*/
533HWTEST_F(MathComplexApiTest, testCsin, Function | MediumTest | Level1) {
534    int ret = TestCsin();
535    ASSERT_EQ(ret, 0);
536}
537
538/**
539* @tc.number     SUB_KERNEL_MATH_COMPLEX_CSINF_0100
540* @tc.name       test csinf api
541* @tc.desc       [C- SOFTWARE -0100]
542*/
543HWTEST_F(MathComplexApiTest, testCsinf, Function | MediumTest | Level1) {
544    int ret = TestCsinf();
545    ASSERT_EQ(ret, 0);
546}
547
548/**
549* @tc.number     SUB_KERNEL_MATH_COMPLEX_CSINH_0100
550* @tc.name       test csinh api
551* @tc.desc       [C- SOFTWARE -0100]
552*/
553HWTEST_F(MathComplexApiTest, testCsinh, Function | MediumTest | Level1) {
554    int ret = TestCsinh();
555    ASSERT_EQ(ret, 0);
556}
557
558/**
559* @tc.number     SUB_KERNEL_MATH_COMPLEX_CSINHF_0100
560* @tc.name       test csinhf api
561* @tc.desc       [C- SOFTWARE -0100]
562*/
563HWTEST_F(MathComplexApiTest, testCsinhf, Function | MediumTest | Level1) {
564    int ret = TestCsinhf();
565    ASSERT_EQ(ret, 0);
566}
567
568/**
569* @tc.number     SUB_KERNEL_MATH_COMPLEX_CSINHL_0100
570* @tc.name       test csinhl api
571* @tc.desc       [C- SOFTWARE -0100]
572*/
573HWTEST_F(MathComplexApiTest, testCsinhl, Function | MediumTest | Level1) {
574    int ret = TestCsinhl();
575    ASSERT_EQ(ret, 0);
576}
577
578/**
579* @tc.number     SUB_KERNEL_MATH_COMPLEX_CSINL_0100
580* @tc.name       test csinl api
581* @tc.desc       [C- SOFTWARE -0100]
582*/
583HWTEST_F(MathComplexApiTest, testCsinl, Function | MediumTest | Level1) {
584    int ret = TestCsinl();
585    ASSERT_EQ(ret, 0);
586}
587
588/**
589* @tc.number     SUB_KERNEL_MATH_COMPLEX_CSQRT_0100
590* @tc.name       test csqrt api
591* @tc.desc       [C- SOFTWARE -0100]
592*/
593HWTEST_F(MathComplexApiTest, testCsqrt, Function | MediumTest | Level1) {
594    int ret = TestCsqrt();
595    ASSERT_EQ(ret, 0);
596}
597
598/**
599* @tc.number     SUB_KERNEL_MATH_COMPLEX_CSQRTF_0100
600* @tc.name       test csqrtf api
601* @tc.desc       [C- SOFTWARE -0100]
602*/
603HWTEST_F(MathComplexApiTest, testCsqrtf, Function | MediumTest | Level1) {
604    int ret = TestCsqrtf();
605    ASSERT_EQ(ret, 0);
606}
607
608/**
609* @tc.number     SUB_KERNEL_MATH_COMPLEX_CSQRTL_0100
610* @tc.name       test csqrtl api
611* @tc.desc       [C- SOFTWARE -0100]
612*/
613HWTEST_F(MathComplexApiTest, testCsqrtl, Function | MediumTest | Level1) {
614    int ret = TestCsqrtl();
615    ASSERT_EQ(ret, 0);
616}
617
618/**
619* @tc.number     SUB_KERNEL_MATH_COMPLEX_CTAN_0100
620* @tc.name       test ctan api
621* @tc.desc       [C- SOFTWARE -0100]
622*/
623HWTEST_F(MathComplexApiTest, testCtan, Function | MediumTest | Level1) {
624    int ret = TestCtan();
625    ASSERT_EQ(ret, 0);
626}
627
628/**
629* @tc.number     SUB_KERNEL_MATH_COMPLEX_CTANF_0100
630* @tc.name       test ctanf api
631* @tc.desc       [C- SOFTWARE -0100]
632*/
633HWTEST_F(MathComplexApiTest, testCtanf, Function | MediumTest | Level1) {
634    int ret = TestCtanf();
635    ASSERT_EQ(ret, 0);
636}
637
638/**
639* @tc.number     SUB_KERNEL_MATH_COMPLEX_CTANH_0100
640* @tc.name       test ctanh api
641* @tc.desc       [C- SOFTWARE -0100]
642*/
643HWTEST_F(MathComplexApiTest, testCtanh, Function | MediumTest | Level1) {
644    int ret = TestCtanh();
645    ASSERT_EQ(ret, 0);
646}
647
648/**
649* @tc.number     SUB_KERNEL_MATH_COMPLEX_CTANHF_0100
650* @tc.name       test ctanhf api
651* @tc.desc       [C- SOFTWARE -0100]
652*/
653HWTEST_F(MathComplexApiTest, testCtanhf, Function | MediumTest | Level1) {
654    int ret = TestCtanhf();
655    ASSERT_EQ(ret, 0);
656}
657
658/**
659* @tc.number     SUB_KERNEL_MATH_COMPLEX_CTANHL_0100
660* @tc.name       test ctanhl api
661* @tc.desc       [C- SOFTWARE -0100]
662*/
663HWTEST_F(MathComplexApiTest, testCtanhl, Function | MediumTest | Level1) {
664    int ret = TestCtanhl();
665    ASSERT_EQ(ret, 0);
666}
667
668/**
669* @tc.number     SUB_KERNEL_MATH_COMPLEX_CTANL_0100
670* @tc.name       test ctanl api
671* @tc.desc       [C- SOFTWARE -0100]
672*/
673HWTEST_F(MathComplexApiTest, testCtanl, Function | MediumTest | Level1) {
674    int ret = TestCtanl();
675    ASSERT_EQ(ret, 0);
676}
677
678/**
679* @tc.number     SUB_KERNEL_MATH_COMPLEX_CACOSH_0100
680* @tc.name       test cacosh api
681* @tc.desc       [C- SOFTWARE -0100]
682*/
683HWTEST_F(MathComplexApiTest, testCacosh, Function | MediumTest | Level1) {
684    int ret = TestCacosh();
685    ASSERT_EQ(ret, 0);
686}