1 /* Test strncat functions.
2 Copyright (C) 2011-2021 Free Software Foundation, Inc.
3
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Lesser General Public
6 License as published by the Free Software Foundation; either
7 version 2.1 of the License, or (at your option) any later version.
8
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Lesser General Public License for more details.
13
14 You should have received a copy of the GNU Lesser General Public
15 License along with the GNU C Library; if not, see
16 <https://www.gnu.org/licenses/>. */
17
18 #define TEST_MAIN
19 #ifndef WIDE
20 # define TEST_NAME "strncat"
21 #else
22 # define TEST_NAME "wcsncat"
23 #endif /* WIDE */
24 #include "test-string.h"
25
26 #ifndef WIDE
27 # define STRNCAT strncat
28 # define CHAR char
29 # define UCHAR unsigned char
30 # define SIMPLE_STRNCAT simple_strncat
31 # define STUPID_STRNCAT stupid_strncat
32 # define STRLEN strlen
33 # define MEMSET memset
34 # define MEMCPY memcpy
35 # define MEMCMP memcmp
36 # define BIG_CHAR CHAR_MAX
37 # define SMALL_CHAR 127
38 #else
39 # include <wchar.h>
40 # define STRNCAT wcsncat
41 # define CHAR wchar_t
42 # define UCHAR wchar_t
43 # define SIMPLE_STRNCAT simple_wcsncat
44 # define STUPID_STRNCAT stupid_wcsncat
45 # define STRLEN wcslen
46 # define MEMSET wmemset
47 # define MEMCPY wmemcpy
48 # define MEMCMP wmemcmp
49 # define BIG_CHAR WCHAR_MAX
50 # define SMALL_CHAR 1273
51 #endif /* WIDE */
52
53 typedef CHAR *(*proto_t) (CHAR *, const CHAR *, size_t);
54 CHAR *STUPID_STRNCAT (CHAR *, const CHAR *, size_t);
55 CHAR *SIMPLE_STRNCAT (CHAR *, const CHAR *, size_t);
56
57 IMPL (STUPID_STRNCAT, 0)
58 IMPL (STRNCAT, 2)
59
60 CHAR *
STUPID_STRNCAT(CHAR * dst,const CHAR * src,size_t n)61 STUPID_STRNCAT (CHAR *dst, const CHAR *src, size_t n)
62 {
63 CHAR *ret = dst;
64 while (*dst++ != '\0');
65 --dst;
66 while (n--)
67 if ((*dst++ = *src++) == '\0')
68 return ret;
69 *dst = '\0';
70 return ret;
71 }
72
73 static void
do_one_test(impl_t * impl,CHAR * dst,const CHAR * src,size_t n)74 do_one_test (impl_t *impl, CHAR *dst, const CHAR *src, size_t n)
75 {
76 size_t k = STRLEN (dst);
77 if (CALL (impl, dst, src, n) != dst)
78 {
79 error (0, 0, "Wrong result in function %s %p != %p", impl->name,
80 CALL (impl, dst, src, n), dst);
81 ret = 1;
82 return;
83 }
84
85 size_t len = STRLEN (src);
86 if (MEMCMP (dst + k, src, len + 1 > n ? n : len + 1) != 0)
87 {
88 error (0, 0, "Incorrect concatenation in function %s",
89 impl->name);
90 ret = 1;
91 return;
92 }
93 if (n < len && dst[k + n] != '\0')
94 {
95 error (0, 0, "There is no zero in the end of output string in %s",
96 impl->name);
97 ret = 1;
98 return;
99 }
100 }
101
102 static void
do_test(size_t align1,size_t align2,size_t len1,size_t len2,size_t n,int max_char)103 do_test (size_t align1, size_t align2, size_t len1, size_t len2,
104 size_t n, int max_char)
105 {
106 size_t i;
107 CHAR *s1, *s2;
108
109 align1 &= 7;
110 if ((align1 + len1) * sizeof (CHAR) >= page_size)
111 return;
112 if ((align1 + n) * sizeof (CHAR) > page_size)
113 return;
114 align2 &= 7;
115 if ((align2 + len1 + len2) * sizeof (CHAR) >= page_size)
116 return;
117 if ((align2 + len1 + n) * sizeof (CHAR) > page_size)
118 return;
119 s1 = (CHAR *) (buf1) + align1;
120 s2 = (CHAR *) (buf2) + align2;
121
122 for (i = 0; i < len1; ++i)
123 s1[i] = 32 + 23 * i % (max_char - 32);
124 s1[len1] = '\0';
125
126 for (i = 0; i < len2; i++)
127 s2[i] = 32 + 23 * i % (max_char - 32);
128
129 FOR_EACH_IMPL (impl, 0)
130 {
131 s2[len2] = '\0';
132 do_one_test (impl, s2, s1, n);
133 }
134 }
135
136 static void
do_overflow_tests(void)137 do_overflow_tests (void)
138 {
139 size_t i, j, len;
140 const size_t one = 1;
141 CHAR *s1, *s2;
142 uintptr_t s1_addr;
143 s1 = (CHAR *) buf1;
144 s2 = (CHAR *) buf2;
145 s1_addr = (uintptr_t)s1;
146 for (j = 0; j < 200; ++j)
147 s2[j] = 32 + 23 * j % (BIG_CHAR - 32);
148 s2[200] = 0;
149 for (i = 0; i < 750; ++i) {
150 for (j = 0; j < i; ++j)
151 s1[j] = 32 + 23 * j % (BIG_CHAR - 32);
152 s1[i] = '\0';
153
154 FOR_EACH_IMPL (impl, 0)
155 {
156 s2[200] = '\0';
157 do_one_test (impl, s2, s1, SIZE_MAX - i);
158 s2[200] = '\0';
159 do_one_test (impl, s2, s1, i - s1_addr);
160 s2[200] = '\0';
161 do_one_test (impl, s2, s1, -s1_addr - i);
162 s2[200] = '\0';
163 do_one_test (impl, s2, s1, SIZE_MAX - s1_addr - i);
164 s2[200] = '\0';
165 do_one_test (impl, s2, s1, SIZE_MAX - s1_addr + i);
166 }
167
168 len = 0;
169 for (j = 8 * sizeof(size_t) - 1; j ; --j)
170 {
171 len |= one << j;
172 FOR_EACH_IMPL (impl, 0)
173 {
174 s2[200] = '\0';
175 do_one_test (impl, s2, s1, len - i);
176 s2[200] = '\0';
177 do_one_test (impl, s2, s1, len + i);
178 s2[200] = '\0';
179 do_one_test (impl, s2, s1, len - s1_addr - i);
180 s2[200] = '\0';
181 do_one_test (impl, s2, s1, len - s1_addr + i);
182
183 s2[200] = '\0';
184 do_one_test (impl, s2, s1, ~len - i);
185 s2[200] = '\0';
186 do_one_test (impl, s2, s1, ~len + i);
187 s2[200] = '\0';
188 do_one_test (impl, s2, s1, ~len - s1_addr - i);
189 s2[200] = '\0';
190 do_one_test (impl, s2, s1, ~len - s1_addr + i);
191 }
192 }
193 }
194 }
195
196 static void
do_random_tests(void)197 do_random_tests (void)
198 {
199 size_t i, j, n, align1, align2, len1, len2, N;
200 UCHAR *p1 = (UCHAR *) (buf1 + page_size) - 512;
201 UCHAR *p2 = (UCHAR *) (buf2 + page_size) - 512;
202 UCHAR *p3 = (UCHAR *) buf1;
203 UCHAR *res;
204 fprintf (stdout, "Number of iterations in random test = %zd\n",
205 ITERATIONS);
206 for (n = 0; n < ITERATIONS; n++)
207 {
208 N = random () & 255;
209 align1 = random () & 31;
210 if (random () & 1)
211 align2 = random () & 31;
212 else
213 align2 = align1 + (random () & 24);
214 len1 = random () & 511;
215 if (len1 + align2 > 512)
216 len2 = random () & 7;
217 else
218 len2 = (512 - len1 - align2) * (random () & (1024 * 1024 - 1))
219 / (1024 * 1024);
220 j = align1;
221 if (align2 + len2 > j)
222 j = align2 + len2;
223 if (len1 + j >= 511)
224 len1 = 510 - j - (random () & 7);
225 if (len1 >= 512)
226 len1 = 0;
227 if (align1 + len1 < 512 - 8)
228 {
229 j = 510 - align1 - len1 - (random () & 31);
230 if (j > 0 && j < 512)
231 align1 += j;
232 }
233 j = len1 + align1 + 64;
234 if (j > 512)
235 j = 512;
236 for (i = 0; i < j; i++)
237 {
238 if (i == len1 + align1)
239 p1[i] = 0;
240 else
241 {
242 p1[i] = random () & BIG_CHAR;
243 if (i >= align1 && i < len1 + align1 && !p1[i])
244 p1[i] = (random () & SMALL_CHAR) + 3;
245 }
246 }
247 for (i = 0; i < len2; i++)
248 {
249 p3[i] = random () & BIG_CHAR;
250 if (!p3[i])
251 p3[i] = (random () & SMALL_CHAR) + 3;
252 }
253 p3[len2] = 0;
254
255 FOR_EACH_IMPL (impl, 1)
256 {
257 MEMSET (p2 - 64, '\1', align2 + 64);
258 MEMSET (p2 + align2 + len2 + 1, '\1', 512 - align2 - len2 - 1);
259 MEMCPY (p2 + align2, p3, len2 + 1);
260 res = (UCHAR *) CALL (impl, (CHAR *) (p2 + align2),
261 (CHAR *) (p1 + align1), N);
262 if (res != p2 + align2)
263 {
264 error (0, 0, "Iteration %zd - wrong result in function %s "
265 "(%zd, %zd, %zd, %zd, %zd) %p != %p",
266 n, impl->name, align1, align2, len1, len2, N,
267 res, p2 + align2);
268 ret = 1;
269 }
270 for (j = 0; j < align2 + 64; ++j)
271 {
272 if (p2[j - 64] != '\1')
273 {
274 error (0, 0, "Iteration %zd - garbage before dst, %s "
275 "%zd, %zd, %zd, %zd, %zd)",
276 n, impl->name, align1, align2, len1, len2, N);
277 ret = 1;
278 break;
279 }
280 }
281 if (MEMCMP (p2 + align2, p3, len2))
282 {
283 error (0, 0, "Iteration %zd - garbage in string before, %s "
284 "(%zd, %zd, %zd, %zd, %zd)",
285 n, impl->name, align1, align2, len1, len2, N);
286 ret = 1;
287 }
288
289 if ((len1 + 1) > N)
290 j = align2 + N + 1 + len2;
291 else
292 j = align2 + len1 + 1 + len2;
293 for (; j < 512; ++j)
294 {
295 if (p2[j] != '\1')
296 {
297 error (0, 0, "Iteration %zd - garbage after, %s "
298 "(%zd, %zd, %zd, %zd, %zd)",
299 n, impl->name, align1, align2, len1, len2, N);
300 ret = 1;
301 break;
302 }
303 }
304 if (len1 + 1 > N)
305 {
306 if (p2[align2 + N + len2] != '\0')
307 {
308 error (0, 0, "Iteration %zd - there is no zero at the "
309 "end of output string, %s (%zd, %zd, %zd, %zd, %zd)",
310 n, impl->name, align1, align2, len1, len2, N);
311 ret = 1;
312 }
313 }
314 if (MEMCMP (p1 + align1, p2 + align2 + len2,
315 (len1 + 1) > N ? N : len1 + 1))
316 {
317 error (0, 0, "Iteration %zd - different strings, %s "
318 "(%zd, %zd, %zd, %zd, %zd)",
319 n, impl->name, align1, align2, len1, len2, N);
320 ret = 1;
321 }
322 }
323 }
324 }
325
326 int
test_main(void)327 test_main (void)
328 {
329 size_t i, n;
330
331 test_init ();
332
333 printf ("%28s", "");
334 FOR_EACH_IMPL (impl, 0)
335 printf ("\t%s", impl->name);
336 putchar ('\n');
337
338 for (n = 2; n <= 2048; n*=4)
339 {
340 do_test (0, 2, 2, 2, n, SMALL_CHAR);
341 do_test (0, 0, 4, 4, n, SMALL_CHAR);
342 do_test (4, 0, 4, 4, n, BIG_CHAR);
343 do_test (0, 0, 8, 8, n, SMALL_CHAR);
344 do_test (0, 8, 8, 8, n, SMALL_CHAR);
345
346 do_test (0, 2, 2, 2, SIZE_MAX, SMALL_CHAR);
347 do_test (0, 0, 4, 4, SIZE_MAX, SMALL_CHAR);
348 do_test (4, 0, 4, 4, SIZE_MAX, BIG_CHAR);
349 do_test (0, 0, 8, 8, SIZE_MAX, SMALL_CHAR);
350 do_test (0, 8, 8, 8, SIZE_MAX, SMALL_CHAR);
351
352 for (i = 1; i < 8; ++i)
353 {
354 do_test (0, 0, 8 << i, 8 << i, n, SMALL_CHAR);
355 do_test (8 - i, 2 * i, 8 << i, 8 << i, n, SMALL_CHAR);
356 do_test (0, 0, 8 << i, 2 << i, n, SMALL_CHAR);
357 do_test (8 - i, 2 * i, 8 << i, 2 << i, n, SMALL_CHAR);
358
359 do_test (0, 0, 8 << i, 8 << i, SIZE_MAX, SMALL_CHAR);
360 do_test (8 - i, 2 * i, 8 << i, 8 << i, SIZE_MAX, SMALL_CHAR);
361 do_test (0, 0, 8 << i, 2 << i, SIZE_MAX, SMALL_CHAR);
362 do_test (8 - i, 2 * i, 8 << i, 2 << i, SIZE_MAX, SMALL_CHAR);
363 }
364
365 for (i = 1; i < 8; ++i)
366 {
367 do_test (i, 2 * i, 8 << i, 1, n, SMALL_CHAR);
368 do_test (2 * i, i, 8 << i, 1, n, BIG_CHAR);
369 do_test (i, i, 8 << i, 10, n, SMALL_CHAR);
370
371 do_test (i, 2 * i, 8 << i, 1, SIZE_MAX, SMALL_CHAR);
372 do_test (2 * i, i, 8 << i, 1, SIZE_MAX, BIG_CHAR);
373 do_test (i, i, 8 << i, 10, SIZE_MAX, SMALL_CHAR);
374 }
375 }
376
377 do_random_tests ();
378 do_overflow_tests ();
379 return ret;
380 }
381
382 #include <support/test-driver.c>
383