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
24using namespace testing::ext;
25
26class ActsUtilCheckApiTest : public testing::Test {
27public:
28    locale_t g_aucaLocale;
29protected:
30    // SetUpTestCase: Testsuit setup, run before 1st testcase
31    static void SetUpTestCase(void)
32    {
33    }
34    // TearDownTestCase: Testsuit teardown, run after last testcase
35    static void TearDownTestCase(void)
36    {
37    }
38    // Testcase setup
39    virtual void SetUp()
40    {
41        g_aucaLocale = newlocale(LC_ALL_MASK, "", (locale_t)0);
42    }
43    // Testcase 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*/
55HWTEST_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*/
70HWTEST_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*/
85HWTEST_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*/
100HWTEST_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*/
115HWTEST_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*/
130HWTEST_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*/
145HWTEST_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*/
160HWTEST_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*/
175HWTEST_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*/
190HWTEST_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*/
205HWTEST_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*/
220HWTEST_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*/
235HWTEST_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*/
250HWTEST_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*/
265HWTEST_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*/
280HWTEST_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*/
295HWTEST_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*/
310HWTEST_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*/
325HWTEST_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*/
340HWTEST_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*/
355HWTEST_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*/
370HWTEST_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*/
398HWTEST_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*/
413HWTEST_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*/
428HWTEST_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*/
443HWTEST_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*/
458HWTEST_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*/
473HWTEST_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*/
488HWTEST_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*/
503HWTEST_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*/
518HWTEST_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*/
533HWTEST_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*/
548HWTEST_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*/
563HWTEST_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*/
578HWTEST_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*/
593HWTEST_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*/
608HWTEST_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*/
623HWTEST_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*/
638HWTEST_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*/
653HWTEST_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*/
668HWTEST_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*/
683HWTEST_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*/
698HWTEST_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*/
713HWTEST_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*/
728HWTEST_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*/
743HWTEST_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*/
758HWTEST_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*/
773HWTEST_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*/
788HWTEST_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*/
803HWTEST_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*/
818HWTEST_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*/
835HWTEST_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*/
852HWTEST_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*/
869HWTEST_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*/
886HWTEST_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*/
903HWTEST_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*/
920HWTEST_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*/
935HWTEST_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*/
952HWTEST_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*/
969HWTEST_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*/
986HWTEST_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*/
1003HWTEST_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*/
1020HWTEST_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*/
1037HWTEST_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*/
1052HWTEST_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*/
1067HWTEST_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*/
1082HWTEST_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*/
1097HWTEST_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*/
1112HWTEST_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*/
1127HWTEST_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*/
1142HWTEST_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*/
1157HWTEST_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*/
1172HWTEST_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*/
1187HWTEST_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*/
1202HWTEST_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*/
1217HWTEST_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*/
1232HWTEST_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*/
1247HWTEST_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*/
1262HWTEST_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*/
1277HWTEST_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*/
1292HWTEST_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*/
1307HWTEST_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*/
1322HWTEST_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*/
1337HWTEST_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*/
1352HWTEST_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*/
1367HWTEST_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*/
1382HWTEST_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*/
1397HWTEST_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*/
1412HWTEST_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*/
1427HWTEST_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*/
1442HWTEST_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*/
1457HWTEST_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*/
1472HWTEST_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*/
1487HWTEST_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*/
1502HWTEST_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*/
1517HWTEST_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*/
1532HWTEST_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*/
1547HWTEST_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*/
1562HWTEST_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*/
1577HWTEST_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*/
1594HWTEST_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*/
1609HWTEST_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*/
1624HWTEST_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*/
1639HWTEST_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*/
1654HWTEST_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*/
1669HWTEST_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*/
1684HWTEST_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*/
1699HWTEST_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*/
1714HWTEST_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*/
1729HWTEST_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*/
1744HWTEST_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*/
1759HWTEST_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}