1 /*
2  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
3  * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without modification,
6  * are permitted provided that the following conditions are met:
7  *
8  * 1. Redistributions of source code must retain the above copyright notice, this list of
9  *    conditions and the following disclaimer.
10  *
11  * 2. Redistributions in binary form must reproduce the above copyright notice, this list
12  *    of conditions and the following disclaimer in the documentation and/or other materials
13  *    provided with the distribution.
14  *
15  * 3. Neither the name of the copyright holder nor the names of its contributors may be used
16  *    to endorse or promote products derived from this software without specific prior written
17  *    permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
21  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
23  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
26  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
27  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
28  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
29  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31 
32 #include "ohos_types.h"
33 #include "posix_test.h"
34 #include "los_config.h"
35 #include "kernel_test.h"
36 #include "ctype.h"
37 #include "errno.h"
38 #include "limits.h"
39 #include "stdlib.h"
40 #include "string.h"
41 #include "log.h"
42 
43 /* *
44  * @tc.desc      : register a test suite, this suite is used to test basic flow and interface dependency
45  * @param        : subsystem name is utils
46  * @param        : module name is utilsFile
47  * @param        : test suit name is CmsisTaskFuncTestSuite
48  */
49 LITE_TEST_SUIT(Posix, Posixtimer, PosixStdlibStrtoullTest);
50 
51 /* *
52  * @tc.setup     : setup for all testcases
53  * @return       : setup result, TRUE is success, FALSE is fail
54  */
PosixStdlibStrtoullTestSetUp(void)55 static BOOL PosixStdlibStrtoullTestSetUp(void)
56 {
57     return TRUE;
58 }
59 
60 /* *
61  * @tc.teardown  : teardown for all testcases
62  * @return       : teardown result, TRUE is success, FALSE is fail
63  */
PosixStdlibStrtoullTestTearDown(void)64 static BOOL PosixStdlibStrtoullTestTearDown(void)
65 {
66     LOG("+-------------------------------------------+\n");
67     return TRUE;
68 }
69 
70 /* *
71  * @tc.number    : TEST_STDLIB_STRTOULL_001
72  * @tc.name      : convert string by Strtoull
73  * @tc.desc      : [C- SOFTWARE -0200]
74  */
75 LITE_TEST_CASE(PosixStdlibStrtoullTest, testStdlibStrtoull001, Function | MediumTest | Level1)
76 {
77     char nPtr[] = "12 0110 0XDEFE 0666 1.6";
78     char *endPtr = NULL;
79     unsigned long long ret = strtoull(nPtr, &endPtr, 10);
80     if (ret == 12ULL) {
81         LOG("[DEMO] posix stdlib test case 1:strtoull(base=10) ret:%llu,%s, endPtr:%s ok.\n", ret, nPtr, endPtr);
82     } else {
83         LOG("[DEMO] posix stdlib test case 1:strtoull(base=10) ret:%llu,%s fail.\n", ret, nPtr);
84     }
85     ICUNIT_ASSERT_EQUAL(ret, 12ULL, 0);
86     ICUNIT_ASSERT_STRING_EQUAL(endPtr, " 0110 0XDEFE 0666 1.6", 0);
87     return 0;
88 }
89 
90 /* *
91  * @tc.number    : TEST_STDLIB_STRTOULL_002
92  * @tc.name      : convert string by Strtoull
93  * @tc.desc      : [C- SOFTWARE -0200]
94  */
95 LITE_TEST_CASE(PosixStdlibStrtoullTest, testStdlibStrtoull002, Function | MediumTest | Level1)
96 {
97     char nPtr[] = " 0110 0XDEFE 0666 1.6";
98     char *endPtr = NULL;
99     unsigned long long ret = strtoull(nPtr, &endPtr, 2);
100     if (ret == 6ULL) {
101         LOG("[DEMO] posix stdlib test case 2:strtoull(base=2) ret:%llu,%s, endPtr:%s ok.\n", ret, nPtr, endPtr);
102     } else {
103         LOG("[DEMO] posix stdlib test case 2:strtoull(base=2) ret:%llu,%s fail.\n", ret, nPtr);
104     }
105     ICUNIT_ASSERT_EQUAL(ret, 6ULL, 0);
106     ICUNIT_ASSERT_STRING_EQUAL(endPtr, " 0XDEFE 0666 1.6", 0);
107     return 0;
108 }
109 
110 /* *
111  * @tc.number    : TEST_STDLIB_STRTOULL_003
112  * @tc.name      : convert string by Strtoull
113  * @tc.desc      : [C- SOFTWARE -0200]
114  */
115 LITE_TEST_CASE(PosixStdlibStrtoullTest, testStdlibStrtoull003, Function | MediumTest | Level1)
116 {
117     char nPtr[] = " 0XDEFE 0666 1.6";
118     char *endPtr = NULL;
119     unsigned long long ret = strtoull(nPtr, &endPtr, 16);
120     if (ret == 0XDEFEULL) {
121         LOG("[DEMO] posix stdlib test case 3:strtoull(base=16) ret:%llu,%s, endPtr:%s ok.\n", ret, nPtr, endPtr);
122     } else {
123         LOG("[DEMO] posix stdlib test case 3:strtoull(base=16) ret:%llu,%s fail.\n", ret, nPtr);
124     }
125     ICUNIT_ASSERT_EQUAL(ret, 0XDEFEULL, 0);
126     ICUNIT_ASSERT_STRING_EQUAL(endPtr, " 0666 1.6", 0);
127     return 0;
128 }
129 
130 /* *
131  * @tc.number    : TEST_STDLIB_STRTOULL_004
132  * @tc.name      : convert string by Strtoull
133  * @tc.desc      : [C- SOFTWARE -0200]
134  */
135 LITE_TEST_CASE(PosixStdlibStrtoullTest, testStdlibStrtoull004, Function | MediumTest | Level1)
136 {
137     char nPtr[] = " 0666 1.6";
138     char *endPtr = NULL;
139     unsigned long long ret = strtoull(nPtr, &endPtr, 8);
140     if (ret == 0666ULL) {
141         LOG("[DEMO] posix stdlib test case 4:strtoull(base=8) ret:%llu,%s, endPtr:%s ok.\n", ret, nPtr, endPtr);
142     } else {
143         LOG("[DEMO] posix stdlib test case 4:strtoull(base=8) ret:%llu,%s fail.\n", ret, nPtr);
144     }
145     ICUNIT_ASSERT_EQUAL(ret, 0666ULL, 0);
146     ICUNIT_ASSERT_STRING_EQUAL(endPtr, " 1.6", 0);
147     return 0;
148 }
149 
150 #if (LOSCFG_LIBC_MUSL == 1)
151 /* *
152  * @tc.number    : TEST_STDLIB_STRTOULL_005
153  * @tc.name      : convert string by Strtoull
154  * @tc.desc      : [C- SOFTWARE -0200]
155  */
156 LITE_TEST_CASE(PosixStdlibStrtoullTest, testStdlibStrtoull005, Function | MediumTest | Level1)
157 {
158     char nPtr[] = " 1.6";
159     char *endPtr = NULL;
160     unsigned long long ret = strtoull(nPtr, &endPtr, 65);
161     if (ret == 0ULL) {
162         LOG("[DEMO] posix stdlib test case 5:strtoull(base=65) ret:%llu,%s, endPtr:%s ok.\n", ret, nPtr, endPtr);
163     } else {
164         LOG("[DEMO] posix stdlib test case 5:strtoull(base=65) ret:%llu,%s fail.\n", ret, nPtr);
165     }
166     ICUNIT_ASSERT_EQUAL(ret, 0ULL, ret);
167     ICUNIT_ASSERT_STRING_EQUAL(endPtr, " 1.6", 0);
168     return 0;
169 }
170 #endif
171 
172 /* *
173  * @tc.number    : TEST_STDLIB_STRTOULL_006
174  * @tc.name      : convert string by Strtoull
175  * @tc.desc      : [C- SOFTWARE -0200]
176  */
177 LITE_TEST_CASE(PosixStdlibStrtoullTest, testStdlibStrtoull006, Function | MediumTest | Level1)
178 {
179     char nPtr[] = ".6";
180     char *endPtr = NULL;
181     unsigned long long ret = strtoull(nPtr, &endPtr, 0);
182     if (ret == 0ULL) {
183         LOG("[DEMO] posix stdlib test case 6:strtoull(base=0) ret:%llu,%s, endPtr:%s ok.\n", ret, nPtr, endPtr);
184     } else {
185         LOG("[DEMO] posix stdlib test case 6:strtoull(base=0) ret:%llu,%s fail.\n", ret, nPtr);
186     }
187     ICUNIT_ASSERT_EQUAL(ret, 0ULL, 0);
188     ICUNIT_ASSERT_STRING_EQUAL(endPtr, ".6", 0);
189     return 0;
190 }
191 
192 /* *
193  * @tc.number    : TEST_STDLIB_STRTOULL_007
194  * @tc.name      : convert string by Strtoull
195  * @tc.desc      : [C- SOFTWARE -0200]
196  */
197 LITE_TEST_CASE(PosixStdlibStrtoullTest, testStdlibStrtoull007, Function | MediumTest | Level1)
198 {
199     char nPtr[] = "18446744073709551615 18446744073709551616";
200     char *endPtr = NULL;
201     unsigned long long ret = strtoull(nPtr, &endPtr, 10);
202     if (ret == 18446744073709551615ULL) {
203         LOG("[DEMO] posix stdlib test case 7:strtoull(base=10) ret:%llu,%s, endPtr:%s ok.\n", ret, nPtr, endPtr);
204     } else {
205         LOG("[DEMO] posix stdlib test case 7:strtoull(base=10) ret:%llu,%s fail.\n", ret, nPtr);
206     }
207     ICUNIT_ASSERT_EQUAL(ret, 18446744073709551615ULL, 0);
208     ICUNIT_ASSERT_STRING_EQUAL(endPtr, " 18446744073709551616", 0);
209     return 0;
210 }
211 
212 /* *
213  * @tc.number    : TEST_STDLIB_STRTOULL_008
214  * @tc.name      : convert string by Strtoull
215  * @tc.desc      : [C- SOFTWARE -0200]
216  */
217 LITE_TEST_CASE(PosixStdlibStrtoullTest, testStdlibStrtoull008, Function | MediumTest | Level1)
218 {
219     char nPtr[] = " 18446744073709551616";
220     char *endPtr = NULL;
221     unsigned long long ret = strtoull(nPtr, &endPtr, 10);
222     if (ret == 0ULL) {
223         LOG("[DEMO] posix stdlib test case 8:strtoull(base=10) ret:%llu,%s, endPtr:%s ok.\n", ret, nPtr, endPtr);
224     } else {
225         LOG("[DEMO] posix stdlib test case 8:strtoull(base=10) ret:%llu,%s fail.\n", ret, nPtr);
226     }
227 
228     ICUNIT_ASSERT_EQUAL(ret, ULLONG_MAX, ret);
229     ICUNIT_ASSERT_EQUAL(errno, ERANGE, errno);
230     ICUNIT_ASSERT_STRING_EQUAL(endPtr, "", 0);
231     return 0;
232 }
233 
234 /* *
235  * @tc.number    : TEST_STDLIB_STRTOULL_009
236  * @tc.name      : convert string by Strtoull
237  * @tc.desc      : [C- SOFTWARE -0200]
238  */
239 LITE_TEST_CASE(PosixStdlibStrtoullTest, testStdlibStrtoull009, Function | MediumTest | Level1)
240 {
241     char nPtr[] = "0XDEFE 0666";
242     char *endPtr = NULL;
243     unsigned long long ret = strtoull(nPtr, &endPtr, 0);
244     if (ret == 0XDEFEULL) {
245         LOG("[DEMO] posix stdlib test case 9:strtoull(base=0) ret:%llu,%s, endPtr:%s ok.\n", ret, nPtr, endPtr);
246     } else {
247         LOG("[DEMO] posix stdlib test case 9:strtoull(base=0) ret:%llu,%s fail.\n", ret, nPtr);
248     }
249     ICUNIT_ASSERT_EQUAL(ret, 0XDEFEULL, ret);
250     ICUNIT_ASSERT_STRING_EQUAL(endPtr, " 0666", 0);
251     return 0;
252 }
253 
254 /* *
255  * @tc.number    : TEST_STDLIB_STRTOULL_010
256  * @tc.name      : convert string by Strtoull
257  * @tc.desc      : [C- SOFTWARE -0200]
258  */
259 LITE_TEST_CASE(PosixStdlibStrtoullTest, testStdlibStrtoull010, Function | MediumTest | Level1)
260 {
261     char nPtr[] = " 0666";
262     char *endPtr = NULL;
263     unsigned long long ret = strtoull(nPtr, &endPtr, 0);
264     if (ret == 0666ULL) {
265         LOG("[DEMO] posix stdlib test case 10:strtoull(base=0) ret:%llu,%s, endPtr:%s ok.\n", ret, nPtr, endPtr);
266     } else {
267         LOG("[DEMO] posix stdlib test case 10:strtoull(base=0) ret:%llu,%s fail.\n", ret, nPtr);
268     }
269     ICUNIT_ASSERT_EQUAL(ret, 0666ULL, ret);
270     ICUNIT_ASSERT_STRING_EQUAL(endPtr, "", 0);
271     return 0;
272 }
273 
274 RUN_TEST_SUITE(PosixStdlibStrtoullTest);
275 
276 
PosixStdlibStrtoullFuncTestnull277 void PosixStdlibStrtoullFuncTest()
278 {
279     LOG("begin PosixStdlibStrtoullFuncTest....");
280     RUN_ONE_TESTCASE(testStdlibStrtoull001);
281     RUN_ONE_TESTCASE(testStdlibStrtoull002);
282     RUN_ONE_TESTCASE(testStdlibStrtoull003);
283     RUN_ONE_TESTCASE(testStdlibStrtoull004);
284 #if (LOSCFG_LIBC_MUSL == 1)
285     RUN_ONE_TESTCASE(testStdlibStrtoull005);
286 #endif
287     RUN_ONE_TESTCASE(testStdlibStrtoull006);
288     RUN_ONE_TESTCASE(testStdlibStrtoull007);
289     RUN_ONE_TESTCASE(testStdlibStrtoull008);
290     RUN_ONE_TESTCASE(testStdlibStrtoull009);
291     RUN_ONE_TESTCASE(testStdlibStrtoull010);
292 
293     return;
294 }