1 | /* Test for dynamic arrays. |
2 | Copyright (C) 2017-2022 Free Software Foundation, Inc. |
3 | This file is part of the GNU C Library. |
4 | |
5 | The GNU C Library is free software; you can redistribute it and/or |
6 | modify it under the terms of the GNU Lesser General Public |
7 | License as published by the Free Software Foundation; either |
8 | version 2.1 of the License, or (at your option) any later version. |
9 | |
10 | The GNU C Library is distributed in the hope that it will be useful, |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Lesser General Public License for more details. |
14 | |
15 | You should have received a copy of the GNU Lesser General Public |
16 | License along with the GNU C Library; if not, see |
17 | <https://www.gnu.org/licenses/>. */ |
18 | |
19 | #include "tst-dynarray-shared.h" |
20 | |
21 | #include <errno.h> |
22 | #include <stdint.h> |
23 | #include <libc-diag.h> |
24 | |
25 | #define DYNARRAY_STRUCT dynarray_long |
26 | #define DYNARRAY_ELEMENT long |
27 | #define DYNARRAY_PREFIX dynarray_long_ |
28 | #define DYNARRAY_ELEMENT_INIT(e) (*(e) = 17) |
29 | #include <malloc/dynarray-skeleton.c> |
30 | |
31 | struct long_array |
32 | { |
33 | long *array; |
34 | size_t length; |
35 | }; |
36 | |
37 | #define DYNARRAY_STRUCT dynarray_long_noscratch |
38 | #define DYNARRAY_ELEMENT long |
39 | #define DYNARRAY_PREFIX dynarray_long_noscratch_ |
40 | #define DYNARRAY_ELEMENT_INIT(e) (*(e) = 23) |
41 | #define DYNARRAY_FINAL_TYPE struct long_array |
42 | #define DYNARRAY_INITIAL_SIZE 0 |
43 | #include <malloc/dynarray-skeleton.c> |
44 | |
45 | #define DYNARRAY_STRUCT zstr |
46 | #define DYNARRAY_ELEMENT char |
47 | #define DYNARRAY_PREFIX zstr_ |
48 | #define DYNARRAY_INITIAL_SIZE 128 |
49 | #include <malloc/dynarray-skeleton.c> |
50 | |
51 | #include <malloc.h> |
52 | #include <mcheck.h> |
53 | #include <stdint.h> |
54 | #include <support/check.h> |
55 | #include <support/support.h> |
56 | |
57 | enum { max_count = 20 }; |
58 | |
59 | /* Test dynamic arrays with int elements (no automatic deallocation |
60 | for elements). */ |
61 | static void |
62 | test_int (void) |
63 | { |
64 | /* Empty array. */ |
65 | { |
66 | struct dynarray_int dyn; |
67 | dynarray_int_init (list: &dyn); |
68 | CHECK_EMPTY (int, &dyn); |
69 | } |
70 | |
71 | /* Empty array with finalization. */ |
72 | { |
73 | struct dynarray_int dyn; |
74 | dynarray_int_init (list: &dyn); |
75 | CHECK_INIT_STATE (int, &dyn); |
76 | struct int_array result = { (int *) (uintptr_t) -1, -1 }; |
77 | TEST_VERIFY_EXIT (dynarray_int_finalize (&dyn, &result)); |
78 | CHECK_INIT_STATE (int, &dyn); |
79 | TEST_VERIFY_EXIT (result.array == NULL); |
80 | TEST_VERIFY_EXIT (result.length == 0); |
81 | } |
82 | |
83 | /* Non-empty array tests. |
84 | |
85 | do_add: Switch between emplace (false) and add (true). |
86 | do_finalize: Perform finalize call at the end. |
87 | do_clear: Perform clear call at the end. |
88 | do_remove_last: Perform remove_last call after adding elements. |
89 | count: Number of elements added to the array. */ |
90 | for (int do_add = 0; do_add < 2; ++do_add) |
91 | for (int do_finalize = 0; do_finalize < 2; ++do_finalize) |
92 | for (int do_clear = 0; do_clear < 2; ++do_clear) |
93 | for (int do_remove_last = 0; do_remove_last < 2; ++do_remove_last) |
94 | for (unsigned int count = 0; count < max_count; ++count) |
95 | { |
96 | if (do_remove_last && count == 0) |
97 | continue; |
98 | unsigned int base = count * count; |
99 | struct dynarray_int dyn; |
100 | dynarray_int_init (list: &dyn); |
101 | for (unsigned int i = 0; i < count; ++i) |
102 | { |
103 | if (do_add) |
104 | dynarray_int_add (list: &dyn, item: base + i); |
105 | else |
106 | { |
107 | int *place = dynarray_int_emplace (list: &dyn); |
108 | TEST_VERIFY_EXIT (place != NULL); |
109 | *place = base + i; |
110 | } |
111 | TEST_VERIFY_EXIT (!dynarray_int_has_failed (&dyn)); |
112 | TEST_VERIFY_EXIT (dynarray_int_size (&dyn) == i + 1); |
113 | TEST_VERIFY_EXIT (dynarray_int_size (&dyn) |
114 | <= dyn.u.dynarray_header.allocated); |
115 | } |
116 | TEST_VERIFY_EXIT (dynarray_int_size (&dyn) == count); |
117 | TEST_VERIFY_EXIT (count <= dyn.u.dynarray_header.allocated); |
118 | if (count > 0) |
119 | { |
120 | TEST_VERIFY (dynarray_int_begin (&dyn) |
121 | == dynarray_int_at (&dyn, 0)); |
122 | TEST_VERIFY (dynarray_int_end (&dyn) |
123 | == dynarray_int_at (&dyn, count - 1) + 1); |
124 | } |
125 | unsigned final_count; |
126 | bool heap_array = dyn.u.dynarray_header.array != dyn.scratch; |
127 | if (do_remove_last) |
128 | { |
129 | dynarray_int_remove_last (list: &dyn); |
130 | if (count == 0) |
131 | final_count = 0; |
132 | else |
133 | final_count = count - 1; |
134 | } |
135 | else |
136 | final_count = count; |
137 | if (final_count > 0) |
138 | { |
139 | TEST_VERIFY (dynarray_int_begin (&dyn) |
140 | == dynarray_int_at (&dyn, 0)); |
141 | TEST_VERIFY (dynarray_int_end (&dyn) |
142 | == dynarray_int_at (&dyn, final_count - 1) + 1); |
143 | } |
144 | if (do_clear) |
145 | { |
146 | dynarray_int_clear (list: &dyn); |
147 | final_count = 0; |
148 | } |
149 | TEST_VERIFY_EXIT (!dynarray_int_has_failed (&dyn)); |
150 | TEST_VERIFY_EXIT ((dyn.u.dynarray_header.array != dyn.scratch) |
151 | == heap_array); |
152 | TEST_VERIFY_EXIT (dynarray_int_size (&dyn) == final_count); |
153 | TEST_VERIFY_EXIT (dyn.u.dynarray_header.allocated |
154 | >= final_count); |
155 | if (!do_clear) |
156 | for (unsigned int i = 0; i < final_count; ++i) |
157 | TEST_VERIFY_EXIT (*dynarray_int_at (&dyn, i) == base + i); |
158 | if (do_finalize) |
159 | { |
160 | struct int_array result = { (int *) (uintptr_t) -1, -1 }; |
161 | TEST_VERIFY_EXIT (dynarray_int_finalize (&dyn, &result)); |
162 | CHECK_INIT_STATE (int, &dyn); |
163 | TEST_VERIFY_EXIT (result.length == final_count); |
164 | if (final_count == 0) |
165 | TEST_VERIFY_EXIT (result.array == NULL); |
166 | else |
167 | { |
168 | TEST_VERIFY_EXIT (result.array != NULL); |
169 | TEST_VERIFY_EXIT (result.array != (int *) (uintptr_t) -1); |
170 | TEST_VERIFY_EXIT |
171 | (malloc_usable_size (result.array) |
172 | >= final_count * sizeof (result.array[0])); |
173 | for (unsigned int i = 0; i < final_count; ++i) |
174 | TEST_VERIFY_EXIT (result.array[i] == base + i); |
175 | free (ptr: result.array); |
176 | } |
177 | } |
178 | else /* !do_finalize */ |
179 | { |
180 | dynarray_int_free (list: &dyn); |
181 | CHECK_INIT_STATE (int, &dyn); |
182 | } |
183 | } |
184 | } |
185 | |
186 | /* Test dynamic arrays with char * elements (with automatic |
187 | deallocation of the pointed-to strings). */ |
188 | static void |
189 | test_str (void) |
190 | { |
191 | /* Empty array. */ |
192 | { |
193 | struct dynarray_str dyn; |
194 | dynarray_str_init (list: &dyn); |
195 | CHECK_EMPTY (str, &dyn); |
196 | } |
197 | |
198 | /* Empty array with finalization. */ |
199 | { |
200 | struct dynarray_str dyn; |
201 | dynarray_str_init (list: &dyn); |
202 | TEST_VERIFY_EXIT (!dynarray_str_has_failed (&dyn)); |
203 | struct str_array result = { (char **) (uintptr_t) -1, -1 }; |
204 | TEST_VERIFY_EXIT (dynarray_str_finalize (&dyn, &result)); |
205 | CHECK_INIT_STATE (str, &dyn); |
206 | TEST_VERIFY_EXIT (result.array == NULL); |
207 | TEST_VERIFY_EXIT (result.length == 0); |
208 | } |
209 | |
210 | /* Non-empty array tests. |
211 | |
212 | do_add: Switch between emplace (false) and add (true). |
213 | do_finalize: Perform finalize call at the end. |
214 | do_clear: Perform clear call at the end. |
215 | do_remove_last: Perform remove_last call after adding elements. |
216 | count: Number of elements added to the array. */ |
217 | for (int do_add = 0; do_add < 2; ++do_add) |
218 | for (int do_finalize = 0; do_finalize < 2; ++do_finalize) |
219 | for (int do_clear = 0; do_clear < 2; ++do_clear) |
220 | for (int do_remove_last = 0; do_remove_last < 2; ++do_remove_last) |
221 | for (unsigned int count = 0; count < max_count; ++count) |
222 | { |
223 | if (do_remove_last && count == 0) |
224 | continue; |
225 | unsigned int base = count * count; |
226 | struct dynarray_str dyn; |
227 | dynarray_str_init (list: &dyn); |
228 | for (unsigned int i = 0; i < count; ++i) |
229 | { |
230 | char *item = xasprintf (format: "%d" , base + i); |
231 | if (do_add) |
232 | dynarray_str_add (list: &dyn, item); |
233 | else |
234 | { |
235 | char **place = dynarray_str_emplace (list: &dyn); |
236 | TEST_VERIFY_EXIT (place != NULL); |
237 | TEST_VERIFY_EXIT (*place == NULL); |
238 | *place = item; |
239 | } |
240 | TEST_VERIFY_EXIT (!dynarray_str_has_failed (&dyn)); |
241 | TEST_VERIFY_EXIT (dynarray_str_size (&dyn) == i + 1); |
242 | TEST_VERIFY_EXIT (dynarray_str_size (&dyn) |
243 | <= dyn.u.dynarray_header.allocated); |
244 | } |
245 | TEST_VERIFY_EXIT (dynarray_str_size (&dyn) == count); |
246 | TEST_VERIFY_EXIT (count <= dyn.u.dynarray_header.allocated); |
247 | if (count > 0) |
248 | { |
249 | TEST_VERIFY (dynarray_str_begin (&dyn) |
250 | == dynarray_str_at (&dyn, 0)); |
251 | TEST_VERIFY (dynarray_str_end (&dyn) |
252 | == dynarray_str_at (&dyn, count - 1) + 1); |
253 | } |
254 | unsigned final_count; |
255 | bool heap_array = dyn.u.dynarray_header.array != dyn.scratch; |
256 | if (do_remove_last) |
257 | { |
258 | dynarray_str_remove_last (list: &dyn); |
259 | if (count == 0) |
260 | final_count = 0; |
261 | else |
262 | final_count = count - 1; |
263 | } |
264 | else |
265 | final_count = count; |
266 | if (final_count > 0) |
267 | { |
268 | TEST_VERIFY (dynarray_str_begin (&dyn) |
269 | == dynarray_str_at (&dyn, 0)); |
270 | TEST_VERIFY (dynarray_str_end (&dyn) |
271 | == dynarray_str_at (&dyn, final_count - 1) + 1); |
272 | } |
273 | if (do_clear) |
274 | { |
275 | dynarray_str_clear (list: &dyn); |
276 | final_count = 0; |
277 | } |
278 | TEST_VERIFY_EXIT (!dynarray_str_has_failed (&dyn)); |
279 | TEST_VERIFY_EXIT ((dyn.u.dynarray_header.array != dyn.scratch) |
280 | == heap_array); |
281 | TEST_VERIFY_EXIT (dynarray_str_size (&dyn) == final_count); |
282 | TEST_VERIFY_EXIT (dyn.u.dynarray_header.allocated |
283 | >= final_count); |
284 | if (!do_clear) |
285 | for (unsigned int i = 0; i < count - do_remove_last; ++i) |
286 | { |
287 | char *expected = xasprintf (format: "%d" , base + i); |
288 | const char *actual = *dynarray_str_at (list: &dyn, index: i); |
289 | TEST_VERIFY_EXIT (strcmp (actual, expected) == 0); |
290 | free (ptr: expected); |
291 | } |
292 | if (do_finalize) |
293 | { |
294 | struct str_array result = { (char **) (uintptr_t) -1, -1 }; |
295 | TEST_VERIFY_EXIT (dynarray_str_finalize (&dyn, &result)); |
296 | CHECK_INIT_STATE (str, &dyn); |
297 | TEST_VERIFY_EXIT (result.length == final_count); |
298 | if (final_count == 0) |
299 | TEST_VERIFY_EXIT (result.array == NULL); |
300 | else |
301 | { |
302 | TEST_VERIFY_EXIT (result.array != NULL); |
303 | TEST_VERIFY_EXIT (result.array |
304 | != (char **) (uintptr_t) -1); |
305 | TEST_VERIFY_EXIT (result.length |
306 | == count - do_remove_last); |
307 | TEST_VERIFY_EXIT |
308 | (malloc_usable_size (result.array) |
309 | >= final_count * sizeof (result.array[0])); |
310 | for (unsigned int i = 0; i < count - do_remove_last; ++i) |
311 | { |
312 | char *expected = xasprintf (format: "%d" , base + i); |
313 | char *actual = result.array[i]; |
314 | TEST_VERIFY_EXIT (strcmp (actual, expected) == 0); |
315 | free (ptr: expected); |
316 | free (ptr: actual); |
317 | } |
318 | free (ptr: result.array); |
319 | } |
320 | } |
321 | else /* !do_finalize */ |
322 | { |
323 | dynarray_str_free (list: &dyn); |
324 | CHECK_INIT_STATE (str, &dyn); |
325 | } |
326 | } |
327 | |
328 | /* Test resizing. */ |
329 | { |
330 | enum { count = 2131 }; |
331 | struct dynarray_str dyn; |
332 | dynarray_str_init (list: &dyn); |
333 | |
334 | /* From length 0 to length 1. */ |
335 | TEST_VERIFY (dynarray_str_resize (&dyn, 1)); |
336 | TEST_VERIFY (dynarray_str_size (&dyn) == 1); |
337 | TEST_VERIFY (*dynarray_str_at (&dyn, 0) == NULL); |
338 | *dynarray_str_at (list: &dyn, index: 0) = xstrdup ("allocated" ); |
339 | dynarray_str_free (list: &dyn); |
340 | |
341 | /* From length 0 to length 1 and 2. */ |
342 | TEST_VERIFY (dynarray_str_resize (&dyn, 1)); |
343 | TEST_VERIFY (dynarray_str_size (&dyn) == 1); |
344 | TEST_VERIFY (*dynarray_str_at (&dyn, 0) == NULL); |
345 | *dynarray_str_at (list: &dyn, index: 0) = xstrdup ("allocated0" ); |
346 | TEST_VERIFY (dynarray_str_resize (&dyn, 2)); |
347 | TEST_VERIFY (dynarray_str_size (&dyn) == 2); |
348 | TEST_VERIFY (strcmp (*dynarray_str_at (&dyn, 0), "allocated0" ) == 0); |
349 | TEST_VERIFY (*dynarray_str_at (&dyn, 1) == NULL); |
350 | *dynarray_str_at (list: &dyn, index: 1) = xstrdup ("allocated1" ); |
351 | TEST_VERIFY (dynarray_str_resize (&dyn, count)); |
352 | TEST_VERIFY (dynarray_str_size (&dyn) == count); |
353 | TEST_VERIFY (strcmp (*dynarray_str_at (&dyn, 0), "allocated0" ) == 0); |
354 | TEST_VERIFY (strcmp (*dynarray_str_at (&dyn, 1), "allocated1" ) == 0); |
355 | for (int i = 2; i < count; ++i) |
356 | TEST_VERIFY (*dynarray_str_at (&dyn, i) == NULL); |
357 | *dynarray_str_at (list: &dyn, index: count - 1) = xstrdup ("allocated2" ); |
358 | TEST_VERIFY (dynarray_str_resize (&dyn, 3)); |
359 | TEST_VERIFY (strcmp (*dynarray_str_at (&dyn, 0), "allocated0" ) == 0); |
360 | TEST_VERIFY (strcmp (*dynarray_str_at (&dyn, 1), "allocated1" ) == 0); |
361 | TEST_VERIFY (*dynarray_str_at (&dyn, 2) == NULL); |
362 | dynarray_str_free (list: &dyn); |
363 | } |
364 | } |
365 | |
366 | /* Verify that DYNARRAY_ELEMENT_INIT has an effect. */ |
367 | static void |
368 | test_long_init (void) |
369 | { |
370 | enum { count = 2131 }; |
371 | { |
372 | struct dynarray_long dyn; |
373 | dynarray_long_init (list: &dyn); |
374 | for (int i = 0; i < count; ++i) |
375 | { |
376 | long *place = dynarray_long_emplace (list: &dyn); |
377 | TEST_VERIFY_EXIT (place != NULL); |
378 | TEST_VERIFY (*place == 17); |
379 | } |
380 | TEST_VERIFY (dynarray_long_size (&dyn) == count); |
381 | for (int i = 0; i < count; ++i) |
382 | TEST_VERIFY (*dynarray_long_at (&dyn, i) == 17); |
383 | dynarray_long_free (list: &dyn); |
384 | |
385 | TEST_VERIFY (dynarray_long_resize (&dyn, 1)); |
386 | TEST_VERIFY (dynarray_long_size (&dyn) == 1); |
387 | TEST_VERIFY (*dynarray_long_at (&dyn, 0) == 17); |
388 | *dynarray_long_at (list: &dyn, index: 0) = 18; |
389 | dynarray_long_free (list: &dyn); |
390 | TEST_VERIFY (dynarray_long_resize (&dyn, 1)); |
391 | TEST_VERIFY (dynarray_long_size (&dyn) == 1); |
392 | TEST_VERIFY (*dynarray_long_at (&dyn, 0) == 17); |
393 | TEST_VERIFY (dynarray_long_resize (&dyn, 2)); |
394 | TEST_VERIFY (dynarray_long_size (&dyn) == 2); |
395 | TEST_VERIFY (*dynarray_long_at (&dyn, 0) == 17); |
396 | TEST_VERIFY (*dynarray_long_at (&dyn, 1) == 17); |
397 | *dynarray_long_at (list: &dyn, index: 0) = 18; |
398 | TEST_VERIFY (dynarray_long_resize (&dyn, count)); |
399 | TEST_VERIFY (dynarray_long_size (&dyn) == count); |
400 | TEST_VERIFY (*dynarray_long_at (&dyn, 0) == 18); |
401 | for (int i = 1; i < count; ++i) |
402 | TEST_VERIFY (*dynarray_long_at (&dyn, i) == 17); |
403 | dynarray_long_free (list: &dyn); |
404 | } |
405 | |
406 | /* Similar, but without an on-stack scratch region |
407 | (DYNARRAY_INITIAL_SIZE is 0). */ |
408 | { |
409 | struct dynarray_long_noscratch dyn; |
410 | dynarray_long_noscratch_init (list: &dyn); |
411 | struct long_array result; |
412 | TEST_VERIFY_EXIT (dynarray_long_noscratch_finalize (&dyn, &result)); |
413 | TEST_VERIFY (result.array == NULL); |
414 | TEST_VERIFY (result.length == 0); |
415 | |
416 | /* Test with one element. */ |
417 | { |
418 | long *place = dynarray_long_noscratch_emplace (list: &dyn); |
419 | TEST_VERIFY_EXIT (place != NULL); |
420 | TEST_VERIFY (*place == 23); |
421 | } |
422 | TEST_VERIFY (dynarray_long_noscratch_size (&dyn) == 1); |
423 | TEST_VERIFY (*dynarray_long_noscratch_at (&dyn, 0) == 23); |
424 | TEST_VERIFY_EXIT (dynarray_long_noscratch_finalize (&dyn, &result)); |
425 | TEST_VERIFY_EXIT (result.array != NULL); |
426 | TEST_VERIFY (result.length == 1); |
427 | TEST_VERIFY (result.array[0] == 23); |
428 | free (ptr: result.array); |
429 | |
430 | for (int i = 0; i < count; ++i) |
431 | { |
432 | long *place = dynarray_long_noscratch_emplace (list: &dyn); |
433 | TEST_VERIFY_EXIT (place != NULL); |
434 | TEST_VERIFY (*place == 23); |
435 | if (i == 0) |
436 | *place = 29; |
437 | } |
438 | TEST_VERIFY (dynarray_long_noscratch_size (&dyn) == count); |
439 | TEST_VERIFY (*dynarray_long_noscratch_at (&dyn, 0) == 29); |
440 | for (int i = 1; i < count; ++i) |
441 | TEST_VERIFY (*dynarray_long_noscratch_at (&dyn, i) == 23); |
442 | TEST_VERIFY_EXIT (dynarray_long_noscratch_finalize (&dyn, &result)); |
443 | TEST_VERIFY_EXIT (result.array != NULL); |
444 | TEST_VERIFY (result.length == count); |
445 | TEST_VERIFY (result.array[0] == 29); |
446 | for (int i = 1; i < count; ++i) |
447 | TEST_VERIFY (result.array[i] == 23); |
448 | free (ptr: result.array); |
449 | |
450 | TEST_VERIFY (dynarray_long_noscratch_resize (&dyn, 1)); |
451 | TEST_VERIFY (dynarray_long_noscratch_size (&dyn) == 1); |
452 | TEST_VERIFY (*dynarray_long_noscratch_at (&dyn, 0) == 23); |
453 | *dynarray_long_noscratch_at (list: &dyn, index: 0) = 24; |
454 | dynarray_long_noscratch_free (list: &dyn); |
455 | TEST_VERIFY (dynarray_long_noscratch_resize (&dyn, 1)); |
456 | TEST_VERIFY (dynarray_long_noscratch_size (&dyn) == 1); |
457 | TEST_VERIFY (*dynarray_long_noscratch_at (&dyn, 0) == 23); |
458 | TEST_VERIFY (dynarray_long_noscratch_resize (&dyn, 2)); |
459 | TEST_VERIFY (dynarray_long_noscratch_size (&dyn) == 2); |
460 | TEST_VERIFY (*dynarray_long_noscratch_at (&dyn, 0) == 23); |
461 | TEST_VERIFY (*dynarray_long_noscratch_at (&dyn, 1) == 23); |
462 | *dynarray_long_noscratch_at (list: &dyn, index: 0) = 24; |
463 | TEST_VERIFY (dynarray_long_noscratch_resize (&dyn, count)); |
464 | TEST_VERIFY (dynarray_long_noscratch_size (&dyn) == count); |
465 | TEST_VERIFY (*dynarray_long_noscratch_at (&dyn, 0) == 24); |
466 | for (int i = 1; i < count; ++i) |
467 | TEST_VERIFY (*dynarray_long_noscratch_at (&dyn, i) == 23); |
468 | dynarray_long_noscratch_free (list: &dyn); |
469 | } |
470 | } |
471 | |
472 | /* Test overflow in resize. */ |
473 | static void |
474 | test_long_overflow (void) |
475 | { |
476 | { |
477 | struct dynarray_long dyn; |
478 | dynarray_long_init (list: &dyn); |
479 | errno = EINVAL; |
480 | DIAG_PUSH_NEEDS_COMMENT; |
481 | /* GCC 12 (on 32-bit platforms) warns that after inlining, a loop |
482 | iteration would invoke undefined behavior. That loop iteration |
483 | can never be executed because an allocation of this size must |
484 | fail. */ |
485 | DIAG_IGNORE_NEEDS_COMMENT (12, "-Waggressive-loop-optimizations" ); |
486 | TEST_VERIFY (!dynarray_long_resize |
487 | (&dyn, (SIZE_MAX / sizeof (long)) + 1)); |
488 | DIAG_POP_NEEDS_COMMENT; |
489 | TEST_VERIFY (errno == ENOMEM); |
490 | TEST_VERIFY (dynarray_long_has_failed (&dyn)); |
491 | } |
492 | |
493 | { |
494 | struct dynarray_long_noscratch dyn; |
495 | dynarray_long_noscratch_init (list: &dyn); |
496 | errno = EINVAL; |
497 | DIAG_PUSH_NEEDS_COMMENT; |
498 | /* GCC 12 (on 32-bit platforms) warns that after inlining, a loop |
499 | iteration would invoke undefined behavior. That loop iteration |
500 | can never be executed because an allocation of this size must |
501 | fail. */ |
502 | DIAG_IGNORE_NEEDS_COMMENT (12, "-Waggressive-loop-optimizations" ); |
503 | TEST_VERIFY (!dynarray_long_noscratch_resize |
504 | (&dyn, (SIZE_MAX / sizeof (long)) + 1)); |
505 | DIAG_POP_NEEDS_COMMENT; |
506 | TEST_VERIFY (errno == ENOMEM); |
507 | TEST_VERIFY (dynarray_long_noscratch_has_failed (&dyn)); |
508 | } |
509 | } |
510 | |
511 | /* Test NUL-terminated string construction with the add function and |
512 | the simple finalize function. */ |
513 | static void |
514 | test_zstr (void) |
515 | { |
516 | /* Totally empty string (no NUL termination). */ |
517 | { |
518 | struct zstr s; |
519 | zstr_init (list: &s); |
520 | char *result = zstr_finalize (list: &s, NULL); |
521 | TEST_VERIFY (result == NULL); |
522 | TEST_VERIFY (zstr_size (&s) == 0); |
523 | size_t length = 1; |
524 | result = zstr_finalize (list: &s, lengthp: &length); |
525 | TEST_VERIFY (result == NULL); |
526 | TEST_VERIFY (length == 0); |
527 | TEST_VERIFY (zstr_size (&s) == 0); |
528 | } |
529 | |
530 | /* Empty string. */ |
531 | { |
532 | struct zstr s; |
533 | zstr_init (list: &s); |
534 | zstr_add (list: &s, item: '\0'); |
535 | char *result = zstr_finalize (list: &s, NULL); |
536 | TEST_VERIFY_EXIT (result != NULL); |
537 | TEST_VERIFY (*result == '\0'); |
538 | TEST_VERIFY (zstr_size (&s) == 0); |
539 | free (ptr: result); |
540 | |
541 | zstr_add (list: &s, item: '\0'); |
542 | size_t length = 1; |
543 | result = zstr_finalize (list: &s, lengthp: &length); |
544 | TEST_VERIFY_EXIT (result != NULL); |
545 | TEST_VERIFY (*result == '\0'); |
546 | TEST_VERIFY (length == 1); |
547 | TEST_VERIFY (zstr_size (&s) == 0); |
548 | free (ptr: result); |
549 | } |
550 | |
551 | /* A few characters. */ |
552 | { |
553 | struct zstr s; |
554 | zstr_init (list: &s); |
555 | zstr_add (list: &s, item: 'A'); |
556 | zstr_add (list: &s, item: 'b'); |
557 | zstr_add (list: &s, item: 'c'); |
558 | zstr_add (list: &s, item: '\0'); |
559 | char *result = zstr_finalize (list: &s, NULL); |
560 | TEST_VERIFY_EXIT (result != NULL); |
561 | TEST_VERIFY (strcmp (result, "Abc" ) == 0); |
562 | TEST_VERIFY (zstr_size (&s) == 0); |
563 | free (ptr: result); |
564 | |
565 | zstr_add (list: &s, item: 'X'); |
566 | zstr_add (list: &s, item: 'y'); |
567 | zstr_add (list: &s, item: 'z'); |
568 | zstr_add (list: &s, item: '\0'); |
569 | size_t length = 1; |
570 | result = zstr_finalize (list: &s, lengthp: &length); |
571 | TEST_VERIFY_EXIT (result != NULL); |
572 | TEST_VERIFY (strcmp (result, "Xyz" ) == 0); |
573 | TEST_VERIFY (length == 4); |
574 | TEST_VERIFY (zstr_size (&s) == 0); |
575 | free (ptr: result); |
576 | } |
577 | } |
578 | |
579 | static int |
580 | do_test (void) |
581 | { |
582 | mtrace (); |
583 | test_int (); |
584 | test_str (); |
585 | test_long_init (); |
586 | test_long_overflow (); |
587 | test_zstr (); |
588 | return 0; |
589 | } |
590 | |
591 | #include <support/test-driver.c> |
592 | |