• 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 //     returnVal = isastream(paraVal);
394 //     LOGD("    isastream returnVal:='%d'\n", returnVal);
395 //     ASSERT_TRUE(-1 == returnVal) << "ErrInfo: isastream returnVal:='" << returnVal << "'";
396 // }
397 
398 /**
399 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISATTY_2400
400 * @tc.name       test isatty api with digit
401 * @tc.desc       [C- SOFTWARE -0200]
402 */
403 HWTEST_F(ActsUtilCheckApiTest, testIsatty2400, Function | MediumTest | Level1) {
404     int paraVal;
405     int returnVal;
406 
407     paraVal = 128;
408     returnVal = isatty(paraVal);
409     LOGD("    isatty returnVal:='%d'\n", returnVal);
410     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isatty returnVal:='" << returnVal << "'";
411 }
412 
413 /**
414 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISBLANK_2500
415 * @tc.name       test isblank api with space
416 * @tc.desc       [C- SOFTWARE -0200]
417 */
418 HWTEST_F(ActsUtilCheckApiTest, testIsblank2500, Function | MediumTest | Level1) {
419     int paraVal;
420     int returnVal;
421 
422     paraVal = ' ';
423     returnVal = isblank(paraVal);
424     LOGD("    isblank returnVal:='%d'\n", returnVal);
425     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isblank returnVal:='" << returnVal << "'";
426 }
427 
428 /**
429 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISBLANK_2600
430 * @tc.name       test isblank api with upper alpha
431 * @tc.desc       [C- SOFTWARE -0200]
432 */
433 HWTEST_F(ActsUtilCheckApiTest, testIsblank2600, Function | MediumTest | Level1) {
434     int paraVal;
435     int returnVal;
436 
437     paraVal = 'A';
438     returnVal = isblank(paraVal);
439     LOGD("    isblank returnVal:='%d'\n", returnVal);
440     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isblank returnVal:='" << returnVal << "'";
441 }
442 
443 /**
444 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISBLANK_L_2700
445 * @tc.name       test isblank_l api with space
446 * @tc.desc       [C- SOFTWARE -0200]
447 */
448 HWTEST_F(ActsUtilCheckApiTest, testIsblankL2700, Function | MediumTest | Level1) {
449     int paraVal;
450     int returnVal;
451 
452     paraVal = ' ';
453     returnVal = isblank_l(paraVal, g_aucaLocale);
454     LOGD("    isblank_l returnVal:='%d'\n", returnVal);
455     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isblank_l returnVal:='" << returnVal << "'";
456 }
457 
458 /**
459 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISBLANK_L_2800
460 * @tc.name       test isblank_l api with upper alpha
461 * @tc.desc       [C- SOFTWARE -0200]
462 */
463 HWTEST_F(ActsUtilCheckApiTest, testIsblankL2800, Function | MediumTest | Level1) {
464     int paraVal;
465     int returnVal;
466 
467     paraVal = 'A';
468     returnVal = isblank_l(paraVal, g_aucaLocale);
469     LOGD("    isblank_l returnVal:='%d'\n", returnVal);
470     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isblank_l returnVal:='" << returnVal << "'";
471 }
472 
473 /**
474 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISCNTRL_2900
475 * @tc.name       test iscntrl api with LF
476 * @tc.desc       [C- SOFTWARE -0200]
477 */
478 HWTEST_F(ActsUtilCheckApiTest, testIscntrl2900, Function | MediumTest | Level1) {
479     int paraVal;
480     int returnVal;
481 
482     paraVal = '\n';
483     returnVal = iscntrl(paraVal);
484     LOGD("    iscntrl returnVal:='%d'\n", returnVal);
485     ASSERT_TRUE(returnVal != 0) << "ErrInfo: iscntrl returnVal:='" << returnVal << "'";
486 }
487 
488 /**
489 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISCNTRL_3000
490 * @tc.name       test iscntrl api with upper alpha
491 * @tc.desc       [C- SOFTWARE -0200]
492 */
493 HWTEST_F(ActsUtilCheckApiTest, testIscntrl3000, Function | MediumTest | Level1) {
494     int paraVal;
495     int returnVal;
496 
497     paraVal = 'A';
498     returnVal = iscntrl(paraVal);
499     LOGD("    iscntrl returnVal:='%d'\n", returnVal);
500     ASSERT_TRUE(0 == returnVal) << "ErrInfo: iscntrl returnVal:='" << returnVal << "'";
501 }
502 
503 /**
504 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISCNTRL_L_3100
505 * @tc.name       test iscntrl_l api with LF
506 * @tc.desc       [C- SOFTWARE -0200]
507 */
508 HWTEST_F(ActsUtilCheckApiTest, testIscntrlL3100, Function | MediumTest | Level1) {
509     int paraVal;
510     int returnVal;
511 
512     paraVal = '\n';
513     returnVal = iscntrl_l(paraVal, g_aucaLocale);
514     LOGD("    iscntrl_l returnVal:='%d'\n", returnVal);
515     ASSERT_TRUE(returnVal != 0) << "ErrInfo: iscntrl_l returnVal:='" << returnVal << "'";
516 }
517 
518 /**
519 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISCNTRL_L_3200
520 * @tc.name       test iscntrl_l api with upper alpha
521 * @tc.desc       [C- SOFTWARE -0200]
522 */
523 HWTEST_F(ActsUtilCheckApiTest, testIscntrlL3200, Function | MediumTest | Level1) {
524     int paraVal;
525     int returnVal;
526 
527     paraVal = 'A';
528     returnVal = iscntrl_l(paraVal, g_aucaLocale);
529     LOGD("    iscntrl_l returnVal:='%d'\n", returnVal);
530     ASSERT_TRUE(0 == returnVal) << "ErrInfo: iscntrl_l returnVal:='" << returnVal << "'";
531 }
532 
533 /**
534 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISDIGIT_3300
535 * @tc.name       test isdigit api with digit
536 * @tc.desc       [C- SOFTWARE -0200]
537 */
538 HWTEST_F(ActsUtilCheckApiTest, testIsdigit3300, Function | MediumTest | Level1) {
539     int paraVal;
540     int returnVal;
541 
542     paraVal = '3';
543     returnVal = isdigit(paraVal);
544     LOGD("    isdigit returnVal:='%d'\n", returnVal);
545     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isdigit returnVal:='" << returnVal << "'";
546 }
547 
548 /**
549 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISDIGIT_3400
550 * @tc.name       test isdigit api with lower alpha
551 * @tc.desc       [C- SOFTWARE -0200]
552 */
553 HWTEST_F(ActsUtilCheckApiTest, testIsdigitl3400, Function | MediumTest | Level1) {
554     int paraVal;
555     int returnVal;
556 
557     paraVal = 'a';
558     returnVal = isdigit(paraVal);
559     LOGD("    isdigit returnVal:='%d'\n", returnVal);
560     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isdigit returnVal:='" << returnVal << "'";
561 }
562 
563 /**
564 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISDIGIT_3500
565 * @tc.name       test isdigit api with LF
566 * @tc.desc       [C- SOFTWARE -0200]
567 */
568 HWTEST_F(ActsUtilCheckApiTest, testIsdigitl3500, Function | MediumTest | Level1) {
569     int paraVal;
570     int returnVal;
571 
572     paraVal = '\n';
573     returnVal = isdigit(paraVal);
574     LOGD("    isdigit returnVal:='%d'\n", returnVal);
575     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isdigit returnVal:='" << returnVal << "'";
576 }
577 
578 /**
579 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISDIGIT_3600
580 * @tc.name       test isdigit api with space
581 * @tc.desc       [C- SOFTWARE -0200]
582 */
583 HWTEST_F(ActsUtilCheckApiTest, testIsdigit3600, Function | MediumTest | Level1) {
584     int paraVal;
585     int returnVal;
586 
587     paraVal = ' ';
588     returnVal = isdigit(paraVal);
589     LOGD("    isdigit returnVal:='%d'\n", returnVal);
590     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isdigit returnVal:='" << returnVal << "'";
591 }
592 
593 /**
594 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISDIGIT_L_3700
595 * @tc.name       test isdigit_l api with digit
596 * @tc.desc       [C- SOFTWARE -0200]
597 */
598 HWTEST_F(ActsUtilCheckApiTest, testIsdigitL3700, Function | MediumTest | Level1) {
599     int paraVal;
600     int returnVal;
601 
602     paraVal = '3';
603     returnVal = isdigit_l(paraVal, g_aucaLocale);
604     LOGD("    isdigit_l returnVal:='%d'\n", returnVal);
605     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isdigit_l returnVal:='" << returnVal << "'";
606 }
607 
608 /**
609 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISDIGIT_L_3800
610 * @tc.name       test isdigit_l api with lower alpha
611 * @tc.desc       [C- SOFTWARE -0200]
612 */
613 HWTEST_F(ActsUtilCheckApiTest, testIsdigitlL3800, Function | MediumTest | Level1) {
614     int paraVal;
615     int returnVal;
616 
617     paraVal = 'a';
618     returnVal = isdigit_l(paraVal, g_aucaLocale);
619     LOGD("    isdigit_l returnVal:='%d'\n", returnVal);
620     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isdigit_l returnVal:='" << returnVal << "'";
621 }
622 
623 /**
624 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISDIGIT_L_3900
625 * @tc.name       test isdigit_l api with LF
626 * @tc.desc       [C- SOFTWARE -0200]
627 */
628 HWTEST_F(ActsUtilCheckApiTest, testIsdigitlL3900, Function | MediumTest | Level1) {
629     int paraVal;
630     int returnVal;
631 
632     paraVal = '\n';
633     returnVal = isdigit_l(paraVal, g_aucaLocale);
634     LOGD("    isdigit_l returnVal:='%d'\n", returnVal);
635     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isdigit_l returnVal:='" << returnVal << "'";
636 }
637 
638 /**
639 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISDIGIT_L_4000
640 * @tc.name       test isdigit_l api with space
641 * @tc.desc       [C- SOFTWARE -0200]
642 */
643 HWTEST_F(ActsUtilCheckApiTest, testIsdigitL4000, Function | MediumTest | Level1) {
644     int paraVal;
645     int returnVal;
646 
647     paraVal = ' ';
648     returnVal = isdigit_l(paraVal, g_aucaLocale);
649     LOGD("    isdigit_l returnVal:='%d'\n", returnVal);
650     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isdigit_l returnVal:='" << returnVal << "'";
651 }
652 
653 /**
654 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISFINITE_4100
655 * @tc.name       test isfinite api with space
656 * @tc.desc       [C- SOFTWARE -0200]
657 */
658 HWTEST_F(ActsUtilCheckApiTest, testIsfinite4100, Function | MediumTest | Level1) {
659     double paraVal;
660     int returnVal;
661 
662     paraVal = ' ';
663     returnVal = isfinite(paraVal);
664     LOGD("    isfinite returnVal:='%d'\n", returnVal);
665     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isfinite returnVal:='" << returnVal << "'";
666 }
667 
668 /**
669 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISFINITE_4200
670 * @tc.name       test isfinite api with decimal double
671 * @tc.desc       [C- SOFTWARE -0200]
672 */
673 HWTEST_F(ActsUtilCheckApiTest, testIsfinite4200, Function | MediumTest | Level1) {
674     double paraVal;
675     int returnVal;
676 
677     paraVal = 3.1415926;
678     returnVal = isfinite(paraVal);
679     LOGD("    isfinite returnVal:='%d'\n", returnVal);
680     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isfinite returnVal:='" << returnVal << "'";
681 }
682 
683 /**
684 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISFINITE_4300
685 * @tc.name       test isfinite api with exponent double
686 * @tc.desc       [C- SOFTWARE -0200]
687 */
688 HWTEST_F(ActsUtilCheckApiTest, testIsfinite4300, Function | MediumTest | Level1) {
689     double paraVal;
690     int returnVal;
691 
692     paraVal = 1.26e3;
693     returnVal = isfinite(paraVal);
694     LOGD("    isfinite returnVal:='%d'\n", returnVal);
695     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isfinite returnVal:='" << returnVal << "'";
696 }
697 
698 /**
699 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISGRAPH_4400
700 * @tc.name       test isgraph api with upper alpha
701 * @tc.desc       [C- SOFTWARE -0200]
702 */
703 HWTEST_F(ActsUtilCheckApiTest, testIsgraph4400, Function | MediumTest | Level1) {
704     double paraVal;
705     int returnVal;
706 
707     paraVal = 'A';
708     returnVal = isgraph(paraVal);
709     LOGD("    isgraph returnVal:='%d'\n", returnVal);
710     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isgraph returnVal:='" << returnVal << "'";
711 }
712 
713 /**
714 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISGRAPH_4500
715 * @tc.name       test isgraph api with lower alpha
716 * @tc.desc       [C- SOFTWARE -0200]
717 */
718 HWTEST_F(ActsUtilCheckApiTest, testIsgraph4500, Function | MediumTest | Level1) {
719     double paraVal;
720     int returnVal;
721 
722     paraVal = 'z';
723     returnVal = isgraph(paraVal);
724     LOGD("    isgraph returnVal:='%d'\n", returnVal);
725     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isgraph returnVal:='" << returnVal << "'";
726 }
727 
728 /**
729 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISGRAPH_4600
730 * @tc.name       test isgraph api with LF
731 * @tc.desc       [C- SOFTWARE -0200]
732 */
733 HWTEST_F(ActsUtilCheckApiTest, testIsgraph4600, Function | MediumTest | Level1) {
734     double paraVal;
735     int returnVal;
736 
737     paraVal = '\n';
738     returnVal = isgraph(paraVal);
739     LOGD("    isgraph returnVal:='%d'\n", returnVal);
740     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isgraph returnVal:='" << returnVal << "'";
741 }
742 
743 /**
744 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISGRAPH_4700
745 * @tc.name       test isgraph api with space
746 * @tc.desc       [C- SOFTWARE -0200]
747 */
748 HWTEST_F(ActsUtilCheckApiTest, testIsgraph4700, Function | MediumTest | Level1) {
749     double paraVal;
750     int returnVal;
751 
752     paraVal = ' ';
753     returnVal = isgraph(paraVal);
754     LOGD("    isgraph returnVal:='%d'\n", returnVal);
755     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isgraph returnVal:='" << returnVal << "'";
756 }
757 
758 /**
759 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISGRAPH_L_4800
760 * @tc.name       test isgraph_l api with upper alpha
761 * @tc.desc       [C- SOFTWARE -0200]
762 */
763 HWTEST_F(ActsUtilCheckApiTest, testIsgraphL4800, Function | MediumTest | Level1) {
764     double paraVal;
765     int returnVal;
766 
767     paraVal = 'A';
768     returnVal = isgraph_l(paraVal, g_aucaLocale);
769     LOGD("    isgraph returnVal:='%d'\n", returnVal);
770     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isgraph returnVal:='" << returnVal << "'";
771 }
772 
773 /**
774 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISGRAPH_L_4900
775 * @tc.name       test isgraph_l api with lower alpha
776 * @tc.desc       [C- SOFTWARE -0200]
777 */
778 HWTEST_F(ActsUtilCheckApiTest, testIsgraphL4900, Function | MediumTest | Level1) {
779     double paraVal;
780     int returnVal;
781 
782     paraVal = 'z';
783     returnVal = isgraph_l(paraVal, g_aucaLocale);
784     LOGD("    isgraph returnVal:='%d'\n", returnVal);
785     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isgraph returnVal:='" << returnVal << "'";
786 }
787 
788 /**
789 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISGRAPH_L_5000
790 * @tc.name       test isgraph_l api with LF
791 * @tc.desc       [C- SOFTWARE -0200]
792 */
793 HWTEST_F(ActsUtilCheckApiTest, testIsgraphL5000, Function | MediumTest | Level1) {
794     double paraVal;
795     int returnVal;
796 
797     paraVal = '\n';
798     returnVal = isgraph_l(paraVal, g_aucaLocale);
799     LOGD("    isgraph returnVal:='%d'\n", returnVal);
800     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isgraph returnVal:='" << returnVal << "'";
801 }
802 
803 /**
804 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISGRAPH_L_5100
805 * @tc.name       test isgraph_l api with space
806 * @tc.desc       [C- SOFTWARE -0200]
807 */
808 HWTEST_F(ActsUtilCheckApiTest, testIsgraphL5100, Function | MediumTest | Level1) {
809     double paraVal;
810     int returnVal;
811 
812     paraVal = ' ';
813     returnVal = isgraph_l(paraVal, g_aucaLocale);
814     LOGD("    isgraph returnVal:='%d'\n", returnVal);
815     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isgraph returnVal:='" << returnVal << "'";
816 }
817 
818 /**
819 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISGREATER_5200
820 * @tc.name       test isgreater api para1 is less than para2
821 * @tc.desc       [C- SOFTWARE -0200]
822 */
823 HWTEST_F(ActsUtilCheckApiTest, testIsgreater5200, Function | MediumTest | Level1) {
824     double paraVal1;
825     double paraVal2;
826     int returnVal;
827 
828     paraVal1 = 1.1;
829     paraVal2 = 2.1;
830     returnVal = isgreater(paraVal1, paraVal2);
831     LOGD("    isgreater returnVal:='%d'\n", returnVal);
832     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isgreater returnVal:='" << returnVal << "'";
833 }
834 
835 /**
836 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISGREATER_5300
837 * @tc.name       test isgreater api para1 is greater than para2
838 * @tc.desc       [C- SOFTWARE -0200]
839 */
840 HWTEST_F(ActsUtilCheckApiTest, testIsgreater5300, Function | MediumTest | Level1) {
841     double paraVal1;
842     double paraVal2;
843     int returnVal;
844 
845     paraVal1 = 2.1;
846     paraVal2 = 1.1;
847     returnVal = isgreater(paraVal1, paraVal2);
848     LOGD("    isgreater returnVal:='%d'\n", returnVal);
849     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isgreater returnVal:='" << returnVal << "'";
850 }
851 
852 /**
853 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISGREATER_5400
854 * @tc.name       test isgreater api para1 is equal to para2
855 * @tc.desc       [C- SOFTWARE -0200]
856 */
857 HWTEST_F(ActsUtilCheckApiTest, testIsgreater5400, Function | MediumTest | Level1) {
858     double paraVal1;
859     double paraVal2;
860     int returnVal;
861 
862     paraVal1 = 2.1;
863     paraVal2 = 2.1;
864     returnVal = isgreater(paraVal1, paraVal2);
865     LOGD("    isgreater returnVal:='%d'\n", returnVal);
866     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isgreater returnVal:='" << returnVal << "'";
867 }
868 
869 /**
870 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISGREATEREQUAL_5500
871 * @tc.name       test isgreaterequal api para1 is less than para2
872 * @tc.desc       [C- SOFTWARE -0200]
873 */
874 HWTEST_F(ActsUtilCheckApiTest, testIsgreaterequal5500, Function | MediumTest | Level1) {
875     double paraVal1;
876     double paraVal2;
877     int returnVal;
878 
879     paraVal1 = 1.1;
880     paraVal2 = 2.1;
881     returnVal = isgreaterequal(paraVal1, paraVal2);
882     LOGD("    isgreaterequal returnVal:='%d'\n", returnVal);
883     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isgreaterequal returnVal:='" << returnVal << "'";
884 }
885 
886 /**
887 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISGREATEREQUAL_5600
888 * @tc.name       test isgreaterequal api para1 is greater than para2
889 * @tc.desc       [C- SOFTWARE -0200]
890 */
891 HWTEST_F(ActsUtilCheckApiTest, testIsgreaterequal5600, Function | MediumTest | Level1) {
892     double paraVal1;
893     double paraVal2;
894     int returnVal;
895 
896     paraVal1 = 2.1;
897     paraVal2 = 1.1;
898     returnVal = isgreaterequal(paraVal1, paraVal2);
899     LOGD("    isgreaterequal returnVal:='%d'\n", returnVal);
900     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isgreaterequal returnVal:='" << returnVal << "'";
901 }
902 
903 /**
904 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISGREATEREQUAL_5700
905 * @tc.name       test isgreaterequal api para1 is equal to para2
906 * @tc.desc       [C- SOFTWARE -0200]
907 */
908 HWTEST_F(ActsUtilCheckApiTest, testIsgreaterequal5700, Function | MediumTest | Level1) {
909     double paraVal1;
910     double paraVal2;
911     int returnVal;
912 
913     paraVal1 = 2.1;
914     paraVal2 = 2.1;
915     returnVal = isgreaterequal(paraVal1, paraVal2);
916     LOGD("    isgreaterequal returnVal:='%d'\n", returnVal);
917     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isgreaterequal returnVal:='" << returnVal << "'";
918 }
919 
920 /**
921 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISINF_5800
922 * @tc.name       test isinf api with INFINITY
923 * @tc.desc       [C- SOFTWARE -0200]
924 */
925 HWTEST_F(ActsUtilCheckApiTest, testIsinf5800, Function | MediumTest | Level1) {
926     double paraVal;
927     int returnVal;
928 
929     paraVal = INFINITY;
930     returnVal = isinf(paraVal);
931     LOGD("    isinf returnVal:='%d'\n", returnVal);
932     ASSERT_TRUE(1 == returnVal) << "ErrInfo: isinf  returnVal:='" << returnVal << "'";
933 }
934 
935 /**
936 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISLESSEQUAL_5900
937 * @tc.name       test islessequal api para1 is less than para2
938 * @tc.desc       [C- SOFTWARE -0200]
939 */
940 HWTEST_F(ActsUtilCheckApiTest, testIslessequal5900, Function | MediumTest | Level1) {
941     double paraVal1;
942     double paraVal2;
943     int returnVal;
944 
945     paraVal1 = 1.1;
946     paraVal2 = 2.1;
947     returnVal = islessequal(paraVal1, paraVal2);
948     LOGD("    islessequal returnVal:='%d'\n", returnVal);
949     ASSERT_TRUE(0 != returnVal) << "ErrInfo: islessequal returnVal:='" << returnVal << "'";
950 }
951 
952 /**
953 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISLESSEQUAL_6000
954 * @tc.name       test islessequal api para1 is greater than para2
955 * @tc.desc       [C- SOFTWARE -0200]
956 */
957 HWTEST_F(ActsUtilCheckApiTest, testIslessequal6000, Function | MediumTest | Level1) {
958     double paraVal1;
959     double paraVal2;
960     int returnVal;
961 
962     paraVal1 = 2.1;
963     paraVal2 = 1.1;
964     returnVal = islessequal(paraVal1, paraVal2);
965     LOGD("    islessequal returnVal:='%d'\n", returnVal);
966     ASSERT_TRUE(0 == returnVal) << "ErrInfo: islessequal returnVal:='" << returnVal << "'";
967 }
968 
969 /**
970 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISLESSEQUAL_6100
971 * @tc.name       test islessequal api para1 is equal to para2
972 * @tc.desc       [C- SOFTWARE -0200]
973 */
974 HWTEST_F(ActsUtilCheckApiTest, testIslessequal6100, Function | MediumTest | Level1) {
975     double paraVal1;
976     double paraVal2;
977     int returnVal;
978 
979     paraVal1 = 2.1;
980     paraVal2 = 2.1;
981     returnVal = islessequal(paraVal1, paraVal2);
982     LOGD("    islessequal returnVal:='%d'\n", returnVal);
983     ASSERT_TRUE(returnVal != 0) << "ErrInfo: islessequal returnVal:='" << returnVal << "'";
984 }
985 
986 /**
987 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISLESSGREATER_6200
988 * @tc.name       test islessgreater api para1 is equal to para2
989 * @tc.desc       [C- SOFTWARE -0200]
990 */
991 HWTEST_F(ActsUtilCheckApiTest, testIslessgreater6200, Function | MediumTest | Level1) {
992     double paraVal1;
993     double paraVal2;
994     int returnVal;
995 
996     paraVal1 = 2.1;
997     paraVal2 = 2.1;
998     returnVal = islessgreater(paraVal1, paraVal2);
999     LOGD("    islessgreater returnVal:='%d'\n", returnVal);
1000     ASSERT_TRUE(0 == returnVal) << "ErrInfo: islessgreater returnVal:='" << returnVal << "'";
1001 }
1002 
1003 /**
1004 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISLESSGREATER_6300
1005 * @tc.name       test islessgreater api para1 is less than para2
1006 * @tc.desc       [C- SOFTWARE -0200]
1007 */
1008 HWTEST_F(ActsUtilCheckApiTest, testIslessgreater6300, Function | MediumTest | Level1) {
1009     double paraVal1;
1010     double paraVal2;
1011     int returnVal;
1012 
1013     paraVal1 = 1.1;
1014     paraVal2 = 2.1;
1015     returnVal = islessgreater(paraVal1, paraVal2);
1016     LOGD("    islessgreater returnVal:='%d'\n", returnVal);
1017     ASSERT_TRUE(returnVal != 0) << "ErrInfo: islessgreater returnVal:='" << returnVal << "'";
1018 }
1019 
1020 /**
1021 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISLESSGREATER_6400
1022 * @tc.name       test islessgreater api para1 is greater than para2
1023 * @tc.desc       [C- SOFTWARE -0200]
1024 */
1025 HWTEST_F(ActsUtilCheckApiTest, testIslessgreater6400, Function | MediumTest | Level1) {
1026     double paraVal1;
1027     double paraVal2;
1028     int returnVal;
1029 
1030     paraVal1 = 3.1;
1031     paraVal2 = 2.1;
1032     returnVal = islessgreater(paraVal1, paraVal2);
1033     LOGD("    islessgreater returnVal:='%d'\n", returnVal);
1034     ASSERT_TRUE(returnVal != 0) << "ErrInfo: islessgreater returnVal:='" << returnVal << "'";
1035 }
1036 
1037 /**
1038 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISLOWER_6500
1039 * @tc.name       test islower api with upper alpha
1040 * @tc.desc       [C- SOFTWARE -0200]
1041 */
1042 HWTEST_F(ActsUtilCheckApiTest, testIslower6500, Function | MediumTest | Level1) {
1043     char paraChar;
1044     int returnVal;
1045 
1046     paraChar = 'A';
1047     returnVal = islower(paraChar);
1048     LOGD("    islower c:='%c',   returnVal:='%c'\n", paraChar, returnVal);
1049     ASSERT_TRUE(0 == returnVal) << "ErrInfo: islower c:='" << paraChar << "',   returnVal:='" << returnVal << "'";
1050 }
1051 
1052 /**
1053 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISLOWER_6600
1054 * @tc.name       test islower api with lower alpha
1055 * @tc.desc       [C- SOFTWARE -0200]
1056 */
1057 HWTEST_F(ActsUtilCheckApiTest, testIslower6600, Function | MediumTest | Level1) {
1058     char paraChar;
1059     int returnVal;
1060 
1061     paraChar = 'a';
1062     returnVal = islower(paraChar);
1063     LOGD("    islower c:='%c',   returnVal:='%c'\n", paraChar, returnVal);
1064     ASSERT_TRUE(returnVal != 0) << "ErrInfo: islower c:='" << paraChar << "',   returnVal:='" << returnVal << "'";
1065 }
1066 
1067 /**
1068 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISLOWER_6700
1069 * @tc.name       test islower api with digit
1070 * @tc.desc       [C- SOFTWARE -0200]
1071 */
1072 HWTEST_F(ActsUtilCheckApiTest, testIslower6700, Function | MediumTest | Level1) {
1073     char paraChar;
1074     int returnVal;
1075 
1076     paraChar = '5';
1077     returnVal = islower(paraChar);
1078     LOGD("    islower c:='%c',   returnVal:='%c'\n", paraChar, returnVal);
1079     ASSERT_TRUE(0 == returnVal) << "ErrInfo: islower c:='" << paraChar << "',   returnVal:='" << returnVal << "'";
1080 }
1081 
1082 /**
1083 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISLOWER_6800
1084 * @tc.name       test islower api with space
1085 * @tc.desc       [C- SOFTWARE -0200]
1086 */
1087 HWTEST_F(ActsUtilCheckApiTest, testIslower6800, Function | MediumTest | Level1) {
1088     char paraChar;
1089     int returnVal;
1090 
1091     paraChar = ' ';
1092     returnVal = islower(paraChar);
1093     LOGD("    islower c:='%c',   returnVal:='%c'\n", paraChar, returnVal);
1094     ASSERT_TRUE(0 == returnVal) << "ErrInfo: islower c:='" << paraChar << "',   returnVal:='" << returnVal << "'";
1095 }
1096 
1097 /**
1098 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISLOWER_L_6900
1099 * @tc.name       test islower_l api with upper alpha
1100 * @tc.desc       [C- SOFTWARE -0200]
1101 */
1102 HWTEST_F(ActsUtilCheckApiTest, testIslowerL6900, Function | MediumTest | Level1) {
1103     char paraChar;
1104     int returnVal;
1105 
1106     paraChar = 'A';
1107     returnVal = islower_l(paraChar, g_aucaLocale);
1108     LOGD("    islower_l c:='%c',   returnVal:='%c'\n", paraChar, returnVal);
1109     ASSERT_TRUE(0 == returnVal) << "ErrInfo: islower_l c:='" << paraChar << "',   returnVal:='" << returnVal << "'";
1110 }
1111 
1112 /**
1113 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISLOWER_L_7000
1114 * @tc.name       test islower_l api with lower alpha
1115 * @tc.desc       [C- SOFTWARE -0200]
1116 */
1117 HWTEST_F(ActsUtilCheckApiTest, testIslowerL7000, Function | MediumTest | Level1) {
1118     char paraChar;
1119     int returnVal;
1120 
1121     paraChar = 'a';
1122     returnVal = islower_l(paraChar, g_aucaLocale);
1123     LOGD("    islower_l c:='%c',   returnVal:='%c'\n", paraChar, returnVal);
1124     ASSERT_TRUE(returnVal != 0) << "ErrInfo: islower_l c:='" << paraChar << "',   returnVal:='" << returnVal << "'";
1125 }
1126 
1127 /**
1128 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISLOWER_L_7100
1129 * @tc.name       test islower_l api with digit
1130 * @tc.desc       [C- SOFTWARE -0200]
1131 */
1132 HWTEST_F(ActsUtilCheckApiTest, testIslowerL7100, Function | MediumTest | Level1) {
1133     char paraChar;
1134     int returnVal;
1135 
1136     paraChar = '5';
1137     returnVal = islower_l(paraChar, g_aucaLocale);
1138     LOGD("    islower_l c:='%c',   returnVal:='%c'\n", paraChar, returnVal);
1139     ASSERT_TRUE(0 == returnVal) << "ErrInfo: islower_l c:='" << paraChar << "',   returnVal:='" << returnVal << "'";
1140 }
1141 
1142 /**
1143 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISLOWER_L_7200
1144 * @tc.name       test islower_l api with space
1145 * @tc.desc       [C- SOFTWARE -0200]
1146 */
1147 HWTEST_F(ActsUtilCheckApiTest, testIslowerL7200, Function | MediumTest | Level1) {
1148     char paraChar;
1149     int returnVal;
1150 
1151     paraChar = ' ';
1152     returnVal = islower_l(paraChar, g_aucaLocale);
1153     LOGD("    islower_l c:='%c',   returnVal:='%c'\n", paraChar, returnVal);
1154     ASSERT_TRUE(0 == returnVal) << "ErrInfo: islower_l c:='" << paraChar << "',   returnVal:='" << returnVal << "'";
1155 }
1156 
1157 /**
1158 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISNAN_7300
1159 * @tc.name       test isnan api with NAN
1160 * @tc.desc       [C- SOFTWARE -0200]
1161 */
1162 HWTEST_F(ActsUtilCheckApiTest, testIsnan7300, Function | MediumTest | Level1) {
1163     double paraVal;
1164     int returnVal;
1165 
1166     paraVal = NAN;
1167     returnVal = isnan(paraVal);
1168     LOGD("    isnan returnVal:='%d'\n", returnVal);
1169     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isnan  returnVal:='" << returnVal << "'";
1170 }
1171 
1172 /**
1173 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISNORMAL_7400
1174 * @tc.name       test isnormal api with FP_NORMAL
1175 * @tc.desc       [C- SOFTWARE -0200]
1176 */
1177 HWTEST_F(ActsUtilCheckApiTest, testIsnormal7400, Function | MediumTest | Level1) {
1178     double paraVal;
1179     int returnVal;
1180 
1181     paraVal = FP_NORMAL;
1182     returnVal = isnormal(paraVal);
1183     LOGD("    isnormal returnVal:='%d'\n", returnVal);
1184     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isnormal  returnVal:='" << returnVal << "'";
1185 }
1186 
1187 /**
1188 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISNORMAL_7500
1189 * @tc.name       test isnormal api with NAN
1190 * @tc.desc       [C- SOFTWARE -0200]
1191 */
1192 HWTEST_F(ActsUtilCheckApiTest, testIsnormal7500, Function | MediumTest | Level1) {
1193     double paraVal;
1194     int returnVal;
1195 
1196     paraVal = NAN;
1197     returnVal = isnormal(paraVal);
1198     LOGD("    isnormal returnVal:='%d'\n", returnVal);
1199     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isnormal  returnVal:='" << returnVal << "'";
1200 }
1201 
1202 /**
1203 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISNORMAL_7600
1204 * @tc.name       test isnormal api with double
1205 * @tc.desc       [C- SOFTWARE -0200]
1206 */
1207 HWTEST_F(ActsUtilCheckApiTest, testIsnormal7600, Function | MediumTest | Level1) {
1208     double paraVal;
1209     int returnVal;
1210 
1211     paraVal = 2.1;
1212     returnVal = isnormal(paraVal);
1213     LOGD("    isnormal returnVal:='%d'\n", returnVal);
1214     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isnormal  returnVal:='" << returnVal << "'";
1215 }
1216 
1217 /**
1218 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISPRINT_7700
1219 * @tc.name       test isprint api with lower alpha
1220 * @tc.desc       [C- SOFTWARE -0200]
1221 */
1222 HWTEST_F(ActsUtilCheckApiTest, testIsprint7700, Function | MediumTest | Level1) {
1223     char paraVal;
1224     int returnVal;
1225 
1226     paraVal = 'a';
1227     returnVal = isprint(paraVal);
1228     LOGD("    isprint returnVal:='%d'\n", returnVal);
1229     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isprint  returnVal:='" << returnVal << "'";
1230 }
1231 
1232 /**
1233 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISPRINT_7800
1234 * @tc.name       test isprint api with space
1235 * @tc.desc       [C- SOFTWARE -0200]
1236 */
1237 HWTEST_F(ActsUtilCheckApiTest, testIsprint7800, Function | MediumTest | Level1) {
1238     char paraVal;
1239     int returnVal;
1240 
1241     paraVal = ' ';
1242     returnVal = isprint(paraVal);
1243     LOGD("    isprint returnVal:='%d'\n", returnVal);
1244     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isprint  returnVal:='" << returnVal << "'";
1245 }
1246 
1247 /**
1248 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISPRINT_7900
1249 * @tc.name       test isprint api with LF
1250 * @tc.desc       [C- SOFTWARE -0200]
1251 */
1252 HWTEST_F(ActsUtilCheckApiTest, testIsprint7900, Function | MediumTest | Level1) {
1253     char paraVal;
1254     int returnVal;
1255 
1256     paraVal = '\n';
1257     returnVal = isprint(paraVal);
1258     LOGD("    isprint returnVal:='%d'\n", returnVal);
1259     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isprint  returnVal:='" << returnVal << "'";
1260 }
1261 
1262 /**
1263 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISPRINT_L_8000
1264 * @tc.name       test isprint_l api with lower alpha
1265 * @tc.desc       [C- SOFTWARE -0200]
1266 */
1267 HWTEST_F(ActsUtilCheckApiTest, testIsprintL8000, Function | MediumTest | Level1) {
1268     char paraVal;
1269     int returnVal;
1270 
1271     paraVal = 'a';
1272     returnVal = isprint_l(paraVal, g_aucaLocale);
1273     LOGD("    isprint_l returnVal:='%d'\n", returnVal);
1274     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isprint_l  returnVal:='" << returnVal << "'";
1275 }
1276 
1277 /**
1278 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISPRINT_L_8100
1279 * @tc.name       test isprint_l api with space
1280 * @tc.desc       [C- SOFTWARE -0200]
1281 */
1282 HWTEST_F(ActsUtilCheckApiTest, testIsprintL8100, Function | MediumTest | Level1) {
1283     char paraVal;
1284     int returnVal;
1285 
1286     paraVal = ' ';
1287     returnVal = isprint_l(paraVal, g_aucaLocale);
1288     LOGD("    isprint_l returnVal:='%d'\n", returnVal);
1289     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isprint_l  returnVal:='" << returnVal << "'";
1290 }
1291 
1292 /**
1293 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISPRINT_L_8200
1294 * @tc.name       test isprint_l api with LF
1295 * @tc.desc       [C- SOFTWARE -0200]
1296 */
1297 HWTEST_F(ActsUtilCheckApiTest, testIsprintL8200, Function | MediumTest | Level1) {
1298     char paraVal;
1299     int returnVal;
1300 
1301     paraVal = '\n';
1302     returnVal = isprint_l(paraVal, g_aucaLocale);
1303     LOGD("    isprint_l returnVal:='%d'\n", returnVal);
1304     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isprint_l  returnVal:='" << returnVal << "'";
1305 }
1306 
1307 /**
1308 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISPUNCT_8300
1309 * @tc.name       test ispunct api with space
1310 * @tc.desc       [C- SOFTWARE -0200]
1311 */
1312 HWTEST_F(ActsUtilCheckApiTest, testIspunct8300, Function | MediumTest | Level1) {
1313     char paraVal;
1314     int returnVal;
1315 
1316     paraVal = ' ';
1317     returnVal = ispunct(paraVal);
1318     LOGD("    ispunct returnVal:='%d'\n", returnVal);
1319     ASSERT_TRUE(0 == returnVal) << "ErrInfo: ispunct  returnVal:='" << returnVal << "'";
1320 }
1321 
1322 /**
1323 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISPUNCT_8400
1324 * @tc.name       test ispunct api with upper alpha
1325 * @tc.desc       [C- SOFTWARE -0200]
1326 */
1327 HWTEST_F(ActsUtilCheckApiTest, testIspunct8400, Function | MediumTest | Level1) {
1328     char paraVal;
1329     int returnVal;
1330 
1331     paraVal = 'A';
1332     returnVal = ispunct(paraVal);
1333     LOGD("    ispunct returnVal:='%d'\n", returnVal);
1334     ASSERT_TRUE(0 == returnVal) << "ErrInfo: ispunct  returnVal:='" << returnVal << "'";
1335 }
1336 
1337 /**
1338 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISPUNCT_8500
1339 * @tc.name       test ispunct api with LF
1340 * @tc.desc       [C- SOFTWARE -0200]
1341 */
1342 HWTEST_F(ActsUtilCheckApiTest, testIspunct8500, Function | MediumTest | Level1) {
1343     char paraVal;
1344     int returnVal;
1345 
1346     paraVal = '\n';
1347     returnVal = ispunct(paraVal);
1348     LOGD("    ispunct returnVal:='%d'\n", returnVal);
1349     ASSERT_TRUE(0 == returnVal) << "ErrInfo: ispunct  returnVal:='" << returnVal << "'";
1350 }
1351 
1352 /**
1353 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISPUNCT_L_8600
1354 * @tc.name       test ispunct_l api with space
1355 * @tc.desc       [C- SOFTWARE -0200]
1356 */
1357 HWTEST_F(ActsUtilCheckApiTest, testIspunctL8600, Function | MediumTest | Level1) {
1358     char paraVal;
1359     int returnVal;
1360 
1361     paraVal = ' ';
1362     returnVal = ispunct_l(paraVal, g_aucaLocale);
1363     LOGD("    ispunct_l returnVal:='%d'\n", returnVal);
1364     ASSERT_TRUE(0 == returnVal) << "ErrInfo: ispunct_l  returnVal:='" << returnVal << "'";
1365 }
1366 
1367 /**
1368 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISPUNCT_L_8700
1369 * @tc.name       test ispunct_l api with upper alpha
1370 * @tc.desc       [C- SOFTWARE -0200]
1371 */
1372 HWTEST_F(ActsUtilCheckApiTest, testIspunctL8700, Function | MediumTest | Level1) {
1373     char paraVal;
1374     int returnVal;
1375 
1376     paraVal = 'A';
1377     returnVal = ispunct_l(paraVal, g_aucaLocale);
1378     LOGD("    ispunct_l returnVal:='%d'\n", returnVal);
1379     ASSERT_TRUE(0 == returnVal) << "ErrInfo: ispunct_l  returnVal:='" << returnVal << "'";
1380 }
1381 
1382 /**
1383 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISPUNCT_L_8800
1384 * @tc.name       test ispunct_l api with LF
1385 * @tc.desc       [C- SOFTWARE -0200]
1386 */
1387 HWTEST_F(ActsUtilCheckApiTest, testIspunctL8800, Function | MediumTest | Level1) {
1388     char paraVal;
1389     int returnVal;
1390 
1391     paraVal = '\n';
1392     returnVal = ispunct_l(paraVal, g_aucaLocale);
1393     LOGD("    ispunct_l returnVal:='%d'\n", returnVal);
1394     ASSERT_TRUE(0 == returnVal) << "ErrInfo: ispunct_l  returnVal:='" << returnVal << "'";
1395 }
1396 
1397 /**
1398 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISSPACE_8900
1399 * @tc.name       test isspace api with lower alpha
1400 * @tc.desc       [C- SOFTWARE -0200]
1401 */
1402 HWTEST_F(ActsUtilCheckApiTest, testIsspace8900, Function | MediumTest | Level1) {
1403     char paraVal;
1404     int returnVal;
1405 
1406     paraVal = 'a';
1407     returnVal = isspace(paraVal);
1408     LOGD("    isspace returnVal:='%d'\n", returnVal);
1409     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isspace  returnVal:='" << returnVal << "'";
1410 }
1411 
1412 /**
1413 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISSPACE_9000
1414 * @tc.name       test isspace api with space
1415 * @tc.desc       [C- SOFTWARE -0200]
1416 */
1417 HWTEST_F(ActsUtilCheckApiTest, testIsspace9000, Function | MediumTest | Level1) {
1418     char paraVal;
1419     int returnVal;
1420 
1421     paraVal = ' ';
1422     returnVal = isspace(paraVal);
1423     LOGD("    isspace returnVal:='%d'\n", returnVal);
1424     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isspace  returnVal:='" << returnVal << "'";
1425 }
1426 
1427 /**
1428 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISSPACE_9100
1429 * @tc.name       test isspace api with LF
1430 * @tc.desc       [C- SOFTWARE -0200]
1431 */
1432 HWTEST_F(ActsUtilCheckApiTest, testIsspace9100, Function | MediumTest | Level1) {
1433     char paraVal;
1434     int returnVal;
1435 
1436     paraVal = '\n';
1437     returnVal = isspace(paraVal);
1438     LOGD("    isspace returnVal:='%d'\n", returnVal);
1439     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isspace  returnVal:='" << returnVal << "'";
1440 }
1441 
1442 /**
1443 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISSPACE_9200
1444 * @tc.name       test isspace api with CR
1445 * @tc.desc       [C- SOFTWARE -0200]
1446 */
1447 HWTEST_F(ActsUtilCheckApiTest, testIsspace9200, Function | MediumTest | Level1) {
1448     char paraVal;
1449     int returnVal;
1450 
1451     paraVal = '\r';
1452     returnVal = isspace(paraVal);
1453     LOGD("    isspace returnVal:='%d'\n", returnVal);
1454     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isspace  returnVal:='" << returnVal << "'";
1455 }
1456 
1457 /**
1458 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISSPACE_9300
1459 * @tc.name       test isspace api with form-feed
1460 * @tc.desc       [C- SOFTWARE -0200]
1461 */
1462 HWTEST_F(ActsUtilCheckApiTest, testIsspace9300, Function | MediumTest | Level1) {
1463     char paraVal;
1464     int returnVal;
1465 
1466     paraVal = '\f';
1467     returnVal = isspace(paraVal);
1468     LOGD("    isspace returnVal:='%d'\n", returnVal);
1469     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isspace  returnVal:='" << returnVal << "'";
1470 }
1471 
1472 /**
1473 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISSPACE_9400
1474 * @tc.name       test isspace api with horizontal tab
1475 * @tc.desc       [C- SOFTWARE -0200]
1476 */
1477 HWTEST_F(ActsUtilCheckApiTest, testIsspace9400, Function | MediumTest | Level1) {
1478     char paraVal;
1479     int returnVal;
1480 
1481     paraVal = '\t';
1482     returnVal = isspace(paraVal);
1483     LOGD("    isspace returnVal:='%d'\n", returnVal);
1484     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isspace  returnVal:='" << returnVal << "'";
1485 }
1486 
1487 /**
1488 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISSPACE_L_9500
1489 * @tc.name       test isspace_l api with lower alpha
1490 * @tc.desc       [C- SOFTWARE -0200]
1491 */
1492 HWTEST_F(ActsUtilCheckApiTest, testIsspaceL9500, Function | MediumTest | Level1) {
1493     char paraVal;
1494     int returnVal;
1495 
1496     paraVal = 'a';
1497     returnVal = isspace_l(paraVal, g_aucaLocale);
1498     LOGD("    isspace_l returnVal:='%d'\n", returnVal);
1499     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isspace_l  returnVal:='" << returnVal << "'";
1500 }
1501 
1502 /**
1503 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISSPACE_L_9600
1504 * @tc.name       test isspace_l api with space
1505 * @tc.desc       [C- SOFTWARE -0200]
1506 */
1507 HWTEST_F(ActsUtilCheckApiTest, testIsspaceL9600, Function | MediumTest | Level1) {
1508     char paraVal;
1509     int returnVal;
1510 
1511     paraVal = ' ';
1512     returnVal = isspace_l(paraVal, g_aucaLocale);
1513     LOGD("    isspace_l returnVal:='%d'\n", returnVal);
1514     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isspace_l  returnVal:='" << returnVal << "'";
1515 }
1516 
1517 /**
1518 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISSPACE_L_9620
1519 * @tc.name       test isspace_l api with LF
1520 * @tc.desc       [C- SOFTWARE -0200]
1521 */
1522 HWTEST_F(ActsUtilCheckApiTest, testIsspaceL9620, Function | MediumTest | Level1) {
1523     char paraVal;
1524     int returnVal;
1525 
1526     paraVal = '\n';
1527     returnVal = isspace_l(paraVal, g_aucaLocale);
1528     LOGD("    isspace_l returnVal:='%d'\n", returnVal);
1529     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isspace_l  returnVal:='" << returnVal << "'";
1530 }
1531 
1532 /**
1533 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISSPACE_L_9640
1534 * @tc.name       test isspace_l api with CR
1535 * @tc.desc       [C- SOFTWARE -0200]
1536 */
1537 HWTEST_F(ActsUtilCheckApiTest, testIsspaceL9640, Function | MediumTest | Level1) {
1538     char paraVal;
1539     int returnVal;
1540 
1541     paraVal = '\r';
1542     returnVal = isspace_l(paraVal, g_aucaLocale);
1543     LOGD("    isspace_l returnVal:='%d'\n", returnVal);
1544     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isspace_l  returnVal:='" << returnVal << "'";
1545 }
1546 
1547 /**
1548 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISSPACE_L_9660
1549 * @tc.name       test isspace_l api with form-feed
1550 * @tc.desc       [C- SOFTWARE -0200]
1551 */
1552 HWTEST_F(ActsUtilCheckApiTest, testIsspaceL9660, Function | MediumTest | Level1) {
1553     char paraVal;
1554     int returnVal;
1555 
1556     paraVal = '\f';
1557     returnVal = isspace_l(paraVal, g_aucaLocale);
1558     LOGD("    isspace_l returnVal:='%d'\n", returnVal);
1559     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isspace_l  returnVal:='" << returnVal << "'";
1560 }
1561 
1562 /**
1563 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISSPACE_L_9680
1564 * @tc.name       test isspace_l api with horizontal tab
1565 * @tc.desc       [C- SOFTWARE -0200]
1566 */
1567 HWTEST_F(ActsUtilCheckApiTest, testIsspaceL9680, Function | MediumTest | Level1) {
1568     char paraVal;
1569     int returnVal;
1570 
1571     paraVal = '\t';
1572     returnVal = isspace_l(paraVal, g_aucaLocale);
1573     LOGD("    isspace_l returnVal:='%d'\n", returnVal);
1574     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isspace_l  returnVal:='" << returnVal << "'";
1575 }
1576 
1577 /**
1578 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISUNORDERED_9700
1579 * @tc.name       test isunordered api with NAN and 0
1580 * @tc.desc       [C- SOFTWARE -0200]
1581 */
1582 HWTEST_F(ActsUtilCheckApiTest, testIsunordered9700, Function | MediumTest | Level1) {
1583     double paraVal1;
1584     double paraVal2;
1585     int returnVal;
1586 
1587     paraVal1 = NAN;
1588     paraVal2 = 0;
1589     returnVal = isunordered(paraVal1, paraVal2);
1590     LOGD("    isunordered returnVal:='%d'\n", returnVal);
1591     ASSERT_TRUE(1 == returnVal) << "ErrInfo: isunordered  returnVal:='" << returnVal << "'";
1592 }
1593 
1594 /**
1595 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISUPPER_9720
1596 * @tc.name       test isupper api with upper alpha
1597 * @tc.desc       [C- SOFTWARE -0200]
1598 */
1599 HWTEST_F(ActsUtilCheckApiTest, testIsupper9720, Function | MediumTest | Level1) {
1600     char paraVal;
1601     int returnVal;
1602 
1603     paraVal = 'A';
1604     returnVal = isupper(paraVal);
1605     LOGD("    isupper returnVal:='%d'\n", returnVal);
1606     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isupper  returnVal:='" << returnVal << "'";
1607 }
1608 
1609 /**
1610 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISUPPER_9740
1611 * @tc.name       test isupper api with lower alpha
1612 * @tc.desc       [C- SOFTWARE -0200]
1613 */
1614 HWTEST_F(ActsUtilCheckApiTest, testIsupper9740, Function | MediumTest | Level1) {
1615     char paraVal;
1616     int returnVal;
1617 
1618     paraVal = 'a';
1619     returnVal = isupper(paraVal);
1620     LOGD("    isupper returnVal:='%d'\n", returnVal);
1621     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isupper  returnVal:='" << returnVal << "'";
1622 }
1623 
1624 /**
1625 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISUPPER_9760
1626 * @tc.name       test isupper api with digit
1627 * @tc.desc       [C- SOFTWARE -0200]
1628 */
1629 HWTEST_F(ActsUtilCheckApiTest, testIsupper9760, Function | MediumTest | Level1) {
1630     char paraVal;
1631     int returnVal;
1632 
1633     paraVal = '5';
1634     returnVal = isupper(paraVal);
1635     LOGD("    isupper returnVal:='%d'\n", returnVal);
1636     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isupper  returnVal:='" << returnVal << "'";
1637 }
1638 
1639 /**
1640 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISUPPER_9780
1641 * @tc.name       test isupper api with LF
1642 * @tc.desc       [C- SOFTWARE -0200]
1643 */
1644 HWTEST_F(ActsUtilCheckApiTest, testIsupper9780, Function | MediumTest | Level1) {
1645     char paraVal;
1646     int returnVal;
1647 
1648     paraVal = '\n';
1649     returnVal = isupper(paraVal);
1650     LOGD("    isupper returnVal:='%d'\n", returnVal);
1651     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isupper  returnVal:='" << returnVal << "'";
1652 }
1653 
1654 /**
1655 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISUPPER_L_9800
1656 * @tc.name       test isupper_l api with upper alpha
1657 * @tc.desc       [C- SOFTWARE -0200]
1658 */
1659 HWTEST_F(ActsUtilCheckApiTest, testIsupperL9800, Function | MediumTest | Level1) {
1660     char paraVal;
1661     int returnVal;
1662 
1663     paraVal = 'A';
1664     returnVal = isupper_l(paraVal, g_aucaLocale);
1665     LOGD("    isupper_l returnVal:='%d'\n", returnVal);
1666     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isupper_l  returnVal:='" << returnVal << "'";
1667 }
1668 
1669 /**
1670 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISUPPER_L_9820
1671 * @tc.name       test isupper_l api with lower alpha
1672 * @tc.desc       [C- SOFTWARE -0200]
1673 */
1674 HWTEST_F(ActsUtilCheckApiTest, testIsupperL9820, Function | MediumTest | Level1) {
1675     char paraVal;
1676     int returnVal;
1677 
1678     paraVal = 'a';
1679     returnVal = isupper_l(paraVal, g_aucaLocale);
1680     LOGD("    isupper_l returnVal:='%d'\n", returnVal);
1681     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isupper_l  returnVal:='" << returnVal << "'";
1682 }
1683 
1684 /**
1685 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISUPPER_L_9840
1686 * @tc.name       test isupper_l api with digit
1687 * @tc.desc       [C- SOFTWARE -0200]
1688 */
1689 HWTEST_F(ActsUtilCheckApiTest, testIsupperL9840, Function | MediumTest | Level1) {
1690     char paraVal;
1691     int returnVal;
1692 
1693     paraVal = '5';
1694     returnVal = isupper_l(paraVal, g_aucaLocale);
1695     LOGD("    isupper_l returnVal:='%d'\n", returnVal);
1696     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isupper_l  returnVal:='" << returnVal << "'";
1697 }
1698 
1699 /**
1700 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISUPPER_L_9860
1701 * @tc.name       test isupper_l api with LF
1702 * @tc.desc       [C- SOFTWARE -0200]
1703 */
1704 HWTEST_F(ActsUtilCheckApiTest, testIsupperL9860, Function | MediumTest | Level1) {
1705     char paraVal;
1706     int returnVal;
1707 
1708     paraVal = '\n';
1709     returnVal = isupper_l(paraVal, g_aucaLocale);
1710     LOGD("    isupper_l returnVal:='%d'\n", returnVal);
1711     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isupper_l  returnVal:='" << returnVal << "'";
1712 }
1713 
1714 /**
1715 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISXDIGIT_9880
1716 * @tc.name       test isxdigit api with xdigit F
1717 * @tc.desc       [C- SOFTWARE -0200]
1718 */
1719 HWTEST_F(ActsUtilCheckApiTest, testIsxdigit9880, Function | MediumTest | Level1) {
1720     char paraVal;
1721     int returnVal;
1722 
1723     paraVal = 'F';
1724     returnVal = isxdigit(paraVal);
1725     LOGD("    isxdigit returnVal:='%d'\n", returnVal);
1726     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isxdigit  returnVal:='" << returnVal << "'";
1727 }
1728 
1729 /**
1730 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISXDIGIT_9900
1731 * @tc.name       test isxdigit api with alpha G
1732 * @tc.desc       [C- SOFTWARE -0200]
1733 */
1734 HWTEST_F(ActsUtilCheckApiTest, testIsxdigit9900, Function | MediumTest | Level1) {
1735     char paraVal;
1736     int returnVal;
1737 
1738     paraVal = 'G';
1739     returnVal = isxdigit(paraVal);
1740     LOGD("    isxdigit returnVal:='%d'\n", returnVal);
1741     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isxdigit  returnVal:='" << returnVal << "'";
1742 }
1743 
1744 /**
1745 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISXDIGIT_L_9920
1746 * @tc.name       test isxdigit_l api with xdigit F
1747 * @tc.desc       [C- SOFTWARE -0200]
1748 */
1749 HWTEST_F(ActsUtilCheckApiTest, testIsxdigitL9920, Function | MediumTest | Level1) {
1750     char paraVal;
1751     int returnVal;
1752 
1753     paraVal = 'F';
1754     returnVal = isxdigit_l(paraVal, g_aucaLocale);
1755     LOGD("    isxdigit_l returnVal:='%d'\n", returnVal);
1756     ASSERT_TRUE(returnVal != 0) << "ErrInfo: isxdigit_l  returnVal:='" << returnVal << "'";
1757 }
1758 
1759 /**
1760 * @tc.number     SUB_KERNEL_UTIL_CHECK_ISXDIGIT_L_9940
1761 * @tc.name       test isxdigit_l api with alpha G
1762 * @tc.desc       [C- SOFTWARE -0200]
1763 */
1764 HWTEST_F(ActsUtilCheckApiTest, testIsxdigitL19940, Function | MediumTest | Level1) {
1765     char paraVal;
1766     int returnVal;
1767 
1768     paraVal = 'G';
1769     returnVal = isxdigit_l(paraVal, g_aucaLocale);
1770     LOGD("    isxdigit_l returnVal:='%d'\n", returnVal);
1771     ASSERT_TRUE(0 == returnVal) << "ErrInfo: isxdigit_l  returnVal:='" << returnVal << "'";
1772 }