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 */
49LITE_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 */
55static 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 */
64static 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 */
75LITE_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 */
95LITE_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 */
115LITE_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 */
135LITE_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 */
156LITE_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 */
177LITE_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 */
197LITE_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 */
217LITE_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 */
239LITE_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 */
259LITE_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
274RUN_TEST_SUITE(PosixStdlibStrtoullTest);
275
276
277void 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}