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