• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) Huawei Technologies Co., Ltd. 2020-2020. All rights reserved.
3  */
4 /*
5  * Copyright (c) 2021 Huawei Device Co., Ltd.
6  * Licensed under the Apache License, Version 2.0 (the "License");
7  * you may not use this file except in compliance with the License.
8  * You may obtain a copy of the License at
9  *
10  *     http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  */
18 
19 #include <stdlib.h>
20 #include <ctype.h>
21 #include <wctype.h>
22 #include <wchar.h>
23 #include <string.h>
24 
25 #include "gtest/gtest.h"
26 #include "log.h"
27 #include "utils.h"
28 
29 using namespace testing::ext;
30 
31 class ActsUtilConvertApiTest : public testing::Test {
32 public:
33     locale_t g_aucaNewloc;
34 protected:
35     // SetUpTestCase: Testsuit setup, run before 1st testcase
SetUpTestCase(void)36     static void SetUpTestCase(void)
37     {
38     }
39     // TearDownTestCase: Testsuit teardown, run after last testcase
TearDownTestCase(void)40     static void TearDownTestCase(void)
41     {
42     }
43     // Testcase setup
SetUp()44     virtual void SetUp()
45     {
46         g_aucaNewloc = newlocale(LC_ALL_MASK, "", (locale_t)0);
47     }
48     // Testcase teardown
TearDown()49     virtual void TearDown()
50     {
51         freelocale(g_aucaNewloc);
52     }
53 };
54 
55 /**
56 * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOLOWER_0100
57 * @tc.name       test _tolower api with upper alpha
58 * @tc.desc       [C- SOFTWARE -0200]
59 */
60 HWTEST_F(ActsUtilConvertApiTest, testTolower0100, Function | MediumTest | Level1) {
61     char paraChar;
62     int returnVal;
63 
64     paraChar = 'A';
65     returnVal = _tolower(paraChar);
66     LOGD("    _tolower c:='%c',   returnVal:='%c'\n", paraChar, returnVal);
67     ASSERT_TRUE('a' == returnVal) << "ErrInfo: _tolower  returnVal:='" << returnVal << "'";
68 }
69 
70 /**
71 * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOLOWER_0200
72 * @tc.name       test _tolower api with digit
73 * @tc.desc       [C- SOFTWARE -0200]
74 */
75 HWTEST_F(ActsUtilConvertApiTest, testTolower0200, Function | MediumTest | Level1) {
76     char paraChar;
77     int returnVal;
78 
79     paraChar = '5';
80     returnVal = _tolower(paraChar);
81     LOGD("    _tolower c:='%c',   returnVal:='%c'\n", paraChar, returnVal);
82     ASSERT_TRUE('5' == returnVal) << "ErrInfo: _tolower  returnVal:='" << returnVal << "'";
83 }
84 
85 /**
86 * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOLOWER_0300
87 * @tc.name       test _tolower api with lower alpha
88 * @tc.desc       [C- SOFTWARE -0200]
89 */
90 HWTEST_F(ActsUtilConvertApiTest, testTolower0300, Function | MediumTest | Level1) {
91     char paraChar;
92     int returnVal;
93 
94     paraChar = 'z';
95     returnVal = _tolower(paraChar);
96     LOGD("    _tolower c:='%c',   returnVal:='%c'\n", paraChar, returnVal);
97     ASSERT_TRUE('z' == returnVal) << "ErrInfo: _tolower  returnVal:='" << returnVal << "'";
98 }
99 
100 /* *
101  * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOLOWER_0310
102  * @tc.name       test _tolower api abnormal scenario with two uppercase characters
103  * @tc.desc       [C- SOFTWARE -0200]
104  */
105 HWTEST_F(ActsUtilConvertApiTest, testTolower0310, Function | MediumTest | Level1)
106 {
107     char paraChar;
108     int returnVal;
109 
110     paraChar = 'AZ';
111     returnVal = _tolower(paraChar);
112     LOGD("    _tolower c:='%c',   returnVal:='%c'/n", paraChar, returnVal);
113     EXPECT_FALSE('az' == returnVal) << "ErrInfo: _tolower  returnVal:='" << returnVal << "'";
114 }
115 
116 /* *
117  * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOLOWER_0320
118  * @tc.name       test _tolower api abnormal scenario with multiple digital characters
119  * @tc.desc       [C- SOFTWARE -0200]
120  */
121 HWTEST_F(ActsUtilConvertApiTest, testTolower0320, Function | MediumTest | Level1)
122 {
123     char paraChar;
124     int returnVal;
125 
126     paraChar = '22';
127     returnVal = _tolower(paraChar);
128     LOGD("    _tolower c:='%c',   returnVal:='%c'/n", paraChar, returnVal);
129     EXPECT_FALSE('22' == returnVal) << "ErrInfo: _tolower  returnVal:='" << returnVal << "'";
130 }
131 
132 /* *
133  * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOLOWER_0330
134  * @tc.name       test _tolower api abnormal scenario with special symbols characters
135  * @tc.desc       [C- SOFTWARE -0200]
136  */
137 HWTEST_F(ActsUtilConvertApiTest, testTolower0330, Function | MediumTest | Level1)
138 {
139     char paraChar;
140     int returnVal;
141 
142     paraChar = '@';
143     returnVal = _tolower(paraChar);
144     LOGD("    _tolower c:='%c',   returnVal:='%c'/n", paraChar, returnVal);
145     ASSERT_TRUE(96 == returnVal) << "ErrInfo: _tolower  returnVal:='" << returnVal << "'";
146 }
147 
148 
149 /**
150 * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOUPPER_0400
151 * @tc.name       test _toupper api with lower alpha
152 * @tc.desc       [C- SOFTWARE -0200]
153 */
154 HWTEST_F(ActsUtilConvertApiTest, testToupper0400, Function | MediumTest | Level1) {
155     char paraChar;
156     int returnVal;
157 
158     paraChar = 'a';
159     returnVal = _toupper(paraChar);
160     LOGD("    _toupper c:='%c',   returnVal:='%c'\n", paraChar, returnVal);
161     ASSERT_TRUE('A' == returnVal) << "ErrInfo: _toupper  returnVal:='" << returnVal << "'";
162 }
163 
164 /**
165 * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOUPPER_0500
166 * @tc.name       test _toupper api with upper alpha
167 * @tc.desc       [C- SOFTWARE -0200]
168 */
169 HWTEST_F(ActsUtilConvertApiTest, testToupper0500, Function | MediumTest | Level1) {
170     char paraChar;
171     int returnVal;
172 
173     paraChar = 'Z';
174     returnVal = _toupper(paraChar);
175     LOGD("    _toupper c:='%c',   returnVal:='%c'\n", paraChar, returnVal);
176     ASSERT_TRUE('Z' == returnVal) << "ErrInfo: _toupper  returnVal:='" << returnVal << "'";
177 }
178 
179 /* *
180  * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOUPPER_0510
181  * @tc.name       test _toupper api abnormal scenario with special symbols characters
182  * @tc.desc       [C- SOFTWARE -0200]
183  */
184 HWTEST_F(ActsUtilConvertApiTest, testToupper0510, Function | MediumTest | Level1)
185 {
186     char paraChar;
187     int returnVal;
188 
189     paraChar = '@';
190     returnVal = _toupper(paraChar);
191     LOGD("    _toupper c:='%c',   returnVal:='%c'/n", paraChar, returnVal);
192     ASSERT_TRUE('@' == returnVal) << "ErrInfo: _toupper  returnVal:='" << returnVal << "'";
193 }
194 
195 /* *
196  * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOUPPER_0520
197  * @tc.name       test _toupper api with ASCII
198  * @tc.desc       [C- SOFTWARE -0200]
199  */
200 HWTEST_F(ActsUtilConvertApiTest, testToupper0520, Function | MediumTest | Level1)
201 {
202     char paraChar;
203     int returnVal;
204 
205     paraChar = 50;
206     returnVal = _toupper(paraChar);
207     LOGD("    _toupper c:='%c',   returnVal:='%c'/n", paraChar, returnVal);
208     ASSERT_TRUE(18 == returnVal) << "ErrInfo: _toupper  returnVal:='" << returnVal << "'";
209 }
210 
211 /* *
212  * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOUPPER_0530
213  * @tc.name       test _toupper api abnormal scenario with multiple lowercase characters
214  * @tc.desc       [C- SOFTWARE -0200]
215  */
216 HWTEST_F(ActsUtilConvertApiTest, testToupper0530, Function | MediumTest | Level1)
217 {
218     char paraChar;
219     int returnVal;
220 
221     paraChar = 'aa';
222     returnVal = _toupper(paraChar);
223     LOGD("    _toupper c:='%c',   returnVal:='%c'/n", paraChar, returnVal);
224     EXPECT_FALSE('AA' == returnVal) << "ErrInfo: _toupper  returnVal:='" << returnVal << "'";
225 }
226 
227 /* *
228  * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOUPPER_0540
229  * @tc.name       test _toupper api abnormal scenario with multiple lowercase characters combination
230  * @tc.desc       [C- SOFTWARE -0200]
231  */
232 HWTEST_F(ActsUtilConvertApiTest, testToupper0540, Function | MediumTest | Level1)
233 {
234     char paraChar;
235     int returnVal;
236 
237     paraChar = 'az';
238     returnVal = _toupper(paraChar);
239     LOGD("    _toupper c:='%c',   returnVal:='%c'/n", paraChar, returnVal);
240     EXPECT_FALSE('AZ' == returnVal) << "ErrInfo: _toupper  returnVal:='" << returnVal << "'";
241 }
242 
243 /**
244 * @tc.number     SUB_KERNEL_UTIL_CONVERT_ATOF_0600
245 * @tc.name       test atof api with string
246 * @tc.desc       [C- SOFTWARE -0200]
247 */
248 HWTEST_F(ActsUtilConvertApiTest, testAtof0600, Function | MediumTest | Level1) {
249     const char *paraChar = nullptr;
250     double returnVal;
251 
252     paraChar = "abcde";
253     returnVal = atof(paraChar);
254     LOGD("    atof c:='%s',   returnVal:='%f'\n", paraChar, returnVal);
255     ASSERT_TRUE(0.000000 == returnVal) << "ErrInfo: atof  returnVal:='" << returnVal << "'";
256 }
257 
258 /**
259 * @tc.number     SUB_KERNEL_UTIL_CONVERT_ATOF_0700
260 * @tc.name       test atof api with empty string
261 * @tc.desc       [C- SOFTWARE -0200]
262 */
263 HWTEST_F(ActsUtilConvertApiTest, testAtof0700, Function | MediumTest | Level1) {
264     const char *paraChar = nullptr;
265     double returnVal;
266 
267     paraChar = "";
268     returnVal = atof(paraChar);
269     LOGD("    atof c:='%s',   returnVal:='%f'\n", paraChar, returnVal);
270     ASSERT_TRUE(0.000000 == returnVal) << "ErrInfo: atof  returnVal:='" << returnVal << "'";
271 }
272 
273 /**
274 * @tc.number     SUB_KERNEL_UTIL_CONVERT_ATOF_0800
275 * @tc.name       test atof api with digit2
276 * @tc.desc       [C- SOFTWARE -0200]
277 */
278 HWTEST_F(ActsUtilConvertApiTest, testAtof0800, Function | MediumTest | Level1) {
279     const char *paraChar = nullptr;
280     double returnVal;
281 
282     paraChar = "12345";
283     returnVal = atof(paraChar);
284     LOGD("    atof c:='%s',   returnVal:='%f'\n", paraChar, returnVal);
285     ASSERT_TRUE(12345.000000 == returnVal) << "ErrInfo: atof  returnVal:='" << returnVal << "'";
286 }
287 
288 /* *
289  * @tc.number     SUB_KERNEL_UTIL_CONVERT_ATOF_0810
290  * @tc.name       test atof api with digit1
291  * @tc.desc       [C- SOFTWARE -0200]
292  */
293 HWTEST_F(ActsUtilConvertApiTest, testAtof0810, Function | MediumTest | Level1)
294 {
295     const char *paraChar = nullptr;
296     double returnVal;
297 
298     paraChar = "xtstest abcde";
299     returnVal = atof(paraChar);
300     LOGD("    atof c:='%s',   returnVal:='%f'/n", paraChar, returnVal);
301     ASSERT_TRUE(0.000000 == returnVal) << "ErrInfo: atof  returnVal:='" << returnVal << "'";
302 }
303 
304 /* *
305  * @tc.number     SUB_KERNEL_UTIL_CONVERT_ATOF_0820
306  * @tc.name       test atof api with digit3
307  * @tc.desc       [C- SOFTWARE -0200]
308  */
309 HWTEST_F(ActsUtilConvertApiTest, testAtof0820, Function | MediumTest | Level1)
310 {
311     const char *paraChar = nullptr;
312     double returnVal;
313 
314     paraChar = "xtstest 123456";
315     returnVal = atof(paraChar);
316     LOGD("    atof c:='%s',   returnVal:='%f'/n", paraChar, returnVal);
317     ASSERT_TRUE(0.000000 == returnVal) << "ErrInfo: atof  returnVal:='" << returnVal << "'";
318 }
319 
320 /* *
321  * @tc.number     SUB_KERNEL_UTIL_CONVERT_ATOF_0830
322  * @tc.name       test atof api with digit4
323  * @tc.desc       [C- SOFTWARE -0200]
324  */
325 HWTEST_F(ActsUtilConvertApiTest, testAtof0830, Function | MediumTest | Level1)
326 {
327     const char *paraChar = nullptr;
328     double returnVal;
329 
330     paraChar = "123456    ";
331     returnVal = atof(paraChar);
332     LOGD("    atof c:='%s',   returnVal:='%f'/n", paraChar, returnVal);
333     ASSERT_TRUE(123456.000000 == returnVal) << "ErrInfo: atof  returnVal:='" << returnVal << "'";
334 }
335 
336 /* *
337  * @tc.number     SUB_KERNEL_UTIL_CONVERT_ATOF_0840
338  * @tc.name       test atof api with digit5
339  * @tc.desc       [C- SOFTWARE -0200]
340  */
341 HWTEST_F(ActsUtilConvertApiTest, testAtof0840, Function | MediumTest | Level1)
342 {
343     const char *paraChar = nullptr;
344     double returnVal;
345 
346     paraChar = "      abcde";
347     returnVal = atof(paraChar);
348     LOGD("    atof c:='%s',   returnVal:='%f'/n", paraChar, returnVal);
349     ASSERT_TRUE(0.000000 == returnVal) << "ErrInfo: atof  returnVal:='" << returnVal << "'";
350 }
351 
352 /* *
353  * @tc.number     SUB_KERNEL_UTIL_CONVERT_ATOF_0850
354  * @tc.name       test atof api with digit6
355  * @tc.desc       [C- SOFTWARE -0200]
356  */
357 HWTEST_F(ActsUtilConvertApiTest, testAtof0850, Function | MediumTest | Level1)
358 {
359     const char *paraChar = nullptr;
360     double returnVal;
361 
362     paraChar = "      abcde     ";
363     returnVal = atof(paraChar);
364     LOGD("    atof c:='%s',   returnVal:='%f'/n", paraChar, returnVal);
365     ASSERT_TRUE(0.000000 == returnVal) << "ErrInfo: atof  returnVal:='" << returnVal << "'";
366 }
367 
368 /* *
369  * @tc.number     SUB_KERNEL_UTIL_CONVERT_ATOF_0860
370  * @tc.name       test atof api with digit7
371  * @tc.desc       [C- SOFTWARE -0200]
372  */
373 HWTEST_F(ActsUtilConvertApiTest, testAtof0860, Function | MediumTest | Level1)
374 {
375     const char *paraChar = nullptr;
376     double returnVal;
377 
378     paraChar = "a";
379     returnVal = atof(paraChar);
380     LOGD("    atof c:='%s',   returnVal:='%f'/n", paraChar, returnVal);
381     ASSERT_TRUE(0.000000 == returnVal) << "ErrInfo: atof  returnVal:='" << returnVal << "'";
382 }
383 
384 /**
385 * @tc.number     SUB_KERNEL_UTIL_CONVERT_ATOL_0900
386 * @tc.name       test atol api with string
387 * @tc.desc       [C- SOFTWARE -0200]
388 */
389 HWTEST_F(ActsUtilConvertApiTest, testAtol0900, Function | MediumTest | Level1) {
390     const char *paraChar = nullptr;
391     long int returnVal;
392 
393     paraChar = "abcde";
394     returnVal = atol(paraChar);
395     LOGD("    atol c:='%s',   returnVal:='%ld'\n", paraChar, returnVal);
396     ASSERT_TRUE(0 == returnVal) << "ErrInfo: atol  returnVal:='" << returnVal << "'";
397 }
398 
399 /**
400 * @tc.number     SUB_KERNEL_UTIL_CONVERT_ATOL_1000
401 * @tc.name       test atol api with empty string
402 * @tc.desc       [C- SOFTWARE -0200]
403 */
404 HWTEST_F(ActsUtilConvertApiTest, testAtol1000, Function | MediumTest | Level1) {
405     const char *paraChar = nullptr;
406     long int returnVal;
407 
408     paraChar = "";
409     returnVal = atol(paraChar);
410     LOGD("    atol c:='%s',   returnVal:='%ld'\n", paraChar, returnVal);
411     ASSERT_TRUE(0 == returnVal) << "ErrInfo: atol  returnVal:='" << returnVal << "'";
412 }
413 
414 /**
415 * @tc.number     SUB_KERNEL_UTIL_CONVERT_ATOL_1100
416 * @tc.name       test atol api with digit9
417 * @tc.desc       [C- SOFTWARE -0200]
418 */
419 HWTEST_F(ActsUtilConvertApiTest, testAtol1100, Function | MediumTest | Level1) {
420     const char *paraChar = nullptr;
421     long int returnVal;
422 
423     paraChar = "12345";
424     returnVal = atol(paraChar);
425     LOGD("    atol c:='%s',   returnVal:='%ld'\n", paraChar, returnVal);
426     ASSERT_TRUE(12345 == returnVal) << "ErrInfo: atol  returnVal:='" << returnVal << "'";
427 }
428 
429 /* *
430  * @tc.number     SUB_KERNEL_UTIL_CONVERT_ATOL_0100
431  * @tc.name       test atol api with digit8
432  * @tc.desc       [C- SOFTWARE -0200]
433  */
434 HWTEST_F(ActsUtilConvertApiTest, testAtol0100, Function | MediumTest | Level1)
435 {
436     const char *paraChar = nullptr;
437     long int returnVal;
438 
439     paraChar = "12345.111";
440     returnVal = atol(paraChar);
441     LOGD("    atol c:='%s',   returnVal:='%ld'/n", paraChar, returnVal);
442     ASSERT_TRUE(12345 == returnVal) << "ErrInfo: atol  returnVal:='" << returnVal << "'";
443 }
444 
445 /* *
446  * @tc.number     SUB_KERNEL_UTIL_CONVERT_ATOL_0200
447  * @tc.name       test atol api with digit10
448  * @tc.desc       [C- SOFTWARE -0200]
449  */
450 HWTEST_F(ActsUtilConvertApiTest, testAtol0200, Function | MediumTest | Level1)
451 {
452     const char *paraChar = nullptr;
453     long int returnVal;
454 
455     paraChar = "-12345";
456     returnVal = atol(paraChar);
457     LOGD("    atol c:='%s',   returnVal:='%ld'/n", paraChar, returnVal);
458     ASSERT_TRUE(-12345 == returnVal) << "ErrInfo: atol  returnVal:='" << returnVal << "'";
459 }
460 
461 /**
462 * @tc.number     SUB_KERNEL_UTIL_CONVERT_ATOLL_1200
463 * @tc.name       test atoll api with string
464 * @tc.desc       [C- SOFTWARE -0200]
465 */
466 HWTEST_F(ActsUtilConvertApiTest, testAtoll1200, Function | MediumTest | Level1) {
467     const char *paraChar = nullptr;
468     long long int returnVal;
469 
470     paraChar = "abcde";
471     returnVal = atoll(paraChar);
472     LOGD("    atoll c:='%s',   returnVal:='%lld'\n", paraChar, returnVal);
473     ASSERT_TRUE(0 == returnVal) << "ErrInfo: atoll  returnVal:='" << returnVal << "'";
474 }
475 
476 /**
477 * @tc.number     SUB_KERNEL_UTIL_CONVERT_ATOLL_1300
478 * @tc.name       test atoll api with empty string
479 * @tc.desc       [C- SOFTWARE -0200]
480 */
481 HWTEST_F(ActsUtilConvertApiTest, testAtoll1300, Function | MediumTest | Level1) {
482     const char *paraChar = nullptr;
483     long long int returnVal;
484 
485     paraChar = "";
486     returnVal = atoll(paraChar);
487     LOGD("    atoll c:='%s',   returnVal:='%lld'\n", paraChar, returnVal);
488     ASSERT_TRUE(0 == returnVal) << "ErrInfo: atoll  returnVal:='" << returnVal << "'";
489 }
490 
491 /**
492 * @tc.number     SUB_KERNEL_UTIL_CONVERT_ATOLL_1400
493 * @tc.name       test atoll api with digit
494 * @tc.desc       [C- SOFTWARE -0200]
495 */
496 HWTEST_F(ActsUtilConvertApiTest, testAtoll1400, Function | MediumTest | Level1) {
497     const char *paraChar = nullptr;
498     long long int returnVal;
499 
500     paraChar = "1234567890";
501     returnVal = atoll(paraChar);
502     LOGD("    atoll c:='%s',   returnVal:='%lld'\n", paraChar, returnVal);
503     ASSERT_TRUE(1234567890 == returnVal) << "ErrInfo: atoll  returnVal:='" << returnVal << "'";
504 }
505 
506 /**
507 * @tc.number     SUB_KERNEL_UTIL_CONVERT_ECVT_1500
508 * @tc.name       test ecvt api with decimal double
509 * @tc.desc       [C- SOFTWARE -0200]
510 */
511 HWTEST_F(ActsUtilConvertApiTest, testEcvt1500, Function | MediumTest | Level1) {
512     char *returnVal = nullptr;
513     double paraValue;
514     int digitCount;
515     int paraDec;
516     int paraSign;
517 
518     paraValue = 12345.6789;
519     digitCount = 10;
520     returnVal = ecvt(paraValue, digitCount, &paraDec, &paraSign);
521     LOGD("    ecvt  paraValue:='%f',  digitCount:='%d',  paraDec = '%d',  paraSign = '%d',  returnVal:='%s'\n",
522         paraValue, digitCount, paraDec, paraSign, returnVal);
523     ASSERT_TRUE(strcmp(returnVal, "1234567890") == 0 && paraSign == 0 && paraDec == 5) <<
524         "ErrInfo: ecvt returnVal:='" << returnVal << "',  paraDec:='" << paraDec << "', paraSign:='" << paraSign << "'";
525 }
526 
527 /**
528 * @tc.number     SUB_KERNEL_UTIL_CONVERT_ECVT_1600
529 * @tc.name       test ecvt api with exponent double2
530 * @tc.desc       [C- SOFTWARE -0200]
531 */
532 HWTEST_F(ActsUtilConvertApiTest, testEcvt1600, Function | MediumTest | Level1) {
533     char *returnVal = nullptr;
534     double paraValue;
535     int digitCount;
536     int paraDec;
537     int paraSign;
538 
539     paraValue = -0.123e4;
540     digitCount = 5;
541     returnVal = ecvt(paraValue, digitCount, &paraDec, &paraSign);
542     LOGD("    ecvt  paraValue:='%d',  digitCount:='%d',  paraDec = '%d',  paraSign = '%d',  returnVal:='%s'\n",
543         paraValue, digitCount, returnVal, paraDec, paraSign);
544     ASSERT_TRUE(strcmp(returnVal, "12300") == 0 && paraSign == 1 && paraDec != 0) <<
545         "ErrInfo: ecvt returnVal:='" << returnVal << "',  paraDec:='" << paraDec << "', paraSign:='" << paraSign << "'";
546 }
547 
548 /* *
549  * @tc.number     SUB_KERNEL_UTIL_CONVERT_ECVT_1610
550  * @tc.name       test ecvt api with exponent double1
551  * @tc.desc       [C- SOFTWARE -0200]
552  */
553 HWTEST_F(ActsUtilConvertApiTest, testEcvt1610, Function | MediumTest | Level1)
554 {
555     int dec, sign;
556     char *returnVal;
557 
558     double paraValue = 3.1415926385;
559     int precision = 10;
560 
561     returnVal = ecvt(paraValue, precision, &dec, &sign);
562     LOGD("    ecvt  paraValue:='%f',  precision:='%d',  dec = '%d',  sign = '%d',  returnVal:='%s'/n", paraValue,
563         precision, dec, sign, returnVal);
564     ASSERT_TRUE(strcmp(returnVal, "3141592639") == 0 && dec == 1 && sign == 0) << "ErrInfo: ecvt returnVal:='" <<
565         returnVal << "',  dec:='" << dec << "', sign:='" << sign << "'";
566 }
567 
568 /* *
569  * @tc.number     SUB_KERNEL_UTIL_CONVERT_ECVT_1630
570  * @tc.name       test ecvt api with exponent double3
571  * @tc.desc       [C- SOFTWARE -0200]
572  */
573 HWTEST_F(ActsUtilConvertApiTest, testEcvt1630, Function | MediumTest | Level1)
574 {
575     int dec, sign;
576     char *returnVal;
577 
578     double paraValue = 0.0;
579     int precision = 10;
580 
581     returnVal = ecvt(paraValue, precision, &dec, &sign);
582     LOGD("    ecvt  paraValue:='%f',  precision:='%d',  dec = '%d',  sign = '%d',  returnVal:='%s'/n", paraValue,
583         precision, dec, sign, returnVal);
584     ASSERT_TRUE(strcmp(returnVal, "0000000000") == 0 && dec == 1 && sign == 0) << "ErrInfo: ecvt returnVal:='" <<
585         returnVal << "',  dec:='" << dec << "', sign:='" << sign << "'";
586 }
587 
588 /**
589 * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOASCII_1700
590 * @tc.name       test toascii api with digit
591 * @tc.desc       [C- SOFTWARE -0200]
592 */
593 HWTEST_F(ActsUtilConvertApiTest, testToascii1700, Function | MediumTest | Level1) {
594     char paraVal;
595     int returnVal;
596 
597     paraVal = 225;
598     returnVal = toascii(paraVal);
599     LOGD("    toascii returnVal:='%d'\n", returnVal);
600     ASSERT_TRUE(97 == returnVal) << "ErrInfo: toascii  returnVal:='" << returnVal << "'";
601 }
602 
603 /**
604 * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOLOWER_1800
605 * @tc.name       test tolower api with upper alpha
606 * @tc.desc       [C- SOFTWARE -0200]
607 */
608 HWTEST_F(ActsUtilConvertApiTest, testTolower1800, Function | MediumTest | Level1) {
609     char paraVal;
610     int returnVal;
611 
612     paraVal = 'A';
613     returnVal = tolower(paraVal);
614     LOGD("    tolower returnVal:='%d'\n", returnVal);
615     ASSERT_TRUE('a' == returnVal) << "ErrInfo: tolower  returnVal:='" << returnVal << "'";
616 }
617 
618 /**
619 * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOLOWER_1900
620 * @tc.name       test tolower api with lower alpha
621 * @tc.desc       [C- SOFTWARE -0200]
622 */
623 HWTEST_F(ActsUtilConvertApiTest, testTolower1900, Function | MediumTest | Level1) {
624     char paraVal;
625     int returnVal;
626 
627     paraVal = 'a';
628     returnVal = tolower(paraVal);
629     LOGD("    tolower returnVal:='%d'\n", returnVal);
630     ASSERT_TRUE('a' == returnVal) << "ErrInfo: tolower  returnVal:='" << returnVal << "'";
631 }
632 
633 /**
634 * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOLOWER_L_2000
635 * @tc.name       test tolower_l api with upper alpha
636 * @tc.desc       [C- SOFTWARE -0200]
637 */
638 HWTEST_F(ActsUtilConvertApiTest, testTolowerL2000, Function | MediumTest | Level1) {
639     char paraVal;
640     int returnVal;
641 
642     paraVal = 'A';
643     returnVal = tolower_l(paraVal, g_aucaNewloc);
644     LOGD("    tolower_l returnVal:='%d'\n", returnVal);
645     ASSERT_TRUE('a' == returnVal) << "ErrInfo: tolower_l  returnVal:='" << returnVal << "'";
646 }
647 
648 /**
649 * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOLOWER_L_2100
650 * @tc.name       test tolower_l api with lower alpha
651 * @tc.desc       [C- SOFTWARE -0200]
652 */
653 HWTEST_F(ActsUtilConvertApiTest, testTolowerL2100, Function | MediumTest | Level1) {
654     char paraVal;
655     int returnVal;
656 
657     paraVal = 'a';
658     returnVal = tolower_l(paraVal, g_aucaNewloc);
659     LOGD("    tolower_l returnVal:='%d'\n", returnVal);
660     ASSERT_TRUE('a' == returnVal) << "ErrInfo: tolower_l  returnVal:='" << returnVal << "'";
661 }
662 
663 /**
664 * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOUPPER_2200
665 * @tc.name       test toupper api with upper alpha
666 * @tc.desc       [C- SOFTWARE -0200]
667 */
668 HWTEST_F(ActsUtilConvertApiTest, testToupper2200, Function | MediumTest | Level1) {
669     char paraVal;
670     int returnVal;
671 
672     paraVal = 'A';
673     returnVal = toupper(paraVal);
674     LOGD("    toupper returnVal:='%d'\n", returnVal);
675     ASSERT_TRUE('A' == returnVal) << "ErrInfo: toupper  returnVal:='" << returnVal << "'";
676 }
677 
678 /**
679 * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOUPPER_2300
680 * @tc.name       test toupper api with lower alpha
681 * @tc.desc       [C- SOFTWARE -0200]
682 */
683 HWTEST_F(ActsUtilConvertApiTest, testToupper2300, Function | MediumTest | Level1) {
684     char paraVal;
685     int returnVal;
686 
687     paraVal = 'a';
688     returnVal = toupper(paraVal);
689     LOGD("    toupper returnVal:='%d'\n", returnVal);
690     ASSERT_TRUE('A' == returnVal) << "ErrInfo: toupper  returnVal:='" << returnVal << "'";
691 }
692 
693 /**
694 * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOUPPER_L_2400
695 * @tc.name       test toupper_l api with upper alpha
696 * @tc.desc       [C- SOFTWARE -0200]
697 */
698 HWTEST_F(ActsUtilConvertApiTest, testToupperL2400, Function | MediumTest | Level1) {
699     char paraVal;
700     int returnVal;
701 
702     paraVal = 'A';
703     returnVal = toupper_l(paraVal, g_aucaNewloc);
704     LOGD("    toupper_l returnVal:='%d'\n", returnVal);
705     ASSERT_TRUE('A' == returnVal) << "ErrInfo: toupper_l  returnVal:='" << returnVal << "'";
706 }
707 
708 /**
709 * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOUPPER_L_2500
710 * @tc.name       test toupper_l api with lower alpha
711 * @tc.desc       [C- SOFTWARE -0200]
712 */
713 HWTEST_F(ActsUtilConvertApiTest, testToupperL2500, Function | MediumTest | Level1) {
714     char paraVal;
715     int returnVal;
716 
717     paraVal = 'a';
718     returnVal = toupper_l(paraVal, g_aucaNewloc);
719     LOGD("    toupper_l returnVal:='%d'\n", returnVal);
720     ASSERT_TRUE('A' == returnVal) << "ErrInfo: toupper_l  returnVal:='" << returnVal << "'";
721 }
722 
723 /**
724 * @tc.number     SUB_KERNEL_UTIL_CONVERT_L64A_2600
725 * @tc.name       test l64a api with zero
726 * @tc.desc       [C- SOFTWARE -0200]
727 */
728 HWTEST_F(ActsUtilConvertApiTest, testL64a2600, Function | MediumTest | Level1) {
729     long paraVal;
730     char *returnVal;
731 
732     paraVal = 0;
733     returnVal = l64a(paraVal);
734     LOGD("    l64a returnVal:='%s'\n", returnVal);
735     ASSERT_TRUE(strcmp("", returnVal) == 0) << "ErrInfo: l64a  returnVal:='" << returnVal << "'";
736 }
737 
738 /**
739 * @tc.number     SUB_KERNEL_UTIL_CONVERT_L64A_2700
740 * @tc.name       test l64a api with decimal
741 * @tc.desc       [C- SOFTWARE -0200]
742 */
743 HWTEST_F(ActsUtilConvertApiTest, testL64a2700, Function | MediumTest | Level1) {
744     long paraVal;
745     char *returnVal;
746 
747     paraVal = 12345;
748     returnVal = l64a(paraVal);
749     LOGD("    l64a returnVal:='%s'\n", returnVal);
750     ASSERT_TRUE(strcmp("t.1", returnVal) == 0) << "ErrInfo: l64a  returnVal:='" << returnVal << "'";
751 }
752 
753 /**
754 * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOWLOWER_2800
755 * @tc.name       test towlower api with upper alpha
756 * @tc.desc       [C- SOFTWARE -0200]
757 */
758 HWTEST_F(ActsUtilConvertApiTest, testTowlower2800, Function | MediumTest | Level1) {
759     wint_t wideChar;
760     wint_t returnVal;
761 
762     wideChar = 'A';
763     returnVal = towlower(wideChar);
764     LOGD("    towlower returnVal:='%c'\n", returnVal);
765     ASSERT_TRUE('a' == returnVal) << "ErrInfo: towlower  returnVal:='" << returnVal << "'";
766 }
767 
768 /**
769 * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOWLOWER_2900
770 * @tc.name       test towlower api with lower alpha
771 * @tc.desc       [C- SOFTWARE -0200]
772 */
773 HWTEST_F(ActsUtilConvertApiTest, testTowlower2900, Function | MediumTest | Level1) {
774     wint_t wideChar;
775     wint_t returnVal;
776 
777     wideChar = 'a';
778     returnVal = towlower(wideChar);
779     LOGD("    towlower returnVal:='%c'\n", returnVal);
780     ASSERT_TRUE('a' == returnVal) << "ErrInfo: towlower  returnVal:='" << returnVal << "'";
781 }
782 
783 /**
784 * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOWLOWER_L_3000
785 * @tc.name       test towlower_l api with upper alpha
786 * @tc.desc       [C- SOFTWARE -0200]
787 */
788 HWTEST_F(ActsUtilConvertApiTest, testTowlowerL3000, Function | MediumTest | Level1) {
789     wint_t wideChar;
790     wint_t returnVal;
791 
792     wideChar = 'A';
793     returnVal = towlower_l(wideChar, g_aucaNewloc);
794     LOGD("    towlower_l returnVal:='%c'\n", returnVal);
795     ASSERT_TRUE('a' == returnVal) << "ErrInfo: towlower_l  returnVal:='" << returnVal << "'";
796 }
797 
798 /**
799 * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOWLOWER_L_3100
800 * @tc.name       test towlower_l api with lower alpha
801 * @tc.desc       [C- SOFTWARE -0200]
802 */
803 HWTEST_F(ActsUtilConvertApiTest, testTowlowerL3100, Function | MediumTest | Level1) {
804     wint_t wideChar;
805     wint_t returnVal;
806 
807     wideChar = 'a';
808     returnVal = towlower_l(wideChar, g_aucaNewloc);
809     LOGD("    towlower_l returnVal:='%c'\n", returnVal);
810     ASSERT_TRUE('a' == returnVal) << "ErrInfo: towlower_l  returnVal:='" << returnVal << "'";
811 }
812 
813 /**
814 * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOWUPPER_3200
815 * @tc.name       test towupper api with upper alpha
816 * @tc.desc       [C- SOFTWARE -0200]
817 */
818 HWTEST_F(ActsUtilConvertApiTest, testTowupper3200, Function | MediumTest | Level1) {
819     wint_t wideChar;
820     wint_t returnVal;
821 
822     wideChar = 'A';
823     returnVal = towupper(wideChar);
824     LOGD("    towupper returnVal:='%c'\n", returnVal);
825     ASSERT_TRUE('A' == returnVal) << "ErrInfo: towupper  returnVal:='" << returnVal << "'";
826 }
827 
828 /**
829 * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOWUPPER_3300
830 * @tc.name       test towupper api with lower alpha
831 * @tc.desc       [C- SOFTWARE -0200]
832 */
833 HWTEST_F(ActsUtilConvertApiTest, testTowupper3300, Function | MediumTest | Level1) {
834     wint_t wideChar;
835     wint_t returnVal;
836 
837     wideChar = 'a';
838     returnVal = towupper(wideChar);
839     LOGD("    towupper returnVal:='%c'\n", returnVal);
840     ASSERT_TRUE('A' == returnVal) << "ErrInfo: towupper  returnVal:='" << returnVal << "'";
841 }
842 
843 /**
844 * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOWUPPER_L_3400
845 * @tc.name       test towupper_l api with upper alpha
846 * @tc.desc       [C- SOFTWARE -0200]
847 */
848 HWTEST_F(ActsUtilConvertApiTest, testTowupperL3400, Function | MediumTest | Level1) {
849     wint_t wideChar;
850     wint_t returnVal;
851 
852     wideChar = 'A';
853     returnVal = towupper_l(wideChar, g_aucaNewloc);
854     LOGD("    towupper_l returnVal:='%c'\n", returnVal);
855     ASSERT_TRUE('A' == returnVal) << "ErrInfo: towupper_l  returnVal:='" << returnVal << "'";
856 }
857 
858 /**
859 * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOWUPPER_L_3500
860 * @tc.name       test towupper_l api with lower alpha
861 * @tc.desc       [C- SOFTWARE -0200]
862 */
863 HWTEST_F(ActsUtilConvertApiTest, testTowupperL3500, Function | MediumTest | Level1) {
864     wint_t wideChar;
865     wint_t returnVal;
866 
867     wideChar = 'a';
868     returnVal = towupper_l(wideChar, g_aucaNewloc);
869     LOGD("    towupper_l returnVal:='%c'\n", returnVal);
870     ASSERT_TRUE('A' == returnVal) << "ErrInfo: towupper_l  returnVal:='" << returnVal << "'";
871 }
872 
873 /**
874 * @tc.number     SUB_KERNEL_UTIL_CONVERT_MBTOWC_3600
875 * @tc.name       test mbtowc api with alpha
876 * @tc.desc       [C- SOFTWARE -0200]
877 */
878 HWTEST_F(ActsUtilConvertApiTest, testMbtowc3600, Function | MediumTest | Level1) {
879     wchar_t wideChar;
880     const char *paraStr = "a";
881     size_t sizeVal;
882     int returnVal;
883 
884     wideChar = 'a';
885     sizeVal = 1;
886     returnVal = mbtowc(&wideChar, paraStr, sizeVal);
887     LOGD("    mbtowc returnVal:='%d'\n", returnVal);
888     ASSERT_TRUE(1 == returnVal && L'a' == wideChar) << "ErrInfo: mbtowc  returnVal:='" << returnVal << "'";
889 }
890 
891 /**
892 * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOWCTRANS_3700
893 * @tc.name       test towctrans api with WEOF
894 * @tc.desc       [C- SOFTWARE -0200]
895 */
896 HWTEST_F(ActsUtilConvertApiTest, testTowctrans3700, Function | MediumTest | Level1) {
897     wint_t wideChar;
898     wctrans_t paraDesc;
899     wint_t returnVal;
900 
901     wideChar = WEOF;
902     paraDesc = wctrans("tolower");
903     returnVal = towctrans(wideChar, paraDesc);
904     LOGD("    towctrans returnVal:='%d'\n", returnVal);
905     ASSERT_TRUE(WEOF == returnVal) << "ErrInfo: towctrans  returnVal:='" << returnVal << "'";
906 }
907 
908 /**
909 * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOWCTRANS_3800
910 * @tc.name       test towctrans api with upper alpha
911 * @tc.desc       [C- SOFTWARE -0200]
912 */
913 HWTEST_F(ActsUtilConvertApiTest, testTowctrans3800, Function | MediumTest | Level1) {
914     wint_t wideChar;
915     wctrans_t paraDesc;
916     wint_t returnVal;
917 
918     wideChar = L'A';
919     paraDesc = wctrans("tolower");
920     returnVal = towctrans(wideChar, paraDesc);
921     LOGD("    towctrans returnVal:='%d'\n", returnVal);
922     ASSERT_TRUE('a' == returnVal) << "ErrInfo: towctrans  returnVal:='" << returnVal << "'";
923 }
924 
925 /**
926 * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOWCTRANS_3900
927 * @tc.name       test towctrans api with lower alpha
928 * @tc.desc       [C- SOFTWARE -0200]
929 */
930 HWTEST_F(ActsUtilConvertApiTest, testTowctrans3900, Function | MediumTest | Level1) {
931     wint_t wideChar;
932     wctrans_t paraDesc;
933     wint_t returnVal;
934 
935     wideChar = L'a';
936     paraDesc = wctrans("toupper");
937     returnVal = towctrans(wideChar, paraDesc);
938     LOGD("    towctrans returnVal:='%d'\n", returnVal);
939     ASSERT_TRUE('A' == returnVal) << "ErrInfo: towctrans  returnVal:='" << returnVal << "'";
940 }
941 
942 /**
943 * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOWCTRANS_L_4000
944 * @tc.name       test towctrans_l api with WEOF
945 * @tc.desc       [C- SOFTWARE -0200]
946 */
947 HWTEST_F(ActsUtilConvertApiTest, testTowctransL4000, Function | MediumTest | Level1) {
948     wint_t wideChar;
949     wctrans_t paraDesc;
950     wint_t returnVal;
951 
952     wideChar = WEOF;
953     paraDesc = wctrans_l("tolower", g_aucaNewloc);
954     returnVal = towctrans_l(wideChar, paraDesc, g_aucaNewloc);
955     LOGD("    towctrans_l returnVal:='%d'\n", returnVal);
956     ASSERT_TRUE(WEOF == returnVal) << "ErrInfo: towctrans_l  returnVal:='" << returnVal << "'";
957 }
958 
959 /**
960 * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOWCTRANS_L_4100
961 * @tc.name       test towctrans_l api with upper alpha
962 * @tc.desc       [C- SOFTWARE -0200]
963 */
964 HWTEST_F(ActsUtilConvertApiTest, testTowctransL4100, Function | MediumTest | Level1) {
965     wint_t wideChar;
966     wctrans_t paraDesc;
967     wint_t returnVal;
968 
969     wideChar = L'A';
970     paraDesc = wctrans_l("tolower", g_aucaNewloc);
971     returnVal = towctrans_l(wideChar, paraDesc, g_aucaNewloc);
972     LOGD("    towctrans_l returnVal:='%d'\n", returnVal);
973     ASSERT_TRUE('a' == returnVal) << "ErrInfo: towctrans_l  returnVal:='" << returnVal << "'";
974 }
975 
976 /**
977 * @tc.number     SUB_KERNEL_UTIL_CONVERT_TOWCTRANS_L_4200
978 * @tc.name       test towctrans_l api with lower alpha
979 * @tc.desc       [C- SOFTWARE -0200]
980 */
981 HWTEST_F(ActsUtilConvertApiTest, testTowctransL4200, Function | MediumTest | Level1) {
982     wint_t wideChar;
983     wctrans_t paraDesc;
984     wint_t returnVal;
985 
986     wideChar = L'a';
987     paraDesc = wctrans_l("toupper", g_aucaNewloc);
988     returnVal = towctrans_l(wideChar, paraDesc, g_aucaNewloc);
989     LOGD("    towctrans_l returnVal:='%d'\n", returnVal);
990     ASSERT_TRUE('A' == returnVal) << "ErrInfo: towctrans_l  returnVal:='" << returnVal << "'";
991 }
992 
993 /**
994 * @tc.number     SUB_KERNEL_UTIL_CONVERT_WCTOB_4300
995 * @tc.name       test wctob api with lower alpha
996 * @tc.desc       [C- SOFTWARE -0200]
997 */
998 HWTEST_F(ActsUtilConvertApiTest, testWctob4300, Function | MediumTest | Level1) {
999     wint_t wideChar;
1000     int returnVal;
1001 
1002     wideChar = L'a';
1003     returnVal = wctob(wideChar);
1004     LOGD("    wctob returnVal:='%d'\n", returnVal);
1005     ASSERT_TRUE('a' == returnVal) << "ErrInfo: wctob  returnVal:='" << returnVal << "'";
1006 }
1007 
1008 /**
1009 * @tc.number     SUB_KERNEL_UTIL_CONVERT_WCTOMB_4400
1010 * @tc.name       test wctomb api with lower alpha
1011 * @tc.desc       [C- SOFTWARE -0200]
1012 */
1013 HWTEST_F(ActsUtilConvertApiTest, testWctomb4400, Function | MediumTest | Level1) {
1014     char paraStr[5];
1015     wint_t wideChar;
1016     int returnVal;
1017 
1018     wideChar = L'a';
1019     returnVal = wctomb(paraStr, wideChar);
1020     LOGD("    wctomb returnVal:='%d'\n", returnVal);
1021     ASSERT_TRUE(1 == returnVal && 'a' == paraStr[0]) << "ErrInfo: wctomb  returnVal:='" << returnVal << "'";
1022 }
1023 
1024 /**
1025 * @tc.number     SUB_KERNEL_UTIL_CONVERT_MBSTOWCS_4500
1026 * @tc.name       test mbstowcs api with string
1027 * @tc.desc       [C- SOFTWARE -0200]
1028 */
1029 HWTEST_F(ActsUtilConvertApiTest, testMbstowcs4500, Function | MediumTest | Level1) {
1030     wchar_t paraDest[10];
1031     const char *paraSrc = "abcde";
1032     size_t sizeVal = 6;
1033     size_t returnVal;
1034 
1035     returnVal = mbstowcs(paraDest, paraSrc, sizeVal);
1036     LOGD("    mbstowcs returnVal:='%d'\n", returnVal);
1037     ASSERT_TRUE(5 == returnVal && (0 == wcscmp(paraDest, L"abcde")))
1038         << "ErrInfo: mbstowcs  returnVal:='" << returnVal << "'";
1039 }
1040 
1041 /**
1042 * @tc.number     SUB_KERNEL_UTIL_CONVERT_WCSTOMBS_4600
1043 * @tc.name       test wcstombs api with string
1044 * @tc.desc       [C- SOFTWARE -0200]
1045 */
1046 HWTEST_F(ActsUtilConvertApiTest, testWcstombs4600, Function | MediumTest | Level1) {
1047     char paraDest[10];
1048     const wchar_t *paraSrc = L"abcde";
1049     size_t sizeVal = 6;
1050     size_t returnVal;
1051 
1052     returnVal = wcstombs(paraDest, paraSrc, sizeVal);
1053     LOGD("    wcstombs returnVal:='%d'\n", returnVal);
1054     ASSERT_TRUE(5 == returnVal && (0 == strcmp(paraDest, "abcde")))
1055         << "ErrInfo: wcstombs  returnVal:='" << returnVal << "'";
1056 }
1057 
1058 /**
1059 * @tc.number     SUB_KERNEL_UTIL_CONVERT_WCRTOMB_4700
1060 * @tc.name       test wcrtomb api with lower alpha
1061 * @tc.desc       [C- SOFTWARE -0200]
1062 */
1063 HWTEST_F(ActsUtilConvertApiTest, testWcrtomb4700, Function | MediumTest | Level1) {
1064     char paraStr[2];
1065     wchar_t wideChar;
1066     mbstate_t paraPs;
1067     size_t returnVal;
1068 
1069     wideChar = L'a';
1070 
1071     returnVal = wcrtomb(paraStr, wideChar, &paraPs);
1072     LOGD("    wcrtomb returnVal:='%d'\n", returnVal);
1073     ASSERT_TRUE(1 == returnVal && 'a' == paraStr[0]) << "ErrInfo: wcrtomb  returnVal:='" << returnVal << "'";
1074 }
1075