• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) Huawei Technologies Co., Ltd. 2020-2020. All rights reserved.
3  */
4 /*
5  * Copyright (c) 2021 Huawei Device Co., Ltd.
6  * Licensed under the Apache License, Version 2.0 (the "License");
7  * you may not use this file except in compliance with the License.
8  * You may obtain a copy of the License at
9  *
10  *     http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  */
18 
19 #include <ctype.h>
20 #include <math.h>
21 #include <stropts.h>
22 
23 #include "gtest/gtest.h"
24 #include "log.h"
25 #include "utils.h"
26 
27 using namespace testing::ext;
28 
29 class ActsUtilCheckApiTest : public testing::Test {
30 public:
31     locale_t g_aucaLocale;
32 protected:
33     // SetUpTestCase: Testsuit setup, run before 1st testcase
SetUpTestCase(void)34     static void SetUpTestCase(void)
35     {
36     }
37     // TearDownTestCase: Testsuit teardown, run after last testcase
TearDownTestCase(void)38     static void TearDownTestCase(void)
39     {
40     }
41     // Testcase setup
SetUp()42     virtual void SetUp()
43     {
44         g_aucaLocale = newlocale(LC_ALL_MASK, "", (locale_t)0);
45     }
46     // Testcase teardown
TearDown()47     virtual void TearDown()
48     {
49         freelocale(g_aucaLocale);
50     }
51 };
52 
53 /**
54 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISALNUM_0100
55 * @tc.name       test isalnum api with num
56 * @tc.desc       [C- SOFTWARE -0200]
57 */
58 HWTEST_F(ActsUtilCheckApiTest, testIsalnum0100, Function | MediumTest | Level1) {
59     int paraVal;
60     int returnVal;
61 
62     paraVal = '2';
63     returnVal = isalnum(paraVal);
64     LOGD("    isalnum returnVal:='%d'\n", returnVal);
65     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isalnum returnVal:='" << returnVal << "'";
66 }
67 
68 /**
69 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISALNUM_0200
70 * @tc.name       test isalnum api with lower alpha
71 * @tc.desc       [C- SOFTWARE -0200]
72 */
73 HWTEST_F(ActsUtilCheckApiTest, testIsalnum0200, Function | MediumTest | Level1) {
74     int paraVal;
75     int returnVal;
76 
77     paraVal = 'z';
78     returnVal = isalnum(paraVal);
79     LOGD("    isalnum returnVal:='%d'\n", returnVal);
80     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isalnum returnVal:='" << returnVal << "'";
81 }
82 
83 /**
84 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISALNUM_0300
85 * @tc.name       test isalnum api with upper alpha
86 * @tc.desc       [C- SOFTWARE -0200]
87 */
88 HWTEST_F(ActsUtilCheckApiTest, testIsalnum0300, Function | MediumTest | Level1) {
89     int paraVal;
90     int returnVal;
91 
92     paraVal = 'Z';
93     returnVal = isalnum(paraVal);
94     LOGD("    isalnum returnVal:='%d'\n", returnVal);
95     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isalnum returnVal:='" << returnVal << "'";
96 }
97 
98 /**
99 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISALNUM_0400
100 * @tc.name       test isalnum api with space
101 * @tc.desc       [C- SOFTWARE -0200]
102 */
103 HWTEST_F(ActsUtilCheckApiTest, testIsalnum0400, Function | MediumTest | Level1) {
104     int paraVal;
105     int returnVal;
106 
107     paraVal = ' ';
108     returnVal = isalnum(paraVal);
109     LOGD("    isalnum returnVal:='%d'\n", returnVal);
110     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isalnum returnVal:='" << returnVal << "'";
111 }
112 
113 /**
114 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISALNUM_0500
115 * @tc.name       test isalnum api with LF
116 * @tc.desc       [C- SOFTWARE -0200]
117 */
118 HWTEST_F(ActsUtilCheckApiTest, testIsalnum0500, Function | MediumTest | Level1) {
119     int paraVal;
120     int returnVal;
121 
122     paraVal = '\n';
123     returnVal = isalnum(paraVal);
124     LOGD("    isalnum returnVal:='%d'\n", returnVal);
125     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isalnum returnVal:='" << returnVal << "'";
126 }
127 
128 /**
129 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISALNUM_L_0600
130 * @tc.name       test isalnum_l api with num
131 * @tc.desc       [C- SOFTWARE -0200]
132 */
133 HWTEST_F(ActsUtilCheckApiTest, testIsalnumL0600, Function | MediumTest | Level1) {
134     int paraVal;
135     int returnVal;
136 
137     paraVal = '2';
138     returnVal = isalnum_l(paraVal, g_aucaLocale);
139     LOGD("    isalnum_l returnVal:='%d'\n", returnVal);
140     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isalnum_l returnVal:='" << returnVal << "'";
141 }
142 
143 /**
144 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISALNUM_L_0700
145 * @tc.name       test isalnum_l api with lower alpha
146 * @tc.desc       [C- SOFTWARE -0200]
147 */
148 HWTEST_F(ActsUtilCheckApiTest, testIsalnumL0700, Function | MediumTest | Level1) {
149     int paraVal;
150     int returnVal;
151 
152     paraVal = 'z';
153     returnVal = isalnum_l(paraVal, g_aucaLocale);
154     LOGD("    isalnum_l returnVal:='%d'\n", returnVal);
155     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isalnum_l returnVal:='" << returnVal << "'";
156 }
157 
158 /**
159 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISALNUM_L_0800
160 * @tc.name       test isalnum_l api with upper alpha
161 * @tc.desc       [C- SOFTWARE -0200]
162 */
163 HWTEST_F(ActsUtilCheckApiTest, testIsalnumL0800, Function | MediumTest | Level1) {
164     int paraVal;
165     int returnVal;
166 
167     paraVal = 'Z';
168     returnVal = isalnum_l(paraVal, g_aucaLocale);
169     LOGD("    isalnum_l returnVal:='%d'\n", returnVal);
170     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isalnum_l returnVal:='" << returnVal << "'";
171 }
172 
173 /**
174 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISALNUM_L_0900
175 * @tc.name       test isalnum_l api with space
176 * @tc.desc       [C- SOFTWARE -0200]
177 */
178 HWTEST_F(ActsUtilCheckApiTest, testIsalnumL0900, Function | MediumTest | Level1) {
179     int paraVal;
180     int returnVal;
181 
182     paraVal = ' ';
183     returnVal = isalnum_l(paraVal, g_aucaLocale);
184     LOGD("    isalnum_l returnVal:='%d'\n", returnVal);
185     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isalnum_l returnVal:='" << returnVal << "'";
186 }
187 
188 /**
189 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISALNUM_L_1000
190 * @tc.name       test isalnum_l api with LF
191 * @tc.desc       [C- SOFTWARE -0200]
192 */
193 HWTEST_F(ActsUtilCheckApiTest, testIsalnumL1000, Function | MediumTest | Level1) {
194     int paraVal;
195     int returnVal;
196 
197     paraVal = '\n';
198     returnVal = isalnum_l(paraVal, g_aucaLocale);
199     LOGD("    isalnum_l returnVal:='%d'\n", returnVal);
200     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isalnum_l returnVal:='" << returnVal << "'";
201 }
202 
203 /**
204 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISALPHA_1100
205 * @tc.name       test isalpha api with lower alpha
206 * @tc.desc       [C- SOFTWARE -0200]
207 */
208 HWTEST_F(ActsUtilCheckApiTest, testIsalpha1100, Function | MediumTest | Level1) {
209     int paraVal;
210     int returnVal;
211 
212     paraVal = 'z';
213     returnVal = isalpha(paraVal);
214     LOGD("    isalpha returnVal:='%d'\n", returnVal);
215     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isalpha returnVal:='" << returnVal << "'";
216 }
217 
218 /**
219 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISALPHA_1200
220 * @tc.name       test isalpha api with upper alpha
221 * @tc.desc       [C- SOFTWARE -0200]
222 */
223 HWTEST_F(ActsUtilCheckApiTest, testIsalpha1200, Function | MediumTest | Level1) {
224     int paraVal;
225     int returnVal;
226 
227     paraVal = 'Z';
228     returnVal = isalpha(paraVal);
229     LOGD("    isalpha returnVal:='%d'\n", returnVal);
230     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isalpha returnVal:='" << returnVal << "'";
231 }
232 
233 /**
234 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISALPHA_1300
235 * @tc.name       test isalpha api with space
236 * @tc.desc       [C- SOFTWARE -0200]
237 */
238 HWTEST_F(ActsUtilCheckApiTest, testIsalpha1300, Function | MediumTest | Level1) {
239     int paraVal;
240     int returnVal;
241 
242     paraVal = ' ';
243     returnVal = isalpha(paraVal);
244     LOGD("    isalpha returnVal:='%d'\n", returnVal);
245     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isalpha returnVal:='" << returnVal << "'";
246 }
247 
248 /**
249 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISALPHA_1400
250 * @tc.name       test isalpha api with LF
251 * @tc.desc       [C- SOFTWARE -0200]
252 */
253 HWTEST_F(ActsUtilCheckApiTest, testIsalpha1400, Function | MediumTest | Level1) {
254     int paraVal;
255     int returnVal;
256 
257     paraVal = '\n';
258     returnVal = isalpha(paraVal);
259     LOGD("    isalpha returnVal:='%d'\n", returnVal);
260     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isalpha returnVal:='" << returnVal << "'";
261 }
262 
263 /**
264 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISALPHA_L_1500
265 * @tc.name       test isalpha_l api with lower alpha
266 * @tc.desc       [C- SOFTWARE -0200]
267 */
268 HWTEST_F(ActsUtilCheckApiTest, testIsalphaL1500, Function | MediumTest | Level1) {
269     int paraVal;
270     int returnVal;
271 
272     paraVal = 'z';
273     returnVal = isalpha_l(paraVal, g_aucaLocale);
274     LOGD("    isalpha_l returnVal:='%d'\n", returnVal);
275     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isalpha_l returnVal:='" << returnVal << "'";
276 }
277 
278 /**
279 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISALPHA_L_1600
280 * @tc.name       test isalpha_l api with upper alpha
281 * @tc.desc       [C- SOFTWARE -0200]
282 */
283 HWTEST_F(ActsUtilCheckApiTest, testIsalphaL1600, Function | MediumTest | Level1) {
284     int paraVal;
285     int returnVal;
286 
287     paraVal = 'Z';
288     returnVal = isalpha_l(paraVal, g_aucaLocale);
289     LOGD("    isalpha_l returnVal:='%d'\n", returnVal);
290     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isalpha_l returnVal:='" << returnVal << "'";
291 }
292 
293 /**
294 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISALPHA_L_1700
295 * @tc.name       test isalpha_l api with space
296 * @tc.desc       [C- SOFTWARE -0200]
297 */
298 HWTEST_F(ActsUtilCheckApiTest, testIsalphaL1700, Function | MediumTest | Level1) {
299     int paraVal;
300     int returnVal;
301 
302     paraVal = ' ';
303     returnVal = isalpha_l(paraVal, g_aucaLocale);
304     LOGD("    isalpha_l returnVal:='%d'\n", returnVal);
305     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isalpha_l returnVal:='" << returnVal << "'";
306 }
307 
308 /**
309 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISALPHA_L_1800
310 * @tc.name       test isalpha_l api with LF
311 * @tc.desc       [C- SOFTWARE -0200]
312 */
313 HWTEST_F(ActsUtilCheckApiTest, testIsalphaL1800, Function | MediumTest | Level1) {
314     int paraVal;
315     int returnVal;
316 
317     paraVal = '\n';
318     returnVal = isalpha_l(paraVal, g_aucaLocale);
319     LOGD("    isalpha_l returnVal:='%d'\n", returnVal);
320     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isalpha_l returnVal:='" << returnVal << "'";
321 }
322 
323 /**
324 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISASCII_1900
325 * @tc.name       test isascii api with lower alpha
326 * @tc.desc       [C- SOFTWARE -0200]
327 */
328 HWTEST_F(ActsUtilCheckApiTest, testIsascii1900, Function | MediumTest | Level1) {
329     int paraVal;
330     int returnVal;
331 
332     paraVal = 'z';
333     returnVal = isascii(paraVal);
334     LOGD("    isascii returnVal:='%d'\n", returnVal);
335     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isascii returnVal:='" << returnVal << "'";
336 }
337 
338 /**
339 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISASCII_2000
340 * @tc.name       test isascii api with upper alpha
341 * @tc.desc       [C- SOFTWARE -0200]
342 */
343 HWTEST_F(ActsUtilCheckApiTest, testIsascii2000, Function | MediumTest | Level1) {
344     int paraVal;
345     int returnVal;
346 
347     paraVal = 'Z';
348     returnVal = isascii(paraVal);
349     LOGD("    isascii returnVal:='%d'\n", returnVal);
350     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isascii returnVal:='" << returnVal << "'";
351 }
352 
353 /**
354 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISASCII_2100
355 * @tc.name       test isascii api with special symbol
356 * @tc.desc       [C- SOFTWARE -0200]
357 */
358 HWTEST_F(ActsUtilCheckApiTest, testIsascii2100, Function | MediumTest | Level1) {
359     int paraVal;
360     int returnVal;
361 
362     paraVal = '~';
363     returnVal = isascii(paraVal);
364     LOGD("    isascii returnVal:='%d'\n", returnVal);
365     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isascii returnVal:='" << returnVal << "'";
366 }
367 
368 /**
369 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISASCII_2200
370 * @tc.name       test isascii api with digit
371 * @tc.desc       [C- SOFTWARE -0200]
372 */
373 HWTEST_F(ActsUtilCheckApiTest, testIsascii2200, Function | MediumTest | Level1) {
374     int paraVal;
375     int returnVal;
376 
377     paraVal = 128;
378     returnVal = isascii(paraVal);
379     LOGD("    isascii returnVal:='%d'\n", returnVal);
380     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isascii returnVal:='" << returnVal << "'";
381 }
382 
383 // /**
384 // * @tc.number     SUB_KERNEL_UTIL_CHECK_ISASTREAM_2300
385 // * @tc.name       test isastream api with digit
386 // * @tc.desc       [C- SOFTWARE -0200]
387 // */
388 // HWTEST_F(ActsUtilCheckApiTest, testIsastream2300, Function | MediumTest | Level1) {
389 //     int paraVal;
390 //     int returnVal;
391 
392 //     paraVal = 128;
393 //     ASSERT_TRUE(-1 == returnVal) << "ErrInfo: isastream returnVal:='" << returnVal << "'";
394 // }
395 
396 /**
397 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISATTY_2400
398 * @tc.name       test isatty api with digit
399 * @tc.desc       [C- SOFTWARE -0200]
400 */
401 HWTEST_F(ActsUtilCheckApiTest, testIsatty2400, Function | MediumTest | Level1) {
402     int paraVal;
403     int returnVal;
404 
405     paraVal = 128;
406     returnVal = isatty(paraVal);
407     LOGD("    isatty returnVal:='%d'\n", returnVal);
408     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isatty returnVal:='" << returnVal << "'";
409 }
410 
411 /**
412 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISBLANK_2500
413 * @tc.name       test isblank api with space
414 * @tc.desc       [C- SOFTWARE -0200]
415 */
416 HWTEST_F(ActsUtilCheckApiTest, testIsblank2500, Function | MediumTest | Level1) {
417     int paraVal;
418     int returnVal;
419 
420     paraVal = ' ';
421     returnVal = isblank(paraVal);
422     LOGD("    isblank returnVal:='%d'\n", returnVal);
423     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isblank returnVal:='" << returnVal << "'";
424 }
425 
426 /**
427 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISBLANK_2600
428 * @tc.name       test isblank api with upper alpha
429 * @tc.desc       [C- SOFTWARE -0200]
430 */
431 HWTEST_F(ActsUtilCheckApiTest, testIsblank2600, Function | MediumTest | Level1) {
432     int paraVal;
433     int returnVal;
434 
435     paraVal = 'A';
436     returnVal = isblank(paraVal);
437     LOGD("    isblank returnVal:='%d'\n", returnVal);
438     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isblank returnVal:='" << returnVal << "'";
439 }
440 
441 /**
442 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISBLANK_L_2700
443 * @tc.name       test isblank_l api with space
444 * @tc.desc       [C- SOFTWARE -0200]
445 */
446 HWTEST_F(ActsUtilCheckApiTest, testIsblankL2700, Function | MediumTest | Level1) {
447     int paraVal;
448     int returnVal;
449 
450     paraVal = ' ';
451     returnVal = isblank_l(paraVal, g_aucaLocale);
452     LOGD("    isblank_l returnVal:='%d'\n", returnVal);
453     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isblank_l returnVal:='" << returnVal << "'";
454 }
455 
456 /**
457 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISBLANK_L_2800
458 * @tc.name       test isblank_l api with upper alpha
459 * @tc.desc       [C- SOFTWARE -0200]
460 */
461 HWTEST_F(ActsUtilCheckApiTest, testIsblankL2800, Function | MediumTest | Level1) {
462     int paraVal;
463     int returnVal;
464 
465     paraVal = 'A';
466     returnVal = isblank_l(paraVal, g_aucaLocale);
467     LOGD("    isblank_l returnVal:='%d'\n", returnVal);
468     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isblank_l returnVal:='" << returnVal << "'";
469 }
470 
471 /**
472 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISCNTRL_2900
473 * @tc.name       test iscntrl api with LF
474 * @tc.desc       [C- SOFTWARE -0200]
475 */
476 HWTEST_F(ActsUtilCheckApiTest, testIscntrl2900, Function | MediumTest | Level1) {
477     int paraVal;
478     int returnVal;
479 
480     paraVal = '\n';
481     returnVal = iscntrl(paraVal);
482     LOGD("    iscntrl returnVal:='%d'\n", returnVal);
483     ASSERT_TRUE(returnVal != 0) << "ErrInfo: iscntrl returnVal:='" << returnVal << "'";
484 }
485 
486 /**
487 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISCNTRL_3000
488 * @tc.name       test iscntrl api with upper alpha
489 * @tc.desc       [C- SOFTWARE -0200]
490 */
491 HWTEST_F(ActsUtilCheckApiTest, testIscntrl3000, Function | MediumTest | Level1) {
492     int paraVal;
493     int returnVal;
494 
495     paraVal = 'A';
496     returnVal = iscntrl(paraVal);
497     LOGD("    iscntrl returnVal:='%d'\n", returnVal);
498     ASSERT_TRUE(0 == returnVal) << "ErrInfo: iscntrl returnVal:='" << returnVal << "'";
499 }
500 
501 /**
502 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISCNTRL_L_3100
503 * @tc.name       test iscntrl_l api with LF
504 * @tc.desc       [C- SOFTWARE -0200]
505 */
506 HWTEST_F(ActsUtilCheckApiTest, testIscntrlL3100, Function | MediumTest | Level1) {
507     int paraVal;
508     int returnVal;
509 
510     paraVal = '\n';
511     returnVal = iscntrl_l(paraVal, g_aucaLocale);
512     LOGD("    iscntrl_l returnVal:='%d'\n", returnVal);
513     ASSERT_TRUE(returnVal != 0) << "ErrInfo: iscntrl_l returnVal:='" << returnVal << "'";
514 }
515 
516 /**
517 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISCNTRL_L_3200
518 * @tc.name       test iscntrl_l api with upper alpha
519 * @tc.desc       [C- SOFTWARE -0200]
520 */
521 HWTEST_F(ActsUtilCheckApiTest, testIscntrlL3200, Function | MediumTest | Level1) {
522     int paraVal;
523     int returnVal;
524 
525     paraVal = 'A';
526     returnVal = iscntrl_l(paraVal, g_aucaLocale);
527     LOGD("    iscntrl_l returnVal:='%d'\n", returnVal);
528     ASSERT_TRUE(0 == returnVal) << "ErrInfo: iscntrl_l returnVal:='" << returnVal << "'";
529 }
530 
531 /**
532 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISDIGIT_3300
533 * @tc.name       test isdigit api with digit
534 * @tc.desc       [C- SOFTWARE -0200]
535 */
536 HWTEST_F(ActsUtilCheckApiTest, testIsdigit3300, Function | MediumTest | Level1) {
537     int paraVal;
538     int returnVal;
539 
540     paraVal = '3';
541     returnVal = isdigit(paraVal);
542     LOGD("    isdigit returnVal:='%d'\n", returnVal);
543     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isdigit returnVal:='" << returnVal << "'";
544 }
545 
546 /**
547 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISDIGIT_3400
548 * @tc.name       test isdigit api with lower alpha
549 * @tc.desc       [C- SOFTWARE -0200]
550 */
551 HWTEST_F(ActsUtilCheckApiTest, testIsdigitl3400, Function | MediumTest | Level1) {
552     int paraVal;
553     int returnVal;
554 
555     paraVal = 'a';
556     returnVal = isdigit(paraVal);
557     LOGD("    isdigit returnVal:='%d'\n", returnVal);
558     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isdigit returnVal:='" << returnVal << "'";
559 }
560 
561 /**
562 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISDIGIT_3500
563 * @tc.name       test isdigit api with LF
564 * @tc.desc       [C- SOFTWARE -0200]
565 */
566 HWTEST_F(ActsUtilCheckApiTest, testIsdigitl3500, Function | MediumTest | Level1) {
567     int paraVal;
568     int returnVal;
569 
570     paraVal = '\n';
571     returnVal = isdigit(paraVal);
572     LOGD("    isdigit returnVal:='%d'\n", returnVal);
573     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isdigit returnVal:='" << returnVal << "'";
574 }
575 
576 /**
577 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISDIGIT_3600
578 * @tc.name       test isdigit api with space
579 * @tc.desc       [C- SOFTWARE -0200]
580 */
581 HWTEST_F(ActsUtilCheckApiTest, testIsdigit3600, Function | MediumTest | Level1) {
582     int paraVal;
583     int returnVal;
584 
585     paraVal = ' ';
586     returnVal = isdigit(paraVal);
587     LOGD("    isdigit returnVal:='%d'\n", returnVal);
588     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isdigit returnVal:='" << returnVal << "'";
589 }
590 
591 /**
592 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISDIGIT_L_3700
593 * @tc.name       test isdigit_l api with digit
594 * @tc.desc       [C- SOFTWARE -0200]
595 */
596 HWTEST_F(ActsUtilCheckApiTest, testIsdigitL3700, Function | MediumTest | Level1) {
597     int paraVal;
598     int returnVal;
599 
600     paraVal = '3';
601     returnVal = isdigit_l(paraVal, g_aucaLocale);
602     LOGD("    isdigit_l returnVal:='%d'\n", returnVal);
603     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isdigit_l returnVal:='" << returnVal << "'";
604 }
605 
606 /**
607 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISDIGIT_L_3800
608 * @tc.name       test isdigit_l api with lower alpha
609 * @tc.desc       [C- SOFTWARE -0200]
610 */
611 HWTEST_F(ActsUtilCheckApiTest, testIsdigitlL3800, Function | MediumTest | Level1) {
612     int paraVal;
613     int returnVal;
614 
615     paraVal = 'a';
616     returnVal = isdigit_l(paraVal, g_aucaLocale);
617     LOGD("    isdigit_l returnVal:='%d'\n", returnVal);
618     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isdigit_l returnVal:='" << returnVal << "'";
619 }
620 
621 /**
622 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISDIGIT_L_3900
623 * @tc.name       test isdigit_l api with LF
624 * @tc.desc       [C- SOFTWARE -0200]
625 */
626 HWTEST_F(ActsUtilCheckApiTest, testIsdigitlL3900, Function | MediumTest | Level1) {
627     int paraVal;
628     int returnVal;
629 
630     paraVal = '\n';
631     returnVal = isdigit_l(paraVal, g_aucaLocale);
632     LOGD("    isdigit_l returnVal:='%d'\n", returnVal);
633     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isdigit_l returnVal:='" << returnVal << "'";
634 }
635 
636 /**
637 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISDIGIT_L_4000
638 * @tc.name       test isdigit_l api with space
639 * @tc.desc       [C- SOFTWARE -0200]
640 */
641 HWTEST_F(ActsUtilCheckApiTest, testIsdigitL4000, Function | MediumTest | Level1) {
642     int paraVal;
643     int returnVal;
644 
645     paraVal = ' ';
646     returnVal = isdigit_l(paraVal, g_aucaLocale);
647     LOGD("    isdigit_l returnVal:='%d'\n", returnVal);
648     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isdigit_l returnVal:='" << returnVal << "'";
649 }
650 
651 /**
652 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISFINITE_4100
653 * @tc.name       test isfinite api with space
654 * @tc.desc       [C- SOFTWARE -0200]
655 */
656 HWTEST_F(ActsUtilCheckApiTest, testIsfinite4100, Function | MediumTest | Level1) {
657     double paraVal;
658     int returnVal;
659 
660     paraVal = ' ';
661     returnVal = isfinite(paraVal);
662     LOGD("    isfinite returnVal:='%d'\n", returnVal);
663     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isfinite returnVal:='" << returnVal << "'";
664 }
665 
666 /**
667 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISFINITE_4200
668 * @tc.name       test isfinite api with decimal double
669 * @tc.desc       [C- SOFTWARE -0200]
670 */
671 HWTEST_F(ActsUtilCheckApiTest, testIsfinite4200, Function | MediumTest | Level1) {
672     double paraVal;
673     int returnVal;
674 
675     paraVal = 3.1415926;
676     returnVal = isfinite(paraVal);
677     LOGD("    isfinite returnVal:='%d'\n", returnVal);
678     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isfinite returnVal:='" << returnVal << "'";
679 }
680 
681 /**
682 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISFINITE_4300
683 * @tc.name       test isfinite api with exponent double
684 * @tc.desc       [C- SOFTWARE -0200]
685 */
686 HWTEST_F(ActsUtilCheckApiTest, testIsfinite4300, Function | MediumTest | Level1) {
687     double paraVal;
688     int returnVal;
689 
690     paraVal = 1.26e3;
691     returnVal = isfinite(paraVal);
692     LOGD("    isfinite returnVal:='%d'\n", returnVal);
693     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isfinite returnVal:='" << returnVal << "'";
694 }
695 
696 /**
697 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISGRAPH_4400
698 * @tc.name       test isgraph api with upper alpha
699 * @tc.desc       [C- SOFTWARE -0200]
700 */
701 HWTEST_F(ActsUtilCheckApiTest, testIsgraph4400, Function | MediumTest | Level1) {
702     double paraVal;
703     int returnVal;
704 
705     paraVal = 'A';
706     returnVal = isgraph(paraVal);
707     LOGD("    isgraph returnVal:='%d'\n", returnVal);
708     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isgraph returnVal:='" << returnVal << "'";
709 }
710 
711 /**
712 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISGRAPH_4500
713 * @tc.name       test isgraph api with lower alpha
714 * @tc.desc       [C- SOFTWARE -0200]
715 */
716 HWTEST_F(ActsUtilCheckApiTest, testIsgraph4500, Function | MediumTest | Level1) {
717     double paraVal;
718     int returnVal;
719 
720     paraVal = 'z';
721     returnVal = isgraph(paraVal);
722     LOGD("    isgraph returnVal:='%d'\n", returnVal);
723     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isgraph returnVal:='" << returnVal << "'";
724 }
725 
726 /**
727 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISGRAPH_4600
728 * @tc.name       test isgraph api with LF
729 * @tc.desc       [C- SOFTWARE -0200]
730 */
731 HWTEST_F(ActsUtilCheckApiTest, testIsgraph4600, Function | MediumTest | Level1) {
732     double paraVal;
733     int returnVal;
734 
735     paraVal = '\n';
736     returnVal = isgraph(paraVal);
737     LOGD("    isgraph returnVal:='%d'\n", returnVal);
738     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isgraph returnVal:='" << returnVal << "'";
739 }
740 
741 /**
742 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISGRAPH_4700
743 * @tc.name       test isgraph api with space
744 * @tc.desc       [C- SOFTWARE -0200]
745 */
746 HWTEST_F(ActsUtilCheckApiTest, testIsgraph4700, Function | MediumTest | Level1) {
747     double paraVal;
748     int returnVal;
749 
750     paraVal = ' ';
751     returnVal = isgraph(paraVal);
752     LOGD("    isgraph returnVal:='%d'\n", returnVal);
753     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isgraph returnVal:='" << returnVal << "'";
754 }
755 
756 /**
757 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISGRAPH_L_4800
758 * @tc.name       test isgraph_l api with upper alpha
759 * @tc.desc       [C- SOFTWARE -0200]
760 */
761 HWTEST_F(ActsUtilCheckApiTest, testIsgraphL4800, Function | MediumTest | Level1) {
762     double paraVal;
763     int returnVal;
764 
765     paraVal = 'A';
766     returnVal = isgraph_l(paraVal, g_aucaLocale);
767     LOGD("    isgraph returnVal:='%d'\n", returnVal);
768     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isgraph returnVal:='" << returnVal << "'";
769 }
770 
771 /**
772 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISGRAPH_L_4900
773 * @tc.name       test isgraph_l api with lower alpha
774 * @tc.desc       [C- SOFTWARE -0200]
775 */
776 HWTEST_F(ActsUtilCheckApiTest, testIsgraphL4900, Function | MediumTest | Level1) {
777     double paraVal;
778     int returnVal;
779 
780     paraVal = 'z';
781     returnVal = isgraph_l(paraVal, g_aucaLocale);
782     LOGD("    isgraph returnVal:='%d'\n", returnVal);
783     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isgraph returnVal:='" << returnVal << "'";
784 }
785 
786 /**
787 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISGRAPH_L_5000
788 * @tc.name       test isgraph_l api with LF
789 * @tc.desc       [C- SOFTWARE -0200]
790 */
791 HWTEST_F(ActsUtilCheckApiTest, testIsgraphL5000, Function | MediumTest | Level1) {
792     double paraVal;
793     int returnVal;
794 
795     paraVal = '\n';
796     returnVal = isgraph_l(paraVal, g_aucaLocale);
797     LOGD("    isgraph returnVal:='%d'\n", returnVal);
798     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isgraph returnVal:='" << returnVal << "'";
799 }
800 
801 /**
802 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISGRAPH_L_5100
803 * @tc.name       test isgraph_l api with space
804 * @tc.desc       [C- SOFTWARE -0200]
805 */
806 HWTEST_F(ActsUtilCheckApiTest, testIsgraphL5100, Function | MediumTest | Level1) {
807     double paraVal;
808     int returnVal;
809 
810     paraVal = ' ';
811     returnVal = isgraph_l(paraVal, g_aucaLocale);
812     LOGD("    isgraph returnVal:='%d'\n", returnVal);
813     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isgraph returnVal:='" << returnVal << "'";
814 }
815 
816 /**
817 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISGREATER_5200
818 * @tc.name       test isgreater api para1 is less than para2
819 * @tc.desc       [C- SOFTWARE -0200]
820 */
821 HWTEST_F(ActsUtilCheckApiTest, testIsgreater5200, Function | MediumTest | Level1) {
822     double paraVal1;
823     double paraVal2;
824     int returnVal;
825 
826     paraVal1 = 1.1;
827     paraVal2 = 2.1;
828     returnVal = isgreater(paraVal1, paraVal2);
829     LOGD("    isgreater returnVal:='%d'\n", returnVal);
830     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isgreater returnVal:='" << returnVal << "'";
831 }
832 
833 /**
834 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISGREATER_5300
835 * @tc.name       test isgreater api para1 is greater than para2
836 * @tc.desc       [C- SOFTWARE -0200]
837 */
838 HWTEST_F(ActsUtilCheckApiTest, testIsgreater5300, Function | MediumTest | Level1) {
839     double paraVal1;
840     double paraVal2;
841     int returnVal;
842 
843     paraVal1 = 2.1;
844     paraVal2 = 1.1;
845     returnVal = isgreater(paraVal1, paraVal2);
846     LOGD("    isgreater returnVal:='%d'\n", returnVal);
847     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isgreater returnVal:='" << returnVal << "'";
848 }
849 
850 /**
851 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISGREATER_5400
852 * @tc.name       test isgreater api para1 is equal to para2
853 * @tc.desc       [C- SOFTWARE -0200]
854 */
855 HWTEST_F(ActsUtilCheckApiTest, testIsgreater5400, Function | MediumTest | Level1) {
856     double paraVal1;
857     double paraVal2;
858     int returnVal;
859 
860     paraVal1 = 2.1;
861     paraVal2 = 2.1;
862     returnVal = isgreater(paraVal1, paraVal2);
863     LOGD("    isgreater returnVal:='%d'\n", returnVal);
864     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isgreater returnVal:='" << returnVal << "'";
865 }
866 
867 /**
868 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISGREATEREQUAL_5500
869 * @tc.name       test isgreaterequal api para1 is less than para2
870 * @tc.desc       [C- SOFTWARE -0200]
871 */
872 HWTEST_F(ActsUtilCheckApiTest, testIsgreaterequal5500, Function | MediumTest | Level1) {
873     double paraVal1;
874     double paraVal2;
875     int returnVal;
876 
877     paraVal1 = 1.1;
878     paraVal2 = 2.1;
879     returnVal = isgreaterequal(paraVal1, paraVal2);
880     LOGD("    isgreaterequal returnVal:='%d'\n", returnVal);
881     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isgreaterequal returnVal:='" << returnVal << "'";
882 }
883 
884 /**
885 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISGREATEREQUAL_5600
886 * @tc.name       test isgreaterequal api para1 is greater than para2
887 * @tc.desc       [C- SOFTWARE -0200]
888 */
889 HWTEST_F(ActsUtilCheckApiTest, testIsgreaterequal5600, Function | MediumTest | Level1) {
890     double paraVal1;
891     double paraVal2;
892     int returnVal;
893 
894     paraVal1 = 2.1;
895     paraVal2 = 1.1;
896     returnVal = isgreaterequal(paraVal1, paraVal2);
897     LOGD("    isgreaterequal returnVal:='%d'\n", returnVal);
898     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isgreaterequal returnVal:='" << returnVal << "'";
899 }
900 
901 /**
902 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISGREATEREQUAL_5700
903 * @tc.name       test isgreaterequal api para1 is equal to para2
904 * @tc.desc       [C- SOFTWARE -0200]
905 */
906 HWTEST_F(ActsUtilCheckApiTest, testIsgreaterequal5700, Function | MediumTest | Level1) {
907     double paraVal1;
908     double paraVal2;
909     int returnVal;
910 
911     paraVal1 = 2.1;
912     paraVal2 = 2.1;
913     returnVal = isgreaterequal(paraVal1, paraVal2);
914     LOGD("    isgreaterequal returnVal:='%d'\n", returnVal);
915     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isgreaterequal returnVal:='" << returnVal << "'";
916 }
917 
918 /**
919 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISINF_5800
920 * @tc.name       test isinf api with INFINITY
921 * @tc.desc       [C- SOFTWARE -0200]
922 */
923 HWTEST_F(ActsUtilCheckApiTest, testIsinf5800, Function | MediumTest | Level1) {
924     double paraVal;
925     int returnVal;
926 
927     paraVal = INFINITY;
928     returnVal = isinf(paraVal);
929     LOGD("    isinf returnVal:='%d'\n", returnVal);
930     ASSERT_TRUE(1 == returnVal) << "ErrInfo: isinf  returnVal:='" << returnVal << "'";
931 }
932 
933 /**
934 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISLESSEQUAL_5900
935 * @tc.name       test islessequal api para1 is less than para2
936 * @tc.desc       [C- SOFTWARE -0200]
937 */
938 HWTEST_F(ActsUtilCheckApiTest, testIslessequal5900, Function | MediumTest | Level1) {
939     double paraVal1;
940     double paraVal2;
941     int returnVal;
942 
943     paraVal1 = 1.1;
944     paraVal2 = 2.1;
945     returnVal = islessequal(paraVal1, paraVal2);
946     LOGD("    islessequal returnVal:='%d'\n", returnVal);
947     ASSERT_TRUE(0 != returnVal) << "ErrInfo: islessequal returnVal:='" << returnVal << "'";
948 }
949 
950 /**
951 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISLESSEQUAL_6000
952 * @tc.name       test islessequal api para1 is greater than para2
953 * @tc.desc       [C- SOFTWARE -0200]
954 */
955 HWTEST_F(ActsUtilCheckApiTest, testIslessequal6000, Function | MediumTest | Level1) {
956     double paraVal1;
957     double paraVal2;
958     int returnVal;
959 
960     paraVal1 = 2.1;
961     paraVal2 = 1.1;
962     returnVal = islessequal(paraVal1, paraVal2);
963     LOGD("    islessequal returnVal:='%d'\n", returnVal);
964     ASSERT_TRUE(0 == returnVal) << "ErrInfo: islessequal returnVal:='" << returnVal << "'";
965 }
966 
967 /**
968 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISLESSEQUAL_6100
969 * @tc.name       test islessequal api para1 is equal to para2
970 * @tc.desc       [C- SOFTWARE -0200]
971 */
972 HWTEST_F(ActsUtilCheckApiTest, testIslessequal6100, Function | MediumTest | Level1) {
973     double paraVal1;
974     double paraVal2;
975     int returnVal;
976 
977     paraVal1 = 2.1;
978     paraVal2 = 2.1;
979     returnVal = islessequal(paraVal1, paraVal2);
980     LOGD("    islessequal returnVal:='%d'\n", returnVal);
981     ASSERT_TRUE(returnVal != 0) << "ErrInfo: islessequal returnVal:='" << returnVal << "'";
982 }
983 
984 /**
985 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISLESSGREATER_6200
986 * @tc.name       test islessgreater api para1 is equal to para2
987 * @tc.desc       [C- SOFTWARE -0200]
988 */
989 HWTEST_F(ActsUtilCheckApiTest, testIslessgreater6200, Function | MediumTest | Level1) {
990     double paraVal1;
991     double paraVal2;
992     int returnVal;
993 
994     paraVal1 = 2.1;
995     paraVal2 = 2.1;
996     returnVal = islessgreater(paraVal1, paraVal2);
997     LOGD("    islessgreater returnVal:='%d'\n", returnVal);
998     ASSERT_TRUE(0 == returnVal) << "ErrInfo: islessgreater returnVal:='" << returnVal << "'";
999 }
1000 
1001 /**
1002 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISLESSGREATER_6300
1003 * @tc.name       test islessgreater api para1 is less than para2
1004 * @tc.desc       [C- SOFTWARE -0200]
1005 */
1006 HWTEST_F(ActsUtilCheckApiTest, testIslessgreater6300, Function | MediumTest | Level1) {
1007     double paraVal1;
1008     double paraVal2;
1009     int returnVal;
1010 
1011     paraVal1 = 1.1;
1012     paraVal2 = 2.1;
1013     returnVal = islessgreater(paraVal1, paraVal2);
1014     LOGD("    islessgreater returnVal:='%d'\n", returnVal);
1015     ASSERT_TRUE(returnVal != 0) << "ErrInfo: islessgreater returnVal:='" << returnVal << "'";
1016 }
1017 
1018 /**
1019 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISLESSGREATER_6400
1020 * @tc.name       test islessgreater api para1 is greater than para2
1021 * @tc.desc       [C- SOFTWARE -0200]
1022 */
1023 HWTEST_F(ActsUtilCheckApiTest, testIslessgreater6400, Function | MediumTest | Level1) {
1024     double paraVal1;
1025     double paraVal2;
1026     int returnVal;
1027 
1028     paraVal1 = 3.1;
1029     paraVal2 = 2.1;
1030     returnVal = islessgreater(paraVal1, paraVal2);
1031     LOGD("    islessgreater returnVal:='%d'\n", returnVal);
1032     ASSERT_TRUE(returnVal != 0) << "ErrInfo: islessgreater returnVal:='" << returnVal << "'";
1033 }
1034 
1035 /**
1036 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISLOWER_6500
1037 * @tc.name       test islower api with upper alpha
1038 * @tc.desc       [C- SOFTWARE -0200]
1039 */
1040 HWTEST_F(ActsUtilCheckApiTest, testIslower6500, Function | MediumTest | Level1) {
1041     char paraChar;
1042     int returnVal;
1043 
1044     paraChar = 'A';
1045     returnVal = islower(paraChar);
1046     LOGD("    islower c:='%c',   returnVal:='%c'\n", paraChar, returnVal);
1047     ASSERT_TRUE(0 == returnVal) << "ErrInfo: islower c:='" << paraChar << "',   returnVal:='" << returnVal << "'";
1048 }
1049 
1050 /**
1051 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISLOWER_6600
1052 * @tc.name       test islower api with lower alpha
1053 * @tc.desc       [C- SOFTWARE -0200]
1054 */
1055 HWTEST_F(ActsUtilCheckApiTest, testIslower6600, Function | MediumTest | Level1) {
1056     char paraChar;
1057     int returnVal;
1058 
1059     paraChar = 'a';
1060     returnVal = islower(paraChar);
1061     LOGD("    islower c:='%c',   returnVal:='%c'\n", paraChar, returnVal);
1062     ASSERT_TRUE(returnVal != 0) << "ErrInfo: islower c:='" << paraChar << "',   returnVal:='" << returnVal << "'";
1063 }
1064 
1065 /**
1066 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISLOWER_6700
1067 * @tc.name       test islower api with digit
1068 * @tc.desc       [C- SOFTWARE -0200]
1069 */
1070 HWTEST_F(ActsUtilCheckApiTest, testIslower6700, Function | MediumTest | Level1) {
1071     char paraChar;
1072     int returnVal;
1073 
1074     paraChar = '5';
1075     returnVal = islower(paraChar);
1076     LOGD("    islower c:='%c',   returnVal:='%c'\n", paraChar, returnVal);
1077     ASSERT_TRUE(0 == returnVal) << "ErrInfo: islower c:='" << paraChar << "',   returnVal:='" << returnVal << "'";
1078 }
1079 
1080 /**
1081 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISLOWER_6800
1082 * @tc.name       test islower api with space
1083 * @tc.desc       [C- SOFTWARE -0200]
1084 */
1085 HWTEST_F(ActsUtilCheckApiTest, testIslower6800, Function | MediumTest | Level1) {
1086     char paraChar;
1087     int returnVal;
1088 
1089     paraChar = ' ';
1090     returnVal = islower(paraChar);
1091     LOGD("    islower c:='%c',   returnVal:='%c'\n", paraChar, returnVal);
1092     ASSERT_TRUE(0 == returnVal) << "ErrInfo: islower c:='" << paraChar << "',   returnVal:='" << returnVal << "'";
1093 }
1094 
1095 /**
1096 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISLOWER_L_6900
1097 * @tc.name       test islower_l api with upper alpha
1098 * @tc.desc       [C- SOFTWARE -0200]
1099 */
1100 HWTEST_F(ActsUtilCheckApiTest, testIslowerL6900, Function | MediumTest | Level1) {
1101     char paraChar;
1102     int returnVal;
1103 
1104     paraChar = 'A';
1105     returnVal = islower_l(paraChar, g_aucaLocale);
1106     LOGD("    islower_l c:='%c',   returnVal:='%c'\n", paraChar, returnVal);
1107     ASSERT_TRUE(0 == returnVal) << "ErrInfo: islower_l c:='" << paraChar << "',   returnVal:='" << returnVal << "'";
1108 }
1109 
1110 /**
1111 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISLOWER_L_7000
1112 * @tc.name       test islower_l api with lower alpha
1113 * @tc.desc       [C- SOFTWARE -0200]
1114 */
1115 HWTEST_F(ActsUtilCheckApiTest, testIslowerL7000, Function | MediumTest | Level1) {
1116     char paraChar;
1117     int returnVal;
1118 
1119     paraChar = 'a';
1120     returnVal = islower_l(paraChar, g_aucaLocale);
1121     LOGD("    islower_l c:='%c',   returnVal:='%c'\n", paraChar, returnVal);
1122     ASSERT_TRUE(returnVal != 0) << "ErrInfo: islower_l c:='" << paraChar << "',   returnVal:='" << returnVal << "'";
1123 }
1124 
1125 /**
1126 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISLOWER_L_7100
1127 * @tc.name       test islower_l api with digit
1128 * @tc.desc       [C- SOFTWARE -0200]
1129 */
1130 HWTEST_F(ActsUtilCheckApiTest, testIslowerL7100, Function | MediumTest | Level1) {
1131     char paraChar;
1132     int returnVal;
1133 
1134     paraChar = '5';
1135     returnVal = islower_l(paraChar, g_aucaLocale);
1136     LOGD("    islower_l c:='%c',   returnVal:='%c'\n", paraChar, returnVal);
1137     ASSERT_TRUE(0 == returnVal) << "ErrInfo: islower_l c:='" << paraChar << "',   returnVal:='" << returnVal << "'";
1138 }
1139 
1140 /**
1141 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISLOWER_L_7200
1142 * @tc.name       test islower_l api with space
1143 * @tc.desc       [C- SOFTWARE -0200]
1144 */
1145 HWTEST_F(ActsUtilCheckApiTest, testIslowerL7200, Function | MediumTest | Level1) {
1146     char paraChar;
1147     int returnVal;
1148 
1149     paraChar = ' ';
1150     returnVal = islower_l(paraChar, g_aucaLocale);
1151     LOGD("    islower_l c:='%c',   returnVal:='%c'\n", paraChar, returnVal);
1152     ASSERT_TRUE(0 == returnVal) << "ErrInfo: islower_l c:='" << paraChar << "',   returnVal:='" << returnVal << "'";
1153 }
1154 
1155 /**
1156 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISNAN_7300
1157 * @tc.name       test isnan api with NAN
1158 * @tc.desc       [C- SOFTWARE -0200]
1159 */
1160 HWTEST_F(ActsUtilCheckApiTest, testIsnan7300, Function | MediumTest | Level1) {
1161     double paraVal;
1162     int returnVal;
1163 
1164     paraVal = NAN;
1165     returnVal = isnan(paraVal);
1166     LOGD("    isnan returnVal:='%d'\n", returnVal);
1167     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isnan  returnVal:='" << returnVal << "'";
1168 }
1169 
1170 /**
1171 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISNORMAL_7400
1172 * @tc.name       test isnormal api with FP_NORMAL
1173 * @tc.desc       [C- SOFTWARE -0200]
1174 */
1175 HWTEST_F(ActsUtilCheckApiTest, testIsnormal7400, Function | MediumTest | Level1) {
1176     double paraVal;
1177     int returnVal;
1178 
1179     paraVal = FP_NORMAL;
1180     returnVal = isnormal(paraVal);
1181     LOGD("    isnormal returnVal:='%d'\n", returnVal);
1182     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isnormal  returnVal:='" << returnVal << "'";
1183 }
1184 
1185 /**
1186 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISNORMAL_7500
1187 * @tc.name       test isnormal api with NAN
1188 * @tc.desc       [C- SOFTWARE -0200]
1189 */
1190 HWTEST_F(ActsUtilCheckApiTest, testIsnormal7500, Function | MediumTest | Level1) {
1191     double paraVal;
1192     int returnVal;
1193 
1194     paraVal = NAN;
1195     returnVal = isnormal(paraVal);
1196     LOGD("    isnormal returnVal:='%d'\n", returnVal);
1197     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isnormal  returnVal:='" << returnVal << "'";
1198 }
1199 
1200 /**
1201 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISNORMAL_7600
1202 * @tc.name       test isnormal api with double
1203 * @tc.desc       [C- SOFTWARE -0200]
1204 */
1205 HWTEST_F(ActsUtilCheckApiTest, testIsnormal7600, Function | MediumTest | Level1) {
1206     double paraVal;
1207     int returnVal;
1208 
1209     paraVal = 2.1;
1210     returnVal = isnormal(paraVal);
1211     LOGD("    isnormal returnVal:='%d'\n", returnVal);
1212     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isnormal  returnVal:='" << returnVal << "'";
1213 }
1214 
1215 /**
1216 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISPRINT_7700
1217 * @tc.name       test isprint api with lower alpha
1218 * @tc.desc       [C- SOFTWARE -0200]
1219 */
1220 HWTEST_F(ActsUtilCheckApiTest, testIsprint7700, Function | MediumTest | Level1) {
1221     char paraVal;
1222     int returnVal;
1223 
1224     paraVal = 'a';
1225     returnVal = isprint(paraVal);
1226     LOGD("    isprint returnVal:='%d'\n", returnVal);
1227     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isprint  returnVal:='" << returnVal << "'";
1228 }
1229 
1230 /**
1231 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISPRINT_7800
1232 * @tc.name       test isprint api with space
1233 * @tc.desc       [C- SOFTWARE -0200]
1234 */
1235 HWTEST_F(ActsUtilCheckApiTest, testIsprint7800, Function | MediumTest | Level1) {
1236     char paraVal;
1237     int returnVal;
1238 
1239     paraVal = ' ';
1240     returnVal = isprint(paraVal);
1241     LOGD("    isprint returnVal:='%d'\n", returnVal);
1242     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isprint  returnVal:='" << returnVal << "'";
1243 }
1244 
1245 /**
1246 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISPRINT_7900
1247 * @tc.name       test isprint api with LF
1248 * @tc.desc       [C- SOFTWARE -0200]
1249 */
1250 HWTEST_F(ActsUtilCheckApiTest, testIsprint7900, Function | MediumTest | Level1) {
1251     char paraVal;
1252     int returnVal;
1253 
1254     paraVal = '\n';
1255     returnVal = isprint(paraVal);
1256     LOGD("    isprint returnVal:='%d'\n", returnVal);
1257     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isprint  returnVal:='" << returnVal << "'";
1258 }
1259 
1260 /**
1261 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISPRINT_L_8000
1262 * @tc.name       test isprint_l api with lower alpha
1263 * @tc.desc       [C- SOFTWARE -0200]
1264 */
1265 HWTEST_F(ActsUtilCheckApiTest, testIsprintL8000, Function | MediumTest | Level1) {
1266     char paraVal;
1267     int returnVal;
1268 
1269     paraVal = 'a';
1270     returnVal = isprint_l(paraVal, g_aucaLocale);
1271     LOGD("    isprint_l returnVal:='%d'\n", returnVal);
1272     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isprint_l  returnVal:='" << returnVal << "'";
1273 }
1274 
1275 /**
1276 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISPRINT_L_8100
1277 * @tc.name       test isprint_l api with space
1278 * @tc.desc       [C- SOFTWARE -0200]
1279 */
1280 HWTEST_F(ActsUtilCheckApiTest, testIsprintL8100, Function | MediumTest | Level1) {
1281     char paraVal;
1282     int returnVal;
1283 
1284     paraVal = ' ';
1285     returnVal = isprint_l(paraVal, g_aucaLocale);
1286     LOGD("    isprint_l returnVal:='%d'\n", returnVal);
1287     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isprint_l  returnVal:='" << returnVal << "'";
1288 }
1289 
1290 /**
1291 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISPRINT_L_8200
1292 * @tc.name       test isprint_l api with LF
1293 * @tc.desc       [C- SOFTWARE -0200]
1294 */
1295 HWTEST_F(ActsUtilCheckApiTest, testIsprintL8200, Function | MediumTest | Level1) {
1296     char paraVal;
1297     int returnVal;
1298 
1299     paraVal = '\n';
1300     returnVal = isprint_l(paraVal, g_aucaLocale);
1301     LOGD("    isprint_l returnVal:='%d'\n", returnVal);
1302     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isprint_l  returnVal:='" << returnVal << "'";
1303 }
1304 
1305 /**
1306 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISPUNCT_8300
1307 * @tc.name       test ispunct api with space
1308 * @tc.desc       [C- SOFTWARE -0200]
1309 */
1310 HWTEST_F(ActsUtilCheckApiTest, testIspunct8300, Function | MediumTest | Level1) {
1311     char paraVal;
1312     int returnVal;
1313 
1314     paraVal = ' ';
1315     returnVal = ispunct(paraVal);
1316     LOGD("    ispunct returnVal:='%d'\n", returnVal);
1317     ASSERT_TRUE(0 == returnVal) << "ErrInfo: ispunct  returnVal:='" << returnVal << "'";
1318 }
1319 
1320 /**
1321 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISPUNCT_8400
1322 * @tc.name       test ispunct api with upper alpha
1323 * @tc.desc       [C- SOFTWARE -0200]
1324 */
1325 HWTEST_F(ActsUtilCheckApiTest, testIspunct8400, Function | MediumTest | Level1) {
1326     char paraVal;
1327     int returnVal;
1328 
1329     paraVal = 'A';
1330     returnVal = ispunct(paraVal);
1331     LOGD("    ispunct returnVal:='%d'\n", returnVal);
1332     ASSERT_TRUE(0 == returnVal) << "ErrInfo: ispunct  returnVal:='" << returnVal << "'";
1333 }
1334 
1335 /**
1336 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISPUNCT_8500
1337 * @tc.name       test ispunct api with LF
1338 * @tc.desc       [C- SOFTWARE -0200]
1339 */
1340 HWTEST_F(ActsUtilCheckApiTest, testIspunct8500, Function | MediumTest | Level1) {
1341     char paraVal;
1342     int returnVal;
1343 
1344     paraVal = '\n';
1345     returnVal = ispunct(paraVal);
1346     LOGD("    ispunct returnVal:='%d'\n", returnVal);
1347     ASSERT_TRUE(0 == returnVal) << "ErrInfo: ispunct  returnVal:='" << returnVal << "'";
1348 }
1349 
1350 /**
1351 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISPUNCT_L_8600
1352 * @tc.name       test ispunct_l api with space
1353 * @tc.desc       [C- SOFTWARE -0200]
1354 */
1355 HWTEST_F(ActsUtilCheckApiTest, testIspunctL8600, Function | MediumTest | Level1) {
1356     char paraVal;
1357     int returnVal;
1358 
1359     paraVal = ' ';
1360     returnVal = ispunct_l(paraVal, g_aucaLocale);
1361     LOGD("    ispunct_l returnVal:='%d'\n", returnVal);
1362     ASSERT_TRUE(0 == returnVal) << "ErrInfo: ispunct_l  returnVal:='" << returnVal << "'";
1363 }
1364 
1365 /**
1366 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISPUNCT_L_8700
1367 * @tc.name       test ispunct_l api with upper alpha
1368 * @tc.desc       [C- SOFTWARE -0200]
1369 */
1370 HWTEST_F(ActsUtilCheckApiTest, testIspunctL8700, Function | MediumTest | Level1) {
1371     char paraVal;
1372     int returnVal;
1373 
1374     paraVal = 'A';
1375     returnVal = ispunct_l(paraVal, g_aucaLocale);
1376     LOGD("    ispunct_l returnVal:='%d'\n", returnVal);
1377     ASSERT_TRUE(0 == returnVal) << "ErrInfo: ispunct_l  returnVal:='" << returnVal << "'";
1378 }
1379 
1380 /**
1381 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISPUNCT_L_8800
1382 * @tc.name       test ispunct_l api with LF
1383 * @tc.desc       [C- SOFTWARE -0200]
1384 */
1385 HWTEST_F(ActsUtilCheckApiTest, testIspunctL8800, Function | MediumTest | Level1) {
1386     char paraVal;
1387     int returnVal;
1388 
1389     paraVal = '\n';
1390     returnVal = ispunct_l(paraVal, g_aucaLocale);
1391     LOGD("    ispunct_l returnVal:='%d'\n", returnVal);
1392     ASSERT_TRUE(0 == returnVal) << "ErrInfo: ispunct_l  returnVal:='" << returnVal << "'";
1393 }
1394 
1395 /**
1396 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISSPACE_8900
1397 * @tc.name       test isspace api with lower alpha
1398 * @tc.desc       [C- SOFTWARE -0200]
1399 */
1400 HWTEST_F(ActsUtilCheckApiTest, testIsspace8900, Function | MediumTest | Level1) {
1401     char paraVal;
1402     int returnVal;
1403 
1404     paraVal = 'a';
1405     returnVal = isspace(paraVal);
1406     LOGD("    isspace returnVal:='%d'\n", returnVal);
1407     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isspace  returnVal:='" << returnVal << "'";
1408 }
1409 
1410 /**
1411 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISSPACE_9000
1412 * @tc.name       test isspace api with space
1413 * @tc.desc       [C- SOFTWARE -0200]
1414 */
1415 HWTEST_F(ActsUtilCheckApiTest, testIsspace9000, Function | MediumTest | Level1) {
1416     char paraVal;
1417     int returnVal;
1418 
1419     paraVal = ' ';
1420     returnVal = isspace(paraVal);
1421     LOGD("    isspace returnVal:='%d'\n", returnVal);
1422     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isspace  returnVal:='" << returnVal << "'";
1423 }
1424 
1425 /**
1426 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISSPACE_9100
1427 * @tc.name       test isspace api with LF
1428 * @tc.desc       [C- SOFTWARE -0200]
1429 */
1430 HWTEST_F(ActsUtilCheckApiTest, testIsspace9100, Function | MediumTest | Level1) {
1431     char paraVal;
1432     int returnVal;
1433 
1434     paraVal = '\n';
1435     returnVal = isspace(paraVal);
1436     LOGD("    isspace returnVal:='%d'\n", returnVal);
1437     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isspace  returnVal:='" << returnVal << "'";
1438 }
1439 
1440 /**
1441 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISSPACE_9200
1442 * @tc.name       test isspace api with CR
1443 * @tc.desc       [C- SOFTWARE -0200]
1444 */
1445 HWTEST_F(ActsUtilCheckApiTest, testIsspace9200, Function | MediumTest | Level1) {
1446     char paraVal;
1447     int returnVal;
1448 
1449     paraVal = '\r';
1450     returnVal = isspace(paraVal);
1451     LOGD("    isspace returnVal:='%d'\n", returnVal);
1452     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isspace  returnVal:='" << returnVal << "'";
1453 }
1454 
1455 /**
1456 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISSPACE_9300
1457 * @tc.name       test isspace api with form-feed
1458 * @tc.desc       [C- SOFTWARE -0200]
1459 */
1460 HWTEST_F(ActsUtilCheckApiTest, testIsspace9300, Function | MediumTest | Level1) {
1461     char paraVal;
1462     int returnVal;
1463 
1464     paraVal = '\f';
1465     returnVal = isspace(paraVal);
1466     LOGD("    isspace returnVal:='%d'\n", returnVal);
1467     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isspace  returnVal:='" << returnVal << "'";
1468 }
1469 
1470 /**
1471 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISSPACE_9400
1472 * @tc.name       test isspace api with horizontal tab
1473 * @tc.desc       [C- SOFTWARE -0200]
1474 */
1475 HWTEST_F(ActsUtilCheckApiTest, testIsspace9400, Function | MediumTest | Level1) {
1476     char paraVal;
1477     int returnVal;
1478 
1479     paraVal = '\t';
1480     returnVal = isspace(paraVal);
1481     LOGD("    isspace returnVal:='%d'\n", returnVal);
1482     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isspace  returnVal:='" << returnVal << "'";
1483 }
1484 
1485 /**
1486 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISSPACE_L_9500
1487 * @tc.name       test isspace_l api with lower alpha
1488 * @tc.desc       [C- SOFTWARE -0200]
1489 */
1490 HWTEST_F(ActsUtilCheckApiTest, testIsspaceL9500, Function | MediumTest | Level1) {
1491     char paraVal;
1492     int returnVal;
1493 
1494     paraVal = 'a';
1495     returnVal = isspace_l(paraVal, g_aucaLocale);
1496     LOGD("    isspace_l returnVal:='%d'\n", returnVal);
1497     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isspace_l  returnVal:='" << returnVal << "'";
1498 }
1499 
1500 /**
1501 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISSPACE_L_9600
1502 * @tc.name       test isspace_l api with space
1503 * @tc.desc       [C- SOFTWARE -0200]
1504 */
1505 HWTEST_F(ActsUtilCheckApiTest, testIsspaceL9600, Function | MediumTest | Level1) {
1506     char paraVal;
1507     int returnVal;
1508 
1509     paraVal = ' ';
1510     returnVal = isspace_l(paraVal, g_aucaLocale);
1511     LOGD("    isspace_l returnVal:='%d'\n", returnVal);
1512     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isspace_l  returnVal:='" << returnVal << "'";
1513 }
1514 
1515 /**
1516 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISSPACE_L_9620
1517 * @tc.name       test isspace_l api with LF
1518 * @tc.desc       [C- SOFTWARE -0200]
1519 */
1520 HWTEST_F(ActsUtilCheckApiTest, testIsspaceL9620, Function | MediumTest | Level1) {
1521     char paraVal;
1522     int returnVal;
1523 
1524     paraVal = '\n';
1525     returnVal = isspace_l(paraVal, g_aucaLocale);
1526     LOGD("    isspace_l returnVal:='%d'\n", returnVal);
1527     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isspace_l  returnVal:='" << returnVal << "'";
1528 }
1529 
1530 /**
1531 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISSPACE_L_9640
1532 * @tc.name       test isspace_l api with CR
1533 * @tc.desc       [C- SOFTWARE -0200]
1534 */
1535 HWTEST_F(ActsUtilCheckApiTest, testIsspaceL9640, Function | MediumTest | Level1) {
1536     char paraVal;
1537     int returnVal;
1538 
1539     paraVal = '\r';
1540     returnVal = isspace_l(paraVal, g_aucaLocale);
1541     LOGD("    isspace_l returnVal:='%d'\n", returnVal);
1542     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isspace_l  returnVal:='" << returnVal << "'";
1543 }
1544 
1545 /**
1546 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISSPACE_L_9660
1547 * @tc.name       test isspace_l api with form-feed
1548 * @tc.desc       [C- SOFTWARE -0200]
1549 */
1550 HWTEST_F(ActsUtilCheckApiTest, testIsspaceL9660, Function | MediumTest | Level1) {
1551     char paraVal;
1552     int returnVal;
1553 
1554     paraVal = '\f';
1555     returnVal = isspace_l(paraVal, g_aucaLocale);
1556     LOGD("    isspace_l returnVal:='%d'\n", returnVal);
1557     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isspace_l  returnVal:='" << returnVal << "'";
1558 }
1559 
1560 /**
1561 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISSPACE_L_9680
1562 * @tc.name       test isspace_l api with horizontal tab
1563 * @tc.desc       [C- SOFTWARE -0200]
1564 */
1565 HWTEST_F(ActsUtilCheckApiTest, testIsspaceL9680, Function | MediumTest | Level1) {
1566     char paraVal;
1567     int returnVal;
1568 
1569     paraVal = '\t';
1570     returnVal = isspace_l(paraVal, g_aucaLocale);
1571     LOGD("    isspace_l returnVal:='%d'\n", returnVal);
1572     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isspace_l  returnVal:='" << returnVal << "'";
1573 }
1574 
1575 /**
1576 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISUNORDERED_9700
1577 * @tc.name       test isunordered api with NAN and 0
1578 * @tc.desc       [C- SOFTWARE -0200]
1579 */
1580 HWTEST_F(ActsUtilCheckApiTest, testIsunordered9700, Function | MediumTest | Level1) {
1581     double paraVal1;
1582     double paraVal2;
1583     int returnVal;
1584 
1585     paraVal1 = NAN;
1586     paraVal2 = 0;
1587     returnVal = isunordered(paraVal1, paraVal2);
1588     LOGD("    isunordered returnVal:='%d'\n", returnVal);
1589     ASSERT_TRUE(1 == returnVal) << "ErrInfo: isunordered  returnVal:='" << returnVal << "'";
1590 }
1591 
1592 /**
1593 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISUPPER_9720
1594 * @tc.name       test isupper api with upper alpha
1595 * @tc.desc       [C- SOFTWARE -0200]
1596 */
1597 HWTEST_F(ActsUtilCheckApiTest, testIsupper9720, Function | MediumTest | Level1) {
1598     char paraVal;
1599     int returnVal;
1600 
1601     paraVal = 'A';
1602     returnVal = isupper(paraVal);
1603     LOGD("    isupper returnVal:='%d'\n", returnVal);
1604     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isupper  returnVal:='" << returnVal << "'";
1605 }
1606 
1607 /**
1608 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISUPPER_9740
1609 * @tc.name       test isupper api with lower alpha
1610 * @tc.desc       [C- SOFTWARE -0200]
1611 */
1612 HWTEST_F(ActsUtilCheckApiTest, testIsupper9740, Function | MediumTest | Level1) {
1613     char paraVal;
1614     int returnVal;
1615 
1616     paraVal = 'a';
1617     returnVal = isupper(paraVal);
1618     LOGD("    isupper returnVal:='%d'\n", returnVal);
1619     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isupper  returnVal:='" << returnVal << "'";
1620 }
1621 
1622 /**
1623 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISUPPER_9760
1624 * @tc.name       test isupper api with digit
1625 * @tc.desc       [C- SOFTWARE -0200]
1626 */
1627 HWTEST_F(ActsUtilCheckApiTest, testIsupper9760, Function | MediumTest | Level1) {
1628     char paraVal;
1629     int returnVal;
1630 
1631     paraVal = '5';
1632     returnVal = isupper(paraVal);
1633     LOGD("    isupper returnVal:='%d'\n", returnVal);
1634     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isupper  returnVal:='" << returnVal << "'";
1635 }
1636 
1637 /**
1638 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISUPPER_9780
1639 * @tc.name       test isupper api with LF
1640 * @tc.desc       [C- SOFTWARE -0200]
1641 */
1642 HWTEST_F(ActsUtilCheckApiTest, testIsupper9780, Function | MediumTest | Level1) {
1643     char paraVal;
1644     int returnVal;
1645 
1646     paraVal = '\n';
1647     returnVal = isupper(paraVal);
1648     LOGD("    isupper returnVal:='%d'\n", returnVal);
1649     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isupper  returnVal:='" << returnVal << "'";
1650 }
1651 
1652 /**
1653 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISUPPER_L_9800
1654 * @tc.name       test isupper_l api with upper alpha
1655 * @tc.desc       [C- SOFTWARE -0200]
1656 */
1657 HWTEST_F(ActsUtilCheckApiTest, testIsupperL9800, Function | MediumTest | Level1) {
1658     char paraVal;
1659     int returnVal;
1660 
1661     paraVal = 'A';
1662     returnVal = isupper_l(paraVal, g_aucaLocale);
1663     LOGD("    isupper_l returnVal:='%d'\n", returnVal);
1664     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isupper_l  returnVal:='" << returnVal << "'";
1665 }
1666 
1667 /**
1668 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISUPPER_L_9820
1669 * @tc.name       test isupper_l api with lower alpha
1670 * @tc.desc       [C- SOFTWARE -0200]
1671 */
1672 HWTEST_F(ActsUtilCheckApiTest, testIsupperL9820, Function | MediumTest | Level1) {
1673     char paraVal;
1674     int returnVal;
1675 
1676     paraVal = 'a';
1677     returnVal = isupper_l(paraVal, g_aucaLocale);
1678     LOGD("    isupper_l returnVal:='%d'\n", returnVal);
1679     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isupper_l  returnVal:='" << returnVal << "'";
1680 }
1681 
1682 /**
1683 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISUPPER_L_9840
1684 * @tc.name       test isupper_l api with digit
1685 * @tc.desc       [C- SOFTWARE -0200]
1686 */
1687 HWTEST_F(ActsUtilCheckApiTest, testIsupperL9840, Function | MediumTest | Level1) {
1688     char paraVal;
1689     int returnVal;
1690 
1691     paraVal = '5';
1692     returnVal = isupper_l(paraVal, g_aucaLocale);
1693     LOGD("    isupper_l returnVal:='%d'\n", returnVal);
1694     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isupper_l  returnVal:='" << returnVal << "'";
1695 }
1696 
1697 /**
1698 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISUPPER_L_9860
1699 * @tc.name       test isupper_l api with LF
1700 * @tc.desc       [C- SOFTWARE -0200]
1701 */
1702 HWTEST_F(ActsUtilCheckApiTest, testIsupperL9860, Function | MediumTest | Level1) {
1703     char paraVal;
1704     int returnVal;
1705 
1706     paraVal = '\n';
1707     returnVal = isupper_l(paraVal, g_aucaLocale);
1708     LOGD("    isupper_l returnVal:='%d'\n", returnVal);
1709     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isupper_l  returnVal:='" << returnVal << "'";
1710 }
1711 
1712 /**
1713 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISXDIGIT_9880
1714 * @tc.name       test isxdigit api with xdigit F
1715 * @tc.desc       [C- SOFTWARE -0200]
1716 */
1717 HWTEST_F(ActsUtilCheckApiTest, testIsxdigit9880, Function | MediumTest | Level1) {
1718     char paraVal;
1719     int returnVal;
1720 
1721     paraVal = 'F';
1722     returnVal = isxdigit(paraVal);
1723     LOGD("    isxdigit returnVal:='%d'\n", returnVal);
1724     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isxdigit  returnVal:='" << returnVal << "'";
1725 }
1726 
1727 /**
1728 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISXDIGIT_9900
1729 * @tc.name       test isxdigit api with alpha G
1730 * @tc.desc       [C- SOFTWARE -0200]
1731 */
1732 HWTEST_F(ActsUtilCheckApiTest, testIsxdigit9900, Function | MediumTest | Level1) {
1733     char paraVal;
1734     int returnVal;
1735 
1736     paraVal = 'G';
1737     returnVal = isxdigit(paraVal);
1738     LOGD("    isxdigit returnVal:='%d'\n", returnVal);
1739     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isxdigit  returnVal:='" << returnVal << "'";
1740 }
1741 
1742 /**
1743 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISXDIGIT_L_9920
1744 * @tc.name       test isxdigit_l api with xdigit F
1745 * @tc.desc       [C- SOFTWARE -0200]
1746 */
1747 HWTEST_F(ActsUtilCheckApiTest, testIsxdigitL9920, Function | MediumTest | Level1) {
1748     char paraVal;
1749     int returnVal;
1750 
1751     paraVal = 'F';
1752     returnVal = isxdigit_l(paraVal, g_aucaLocale);
1753     LOGD("    isxdigit_l returnVal:='%d'\n", returnVal);
1754     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isxdigit_l  returnVal:='" << returnVal << "'";
1755 }
1756 
1757 /**
1758 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISXDIGIT_L_9940
1759 * @tc.name       test isxdigit_l api with alpha G
1760 * @tc.desc       [C- SOFTWARE -0200]
1761 */
1762 HWTEST_F(ActsUtilCheckApiTest, testIsxdigitL19940, Function | MediumTest | Level1) {
1763     char paraVal;
1764     int returnVal;
1765 
1766     paraVal = 'G';
1767     returnVal = isxdigit_l(paraVal, g_aucaLocale);
1768     LOGD("    isxdigit_l returnVal:='%d'\n", returnVal);
1769     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isxdigit_l  returnVal:='" << returnVal << "'";
1770 }