1 /*
2 * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without modification,
5 * are permitted provided that the following conditions are met:
6 *
7 * 1. Redistributions of source code must retain the above copyright notice, this list of
8 * conditions and the following disclaimer.
9 *
10 * 2. Redistributions in binary form must reproduce the above copyright notice, this list
11 * of conditions and the following disclaimer in the documentation and/or other materials
12 * provided with the distribution.
13 *
14 * 3. Neither the name of the copyright holder nor the names of its contributors may be used
15 * to endorse or promote products derived from this software without specific prior written
16 * permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
20 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
21 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
22 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
23 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
24 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
25 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
26 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
27 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
28 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 */
30
31 #include "xts_io.h"
32
33 LITE_TEST_SUIT(IO, IoStringApi, IoStringApiTestSuite);
34
IoStringApiTestSuiteSetUp(void)35 static BOOL IoStringApiTestSuiteSetUp(void)
36 {
37 return TRUE;
38 }
39
IoStringApiTestSuiteTearDown(void)40 static BOOL IoStringApiTestSuiteTearDown(void)
41 {
42 return TRUE;
43 }
44
45 /**
46 * @tc.number SUB_KERNEL_IO_STRING_0300
47 * @tc.name strcmp basic function test
48 * @tc.desc [C- SOFTWARE -0200]
49 */
50 LITE_TEST_CASE(IoStringApiTestSuite, testStrcmp, Function | MediumTest | Level1)
51 {
52 int ret = strcmp("abcdef", "ABCDEF");
53 ICUNIT_ASSERT_WITHIN_EQUAL(ret, 0, INT_MAX, ret);
54
55 ret = strcmp("123456", "654321");
56 ICUNIT_ASSERT_WITHIN_EQUAL(ret, INT_MIN, 0, ret);
57
58 ret = strcmp("~!@#$%^&*()_+", "~!@#$%^&*()_+");
59 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
60 return 0;
61 }
62
63 /**
64 * @tc.number SUB_KERNEL_IO_STRING_0400
65 * @tc.name strncmp basic function test
66 * @tc.desc [C- SOFTWARE -0200]
67 */
68 LITE_TEST_CASE(IoStringApiTestSuite, testStrncmp, Function | MediumTest | Level1)
69 {
70 const char dest[] = "abcdef";
71 const char src[] = "ABCDEF";
72 int ret = strncmp(dest, src, 1); /* 1 common data for test, no special meaning */
73 ICUNIT_ASSERT_WITHIN_EQUAL(ret, 0, INT_MAX, ret);
74
75 ret = strncmp("123456", "654321", 6); /* 6 common data for test, no special meaning */
76 ICUNIT_ASSERT_WITHIN_EQUAL(ret, INT_MIN, 0, ret);
77
78 ret = strncmp("~!@#$%^&*()_+", "~!@#$%^&*()_+", 8); /* 8 common data for test, no special meaning */
79 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
80 return 0;
81 }
82
83 /**
84 * @tc.number SUB_KERNEL_IO_STRING_0700
85 * @tc.name stpcpy basic function test
86 * @tc.desc [C- SOFTWARE -0200]
87 */
88 LITE_TEST_CASE(IoStringApiTestSuite, testStpcpy, Function | MediumTest | Level1)
89 {
90 const char *src = "hello world !";
91 char dest[50] = {0}; /* 50 common data for test, no special meaning */
92 char *ret = stpcpy(dest, src);
93 ICUNIT_ASSERT_NOT_EQUAL(ret, NULL, ret);
94 ICUNIT_ASSERT_STRING_EQUAL(dest, src, dest);
95
96 const char *srcT = "~!@#$%%^&*()_+";
97 char destT[50] = {0}; /* 50 common data for test, no special meaning */
98 ret = stpcpy(destT, srcT);
99 ICUNIT_ASSERT_NOT_EQUAL(ret, NULL, ret);
100 ICUNIT_ASSERT_STRING_EQUAL(destT, srcT, destT);
101 return 0;
102 }
103
104 /**
105 * @tc.number SUB_KERNEL_IO_STRING_0800
106 * @tc.name stpncpy basic function test
107 * @tc.desc [C- SOFTWARE -0200]
108 */
109 LITE_TEST_CASE(IoStringApiTestSuite, testStpncpy, Function | MediumTest | Level1)
110 {
111 char src[] = "hello world !";
112 char dest[50] = {0}; /* 50 common data for test, no special meaning */
113 char *ret = stpncpy(dest, src, 5); /* 5 common data for test, no special meaning */
114 ICUNIT_ASSERT_STRING_EQUAL(ret, "", ret);
115 ICUNIT_ASSERT_STRING_EQUAL(dest, "hello", dest);
116
117 char srcT[] = "~!@#$%%^&*()_+";
118 char destT[50] = {0}; /* 50 common data for test, no special meaning */
119 ret = stpncpy(destT, srcT, 15); /* 15 common data for test, no special meaning */
120 ICUNIT_ASSERT_STRING_EQUAL(ret, "", ret);
121 ICUNIT_ASSERT_STRING_EQUAL(destT, "~!@#$%%^&*()_+", destT);
122 return 0;
123 }
124
125 /**
126 * @tc.number SUB_KERNEL_IO_STRING_1000
127 * @tc.name strcpy basic function test
128 * @tc.desc [C- SOFTWARE -0200]
129 */
130 LITE_TEST_CASE(IoStringApiTestSuite, testStrcpy, Function | MediumTest | Level1)
131 {
132 char src[] = "hello world !";
133 char dest[20] = {0}; /* 20 common data for test, no special meaning */
134 int ret = strcpy_s(dest, sizeof(dest), src);
135 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
136
137 char srcT[] = "This is String1";
138 char destT[20] = {0}; /* 20 common data for test, no special meaning */
139 ret = strcpy_s(destT, sizeof(destT), srcT);
140 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
141 return 0;
142 }
143
144 /**
145 * @tc.number SUB_KERNEL_IO_STRING_1100
146 * @tc.name strncpy basic function test
147 * @tc.desc [C- SOFTWARE -0200]
148 */
149 LITE_TEST_CASE(IoStringApiTestSuite, testStrncpy, Function | MediumTest | Level1)
150 {
151 char src[] = "hello world !";
152 char dest[20] = {0};
153 int ret = strncpy_s(dest, sizeof(dest), src, 6); /* 6 common data for test, no special meaning */
154 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
155
156 char destT[] = "~!@#$%^&*()_+";
157 ret = strncpy_s(destT, sizeof(destT), "hello world", 0);
158 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
159 return 0;
160 }
161
162 /**
163 * @tc.number SUB_KERNEL_IO_STRING_1400
164 * @tc.name strcat basic function test
165 * @tc.desc [C- SOFTWARE -0200]
166 */
167 LITE_TEST_CASE(IoStringApiTestSuite, testStrcat, Function | MediumTest | Level1)
168 {
169 char dest[50] = {0}; /* 50 common data for test, no special meaning */
170 int ret = strcat_s(dest, sizeof(dest), "hello world !");
171 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
172
173 char destT[50] = "hello world ! || "; /* 50 common data for test, no special meaning */
174 ret = strcat_s(destT, sizeof(destT), "This is String1");
175 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
176 return 0;
177 }
178
179 /**
180 * @tc.number SUB_KERNEL_IO_STRING_1500
181 * @tc.name strncat basic function test
182 * @tc.desc [C- SOFTWARE -0200]
183 */
184 LITE_TEST_CASE(IoStringApiTestSuite, testStrncat, Function | MediumTest | Level1)
185 {
186 char dest[50] = "hello world || "; /* 50 common data for test, no special meaning */
187 int ret = strncat_s(dest, sizeof(dest), "This is String1", 7); /* 7 common data for test, no special meaning */
188 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
189
190 char destT[20] = "|/*"; /* 20 common data for test, no special meaning */
191 ret = strncat_s(destT, sizeof(destT), "~!@#$%^&*()_+", 13); /* 13 common data for test, no special meaning */
192 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
193 return 0;
194 }
195
196 /**
197 * @tc.number SUB_KERNEL_IO_STRING_1600
198 * @tc.name strchr basic function test
199 * @tc.desc [C- SOFTWARE -0200]
200 */
201 LITE_TEST_CASE(IoStringApiTestSuite, testStrchr, Function | MediumTest | Level1)
202 {
203 char src[] = "hello !! world";
204 char *ret = strchr(src, '!');
205 ICUNIT_ASSERT_STRING_EQUAL(ret, "!! world", ret);
206
207 ret = strchr(src, '?');
208 ICUNIT_ASSERT_STRING_EQUAL(ret, NULL, ret);
209 return 0;
210 }
211
212 /**
213 * @tc.number SUB_KERNEL_IO_STRING_1700
214 * @tc.name strrchr basic function test
215 * @tc.desc [C- SOFTWARE -0200]
216 */
217 LITE_TEST_CASE(IoStringApiTestSuite, testStrrchr, Function | MediumTest | Level1)
218 {
219 char src[] = "hello world & HEELO & WORLD";
220 char *ret = strrchr(src, '&');
221 ICUNIT_ASSERT_STRING_EQUAL(ret, "& WORLD", ret);
222
223 ret = strrchr(src, '?');
224 ICUNIT_ASSERT_STRING_EQUAL(ret, NULL, ret);
225 return 0;
226 }
227
228 /**
229 * @tc.number SUB_KERNEL_IO_STRING_1800
230 * @tc.name strnlen basic function test
231 * @tc.desc [C- SOFTWARE -0200]
232 */
233 LITE_TEST_CASE(IoStringApiTestSuite, testStrnlen, Function | MediumTest | Level1)
234 {
235 char src[] = "hello world !";
236 unsigned int ltSrcSize = strlen(src) - 2; /* 2 common data for test, no special meaning */
237 unsigned int gtSrcSize = strlen(src) + 2; /* 2 common data for test, no special meaning */
238
239 size_t ret = strnlen(src, ltSrcSize);
240 ICUNIT_ASSERT_EQUAL(ret, ltSrcSize, ret);
241
242 ret = strnlen(src, gtSrcSize);
243 ICUNIT_ASSERT_EQUAL(ret, strlen(src), ret);
244 return 0;
245 }
246
247 /**
248 * @tc.number SUB_KERNEL_IO_STRING_1900
249 * @tc.name strtok basic function test
250 * @tc.desc [C- SOFTWARE -0200]
251 */
252 LITE_TEST_CASE(IoStringApiTestSuite, testStrtok, Function | MediumTest | Level1)
253 {
254 char src[] = "hello world & This is-String1";
255 char *ret = strtok(src, "&");
256 ICUNIT_ASSERT_STRING_EQUAL(ret, src, ret);
257
258 ret = strtok(NULL, "-");
259 ICUNIT_ASSERT_STRING_EQUAL(ret, " This is", ret);
260
261 char srcS[] = "hello world !";
262 ret = strtok(srcS, "?");
263 ICUNIT_ASSERT_STRING_EQUAL(ret, srcS, ret);
264
265 char srcT[50] = {0}; /* 50 common data for test, no special meaning */
266 ret = strtok(srcT, "~");
267 ICUNIT_ASSERT_STRING_EQUAL(ret, NULL, ret);
268 return 0;
269 }
270
271 /**
272 * @tc.number SUB_KERNEL_IO_STRING_2200
273 * @tc.name strdup basic function test
274 * @tc.desc [C- SOFTWARE -0200]
275 */
276 LITE_TEST_CASE(IoStringApiTestSuite, testStrdup, Function | MediumTest | Level1)
277 {
278 char src[] = "hello world !";
279 char *ret = strdup(src);
280 ICUNIT_ASSERT_STRING_EQUAL(ret, src, ret);
281
282 char srcS[] = "This is String1";
283 ret = strdup(srcS);
284 ICUNIT_ASSERT_STRING_EQUAL(ret, "This is String1", ret);
285 free(ret);
286 return 0;
287 }
288
289 /**
290 * @tc.number SUB_KERNEL_IO_STRING_2500
291 * @tc.name strcspn basic function test
292 * @tc.desc [C- SOFTWARE -0200]
293 */
294 LITE_TEST_CASE(IoStringApiTestSuite, testStrcspn, Function | MediumTest | Level1)
295 {
296 const char dest[] = "hello world !";
297 const char src[] = "!";
298 size_t ret = strcspn(dest, src);
299 ICUNIT_ASSERT_EQUAL(ret, 12U, ret);
300
301 const char srcS[] = "a";
302 ret = strcspn(dest, srcS);
303 ICUNIT_ASSERT_EQUAL(ret, 13U, ret);
304 return 0;
305 }
306
307 /**
308 * @tc.number SUB_KERNEL_IO_STRING_2600
309 * @tc.name strspn basic function test
310 * @tc.desc [C- SOFTWARE -0200]
311 */
312 LITE_TEST_CASE(IoStringApiTestSuite, testStrspn, Function | MediumTest | Level1)
313 {
314 const char dest[] = "hello world !";
315 const char src[] = "heAlo";
316 size_t ret = strspn(dest, src);
317 ICUNIT_ASSERT_EQUAL(ret, 5U, ret);
318 ICUNIT_ASSERT_EQUAL(ret, 5U, ret);
319
320 const char destS[] = "this is string";
321 const char srcS[] = "abc";
322 ret = strspn(destS, srcS);
323 ICUNIT_ASSERT_EQUAL(ret, 0U, ret);
324
325 const char srcT[] = "helo\0 wal";
326 ret = strspn(dest, srcT);
327 ICUNIT_ASSERT_EQUAL(ret, 5U, ret);
328 return 0;
329 }
330
331 /**
332 * @tc.number SUB_KERNEL_IO_STRING_2700
333 * @tc.name strstr basic function test
334 * @tc.desc [C- SOFTWARE -0200]
335 */
336 LITE_TEST_CASE(IoStringApiTestSuite, testStrstr, Function | MediumTest | Level1)
337 {
338 const char dest[] = "hello world !";
339 const char src[] = "heAlo";
340 const char *ret = strstr(dest, src);
341 ICUNIT_ASSERT_STRING_EQUAL(ret, NULL, ret);
342
343 const char destS[] = "string this is string";
344 const char srcS[] = "string";
345 ret = strstr(destS, srcS);
346 ICUNIT_ASSERT_STRING_EQUAL(ret, "string this is string", ret);
347
348 const char srcT[] = "\0hello";
349 ret = strstr(dest, srcT);
350 ICUNIT_ASSERT_STRING_EQUAL(ret, "hello world !", ret);
351 return 0;
352 }
353
354 RUN_TEST_SUITE(IoStringApiTestSuite);
355
XtsIoStringFuncTest(void)356 void XtsIoStringFuncTest(void)
357 {
358 RUN_ONE_TESTCASE(testStrcmp);
359 RUN_ONE_TESTCASE(testStrncmp);
360 RUN_ONE_TESTCASE(testStpcpy);
361 RUN_ONE_TESTCASE(testStpncpy);
362 RUN_ONE_TESTCASE(testStrcpy);
363 RUN_ONE_TESTCASE(testStrncpy);
364 RUN_ONE_TESTCASE(testStrcat);
365 RUN_ONE_TESTCASE(testStrncat);
366 RUN_ONE_TESTCASE(testStrchr);
367 RUN_ONE_TESTCASE(testStrrchr);
368 RUN_ONE_TESTCASE(testStrnlen);
369 RUN_ONE_TESTCASE(testStrtok);
370 RUN_ONE_TESTCASE(testStrdup);
371 RUN_ONE_TESTCASE(testStrcspn);
372 RUN_ONE_TESTCASE(testStrspn);
373 RUN_ONE_TESTCASE(testStrstr);
374 }
375