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