@matheusbsbs / matheus-bagliano
Code Commits Pulls CI/CD 81,972
jch
bisect jch maint master next seen test todo
c 549 lines 16.7 KB
Raw
1 #include "unit-test.h"
2 #include "string-list.h"
3
4 static void t_vcreate_string_list_dup(struct string_list *list,
5 int free_util, va_list ap)
6 {
7 const char *arg;
8
9 cl_assert(list->strdup_strings);
10
11 string_list_clear(list, free_util);
12 while ((arg = va_arg(ap, const char *)))
13 string_list_append(list, arg);
14 }
15
16 static void t_create_string_list_dup(struct string_list *list, int free_util, ...)
17 {
18 va_list ap;
19
20 cl_assert(list->strdup_strings);
21
22 string_list_clear(list, free_util);
23 va_start(ap, free_util);
24 t_vcreate_string_list_dup(list, free_util, ap);
25 va_end(ap);
26 }
27
28 static void t_string_list_clear(struct string_list *list, int free_util)
29 {
30 string_list_clear(list, free_util);
31 cl_assert_equal_p(list->items, NULL);
32 cl_assert_equal_i(list->nr, 0);
33 cl_assert_equal_i(list->alloc, 0);
34 }
35
36 static void t_string_list_equal(struct string_list *list,
37 struct string_list *expected_strings)
38 {
39 cl_assert_equal_i(list->nr, expected_strings->nr);
40 cl_assert(list->nr <= list->alloc);
41 for (size_t i = 0; i < expected_strings->nr; i++)
42 cl_assert_equal_s(list->items[i].string,
43 expected_strings->items[i].string);
44 }
45
46 static void t_string_list_split(const char *data, const char *delim, int maxsplit, ...)
47 {
48 struct string_list expected_strings = STRING_LIST_INIT_DUP;
49 struct string_list list = STRING_LIST_INIT_DUP;
50 va_list ap;
51 int len;
52
53 va_start(ap, maxsplit);
54 t_vcreate_string_list_dup(&expected_strings, 0, ap);
55 va_end(ap);
56
57 string_list_clear(&list, 0);
58 len = string_list_split(&list, data, delim, maxsplit);
59 cl_assert_equal_i(len, expected_strings.nr);
60 t_string_list_equal(&list, &expected_strings);
61
62 string_list_clear(&expected_strings, 0);
63 string_list_clear(&list, 0);
64 }
65
66 static void t_string_list_split_f(const char *data, const char *delim,
67 int maxsplit, unsigned flags, ...)
68 {
69 struct string_list expected_strings = STRING_LIST_INIT_DUP;
70 struct string_list list = STRING_LIST_INIT_DUP;
71 va_list ap;
72 int len;
73
74 va_start(ap, flags);
75 t_vcreate_string_list_dup(&expected_strings, 0, ap);
76 va_end(ap);
77
78 string_list_clear(&list, 0);
79 len = string_list_split_f(&list, data, delim, maxsplit, flags);
80 cl_assert_equal_i(len, expected_strings.nr);
81 t_string_list_equal(&list, &expected_strings);
82
83 string_list_clear(&expected_strings, 0);
84 string_list_clear(&list, 0);
85 }
86
87 void test_string_list__split_f(void)
88 {
89 t_string_list_split_f("::foo:bar:baz:", ":", -1, 0,
90 "", "", "foo", "bar", "baz", "", NULL);
91 t_string_list_split_f(" foo:bar : baz", ":", -1, STRING_LIST_SPLIT_TRIM,
92 "foo", "bar", "baz", NULL);
93 t_string_list_split_f(" a b c ", " ", 1, STRING_LIST_SPLIT_TRIM,
94 "a", "b c", NULL);
95 t_string_list_split_f("::foo::bar:baz:", ":", -1, STRING_LIST_SPLIT_NONEMPTY,
96 "foo", "bar", "baz", NULL);
97 t_string_list_split_f("foo:baz", ":", -1, STRING_LIST_SPLIT_NONEMPTY,
98 "foo", "baz", NULL);
99 t_string_list_split_f("foo :: : baz", ":", -1,
100 STRING_LIST_SPLIT_NONEMPTY | STRING_LIST_SPLIT_TRIM,
101 "foo", "baz", NULL);
102 }
103
104 static void t_string_list_split_in_place_f(const char *data_, const char *delim,
105 int maxsplit, unsigned flags, ...)
106 {
107 struct string_list expected_strings = STRING_LIST_INIT_DUP;
108 struct string_list list = STRING_LIST_INIT_NODUP;
109 char *data = xstrdup(data_);
110 va_list ap;
111 int len;
112
113 va_start(ap, flags);
114 t_vcreate_string_list_dup(&expected_strings, 0, ap);
115 va_end(ap);
116
117 string_list_clear(&list, 0);
118 len = string_list_split_in_place_f(&list, data, delim, maxsplit, flags);
119 cl_assert_equal_i(len, expected_strings.nr);
120 t_string_list_equal(&list, &expected_strings);
121
122 free(data);
123 string_list_clear(&expected_strings, 0);
124 string_list_clear(&list, 0);
125 }
126
127 void test_string_list__split_in_place_f(void)
128 {
129 t_string_list_split_in_place_f("::foo:bar:baz:", ":", -1, 0,
130 "", "", "foo", "bar", "baz", "", NULL);
131 t_string_list_split_in_place_f(" foo:bar : baz", ":", -1, STRING_LIST_SPLIT_TRIM,
132 "foo", "bar", "baz", NULL);
133 t_string_list_split_in_place_f(" a b c ", " ", 1, STRING_LIST_SPLIT_TRIM,
134 "a", "b c", NULL);
135 t_string_list_split_in_place_f("::foo::bar:baz:", ":", -1,
136 STRING_LIST_SPLIT_NONEMPTY,
137 "foo", "bar", "baz", NULL);
138 t_string_list_split_in_place_f("foo:baz", ":", -1, STRING_LIST_SPLIT_NONEMPTY,
139 "foo", "baz", NULL);
140 t_string_list_split_in_place_f("foo :: : baz", ":", -1,
141 STRING_LIST_SPLIT_NONEMPTY | STRING_LIST_SPLIT_TRIM,
142 "foo", "baz", NULL);
143 }
144
145 void test_string_list__split(void)
146 {
147 t_string_list_split("foo:bar:baz", ":", -1, "foo", "bar", "baz", NULL);
148 t_string_list_split("foo:bar:baz", ":", 0, "foo:bar:baz", NULL);
149 t_string_list_split("foo:bar:baz", ":", 1, "foo", "bar:baz", NULL);
150 t_string_list_split("foo:bar:baz", ":", 2, "foo", "bar", "baz", NULL);
151 t_string_list_split("foo:bar:", ":", -1, "foo", "bar", "", NULL);
152 t_string_list_split("", ":", -1, "", NULL);
153 t_string_list_split(":", ":", -1, "", "", NULL);
154 }
155
156 static void t_string_list_split_in_place(const char *data, const char *delim,
157 int maxsplit, ...)
158 {
159 struct string_list expected_strings = STRING_LIST_INIT_DUP;
160 struct string_list list = STRING_LIST_INIT_NODUP;
161 char *string = xstrdup(data);
162 va_list ap;
163 int len;
164
165 va_start(ap, maxsplit);
166 t_vcreate_string_list_dup(&expected_strings, 0, ap);
167 va_end(ap);
168
169 string_list_clear(&list, 0);
170 len = string_list_split_in_place(&list, string, delim, maxsplit);
171 cl_assert_equal_i(len, expected_strings.nr);
172 t_string_list_equal(&list, &expected_strings);
173
174 free(string);
175 string_list_clear(&expected_strings, 0);
176 string_list_clear(&list, 0);
177 }
178
179 void test_string_list__split_in_place(void)
180 {
181 t_string_list_split_in_place("foo:;:bar:;:baz:;:", ":;", -1,
182 "foo", "", "", "bar", "", "", "baz", "", "", "", NULL);
183 t_string_list_split_in_place("foo:;:bar:;:baz", ":;", 0,
184 "foo:;:bar:;:baz", NULL);
185 t_string_list_split_in_place("foo:;:bar:;:baz", ":;", 1,
186 "foo", ";:bar:;:baz", NULL);
187 t_string_list_split_in_place("foo:;:bar:;:baz", ":;", 2,
188 "foo", "", ":bar:;:baz", NULL);
189 t_string_list_split_in_place("foo:;:bar:;:", ":;", -1,
190 "foo", "", "", "bar", "", "", "", NULL);
191 }
192
193 static int prefix_cb(struct string_list_item *item, void *cb_data)
194 {
195 const char *prefix = (const char *)cb_data;
196 return starts_with(item->string, prefix);
197 }
198
199 static void t_string_list_filter(struct string_list *list, ...)
200 {
201 struct string_list expected_strings = STRING_LIST_INIT_DUP;
202 const char *prefix = "y";
203 va_list ap;
204
205 va_start(ap, list);
206 t_vcreate_string_list_dup(&expected_strings, 0, ap);
207 va_end(ap);
208
209 filter_string_list(list, 0, prefix_cb, (void *)prefix);
210 t_string_list_equal(list, &expected_strings);
211
212 string_list_clear(&expected_strings, 0);
213 }
214
215 void test_string_list__filter(void)
216 {
217 struct string_list list = STRING_LIST_INIT_DUP;
218
219 t_create_string_list_dup(&list, 0, NULL);
220 t_string_list_filter(&list, NULL);
221
222 t_create_string_list_dup(&list, 0, "no", NULL);
223 t_string_list_filter(&list, NULL);
224
225 t_create_string_list_dup(&list, 0, "yes", NULL);
226 t_string_list_filter(&list, "yes", NULL);
227
228 t_create_string_list_dup(&list, 0, "no", "yes", NULL);
229 t_string_list_filter(&list, "yes", NULL);
230
231 t_create_string_list_dup(&list, 0, "yes", "no", NULL);
232 t_string_list_filter(&list, "yes", NULL);
233
234 t_create_string_list_dup(&list, 0, "y1", "y2", NULL);
235 t_string_list_filter(&list, "y1", "y2", NULL);
236
237 t_create_string_list_dup(&list, 0, "y2", "y1", NULL);
238 t_string_list_filter(&list, "y2", "y1", NULL);
239
240 t_create_string_list_dup(&list, 0, "x1", "x2", NULL);
241 t_string_list_filter(&list, NULL);
242
243 t_string_list_clear(&list, 0);
244 }
245
246 static void t_string_list_has_string(
247 struct string_list *list,
248 const char *string,
249 int expected)
250 {
251 int has_string = string_list_has_string(list, string);
252 cl_assert_equal_i(has_string, expected);
253 }
254
255 void test_string_list__has_string(void)
256 {
257 struct string_list list = STRING_LIST_INIT_DUP;
258
259 t_create_string_list_dup(&list, 0, NULL);
260 t_string_list_has_string(&list, "", 0);
261
262 t_create_string_list_dup(&list, 0, "a", "b", "c", NULL);
263 t_string_list_has_string(&list, "a", 1);
264 t_string_list_has_string(&list, "b", 1);
265 t_string_list_has_string(&list, "c", 1);
266 t_string_list_has_string(&list, "d", 0);
267
268 t_string_list_clear(&list, 0);
269 }
270
271 static void t_string_list_insert(struct string_list *expected_strings, ...)
272 {
273 struct string_list strings_to_insert = STRING_LIST_INIT_DUP;
274 struct string_list list = STRING_LIST_INIT_DUP;
275 va_list ap;
276
277 va_start(ap, expected_strings);
278 t_vcreate_string_list_dup(&strings_to_insert, 0, ap);
279 va_end(ap);
280
281 for (size_t i = 0; i < strings_to_insert.nr; i++)
282 string_list_insert(&list, strings_to_insert.items[i].string);
283
284 t_string_list_equal(&list, expected_strings);
285
286 string_list_clear(&strings_to_insert, 0);
287 string_list_clear(&list, 0);
288 }
289
290 void test_string_list__insert(void)
291 {
292 struct string_list expected_strings = STRING_LIST_INIT_DUP;
293
294 t_create_string_list_dup(&expected_strings, 0, NULL);
295 t_string_list_insert(&expected_strings, NULL);
296
297 t_create_string_list_dup(&expected_strings, 0, "a", "b", NULL);
298 t_string_list_insert(&expected_strings, "b", "a", "a", "b", NULL);
299
300 t_create_string_list_dup(&expected_strings, 0, "a", "b", "c", NULL);
301 t_string_list_insert(&expected_strings, "c", "b", "a", "c", "b", NULL);
302
303 t_create_string_list_dup(&expected_strings, 0, "", "a", NULL);
304 t_string_list_insert(&expected_strings, "a", "a", "a", "", NULL);
305
306 t_string_list_clear(&expected_strings, 0);
307 }
308
309 static void t_string_list_sort(struct string_list *list, ...)
310 {
311 struct string_list expected_strings = STRING_LIST_INIT_DUP;
312 va_list ap;
313
314 va_start(ap, list);
315 t_vcreate_string_list_dup(&expected_strings, 0, ap);
316 va_end(ap);
317
318 string_list_sort(list);
319 t_string_list_equal(list, &expected_strings);
320
321 string_list_clear(&expected_strings, 0);
322 }
323
324 void test_string_list__sort(void)
325 {
326 struct string_list list = STRING_LIST_INIT_DUP;
327
328 t_create_string_list_dup(&list, 0, NULL);
329 t_string_list_sort(&list, NULL);
330
331 t_create_string_list_dup(&list, 0, "b", "", "a", NULL);
332 t_string_list_sort(&list, "", "a", "b", NULL);
333
334 t_create_string_list_dup(&list, 0, "c", "a", "b", "a", NULL);
335 t_string_list_sort(&list, "a", "a", "b", "c", NULL);
336
337 t_string_list_clear(&list, 0);
338 }
339
340 static void t_string_list_remove(
341 struct string_list *expected_strings,
342 struct string_list *list,
343 char const *str)
344 {
345 string_list_remove(list, str, 0);
346 t_string_list_equal(list, expected_strings);
347 }
348
349 void test_string_list__remove(void)
350 {
351 struct string_list expected_strings = STRING_LIST_INIT_DUP;
352 struct string_list list = STRING_LIST_INIT_DUP;
353
354 t_create_string_list_dup(&expected_strings, 0, NULL);
355 t_create_string_list_dup(&list, 0, NULL);
356 t_string_list_remove(&expected_strings, &list, "");
357
358 t_create_string_list_dup(&expected_strings, 0, "a", NULL);
359 t_create_string_list_dup(&list, 0, "a", "a", NULL);
360 t_string_list_remove(&expected_strings, &list, "a");
361
362 t_create_string_list_dup(&expected_strings, 0, "a", "b", "b", NULL);
363 t_create_string_list_dup(&list, 0, "a", "b", "b", "c", NULL);
364 t_string_list_remove(&expected_strings, &list, "c");
365
366 t_create_string_list_dup(&expected_strings, 0, "a", "b", "d", NULL);
367 t_create_string_list_dup(&list, 0, "a", "b", "c", "d", NULL);
368 t_string_list_remove(&expected_strings, &list, "c");
369
370 t_create_string_list_dup(&expected_strings, 0, "a", "b", "c", "d", NULL);
371 t_create_string_list_dup(&list, 0, "a", "b", "c", "d", NULL);
372 t_string_list_remove(&expected_strings, &list, "e");
373
374 t_string_list_clear(&expected_strings, 0);
375 t_string_list_clear(&list, 0);
376 }
377
378 static void t_string_list_remove_duplicates(struct string_list *list, ...)
379 {
380 struct string_list expected_strings = STRING_LIST_INIT_DUP;
381 va_list ap;
382
383 va_start(ap, list);
384 t_vcreate_string_list_dup(&expected_strings, 0, ap);
385 va_end(ap);
386
387 string_list_remove_duplicates(list, 0);
388 t_string_list_equal(list, &expected_strings);
389
390 string_list_clear(&expected_strings, 0);
391 }
392
393 void test_string_list__remove_duplicates(void)
394 {
395 struct string_list list = STRING_LIST_INIT_DUP;
396
397 t_create_string_list_dup(&list, 0, NULL);
398 t_string_list_remove_duplicates(&list, NULL);
399
400 t_create_string_list_dup(&list, 0, "", NULL);
401 t_string_list_remove_duplicates(&list, "", NULL);
402
403 t_create_string_list_dup(&list, 0, "a", NULL);
404 t_string_list_remove_duplicates(&list, "a", NULL);
405
406 t_create_string_list_dup(&list, 0, "a", "a", NULL);
407 t_string_list_remove_duplicates(&list, "a", NULL);
408
409 t_create_string_list_dup(&list, 0, "a", "a", "a", NULL);
410 t_string_list_remove_duplicates(&list, "a", NULL);
411
412 t_create_string_list_dup(&list, 0, "a", "a", "b", NULL);
413 t_string_list_remove_duplicates(&list, "a", "b", NULL);
414
415 t_create_string_list_dup(&list, 0, "a", "b", "b", NULL);
416 t_string_list_remove_duplicates(&list, "a", "b", NULL);
417
418 t_create_string_list_dup(&list, 0, "a", "b", "c", NULL);
419 t_string_list_remove_duplicates(&list, "a", "b", "c", NULL);
420
421 t_create_string_list_dup(&list, 0, "a", "a", "b", "c", NULL);
422 t_string_list_remove_duplicates(&list, "a", "b", "c", NULL);
423
424 t_create_string_list_dup(&list, 0, "a", "b", "b", "c", NULL);
425 t_string_list_remove_duplicates(&list, "a", "b", "c", NULL);
426
427 t_create_string_list_dup(&list, 0, "a", "b", "c", "c", NULL);
428 t_string_list_remove_duplicates(&list, "a", "b", "c", NULL);
429
430 t_create_string_list_dup(&list, 0, "a", "a", "b", "b", "c", "c", NULL);
431 t_string_list_remove_duplicates(&list, "a", "b", "c", NULL);
432
433 t_create_string_list_dup(&list, 0, "a", "a", "a", "b", "b", "b",
434 "c", "c", "c", NULL);
435 t_string_list_remove_duplicates(&list, "a", "b", "c", NULL);
436
437 t_string_list_clear(&list, 0);
438 }
439
440 static void t_string_list_sort_u(struct string_list *list, ...)
441 {
442 struct string_list expected_strings = STRING_LIST_INIT_DUP;
443 va_list ap;
444
445 va_start(ap, list);
446 t_vcreate_string_list_dup(&expected_strings, 0, ap);
447 va_end(ap);
448
449 string_list_sort_u(list, 0);
450 t_string_list_equal(list, &expected_strings);
451
452 string_list_clear(&expected_strings, 0);
453 }
454
455 void test_string_list__sort_u(void)
456 {
457 struct string_list list = STRING_LIST_INIT_DUP;
458
459 t_create_string_list_dup(&list, 0, NULL);
460 t_string_list_sort_u(&list, NULL);
461
462 t_create_string_list_dup(&list, 0, "", "", "", "", NULL);
463 t_string_list_sort_u(&list, "", NULL);
464
465 t_create_string_list_dup(&list, 0, "b", "a", "a", "", NULL);
466 t_string_list_sort_u(&list, "", "a", "b", NULL);
467
468 t_create_string_list_dup(&list, 0, "b", "a", "a", "d", "c", "c", NULL);
469 t_string_list_sort_u(&list, "a", "b", "c", "d", NULL);
470
471 t_string_list_clear(&list, 0);
472 }
473
474 static void t_string_list_remove_empty_items(
475 struct string_list *expected_strings,
476 struct string_list *list)
477 {
478 string_list_remove_empty_items(list, 0);
479 t_string_list_equal(list, expected_strings);
480 }
481
482 void test_string_list__remove_empty_items(void)
483 {
484 struct string_list expected_strings = STRING_LIST_INIT_DUP;
485 struct string_list list = STRING_LIST_INIT_DUP;
486
487 t_create_string_list_dup(&expected_strings, 0, NULL);
488 t_create_string_list_dup(&list, 0, "", "", "", NULL);
489 t_string_list_remove_empty_items(&expected_strings, &list);
490
491 t_create_string_list_dup(&expected_strings, 0, "a", "b", NULL);
492 t_create_string_list_dup(&list, 0, "a", "", "b", "", NULL);
493 t_string_list_remove_empty_items(&expected_strings, &list);
494
495 t_string_list_clear(&expected_strings, 0);
496 t_string_list_clear(&list, 0);
497 }
498
499 static void t_string_list_unsorted_string_list_has_string(
500 struct string_list *list,
501 const char *str, int expected)
502 {
503 int has_string = unsorted_string_list_has_string(list, str);
504 cl_assert_equal_i(has_string, expected);
505 }
506
507 void test_string_list__unsorted_string_list_has_string(void)
508 {
509 struct string_list list = STRING_LIST_INIT_DUP;
510
511 t_create_string_list_dup(&list, 0, "b", "d", "a", NULL);
512 t_string_list_unsorted_string_list_has_string(&list, "a", 1);
513 t_string_list_unsorted_string_list_has_string(&list, "b", 1);
514 t_string_list_unsorted_string_list_has_string(&list, "c", 0);
515 t_string_list_unsorted_string_list_has_string(&list, "d", 1);
516
517 t_string_list_clear(&list, 0);
518 }
519
520 static void t_string_list_unsorted_string_list_delete_item(
521 struct string_list *expected_list,
522 struct string_list *list,
523 int i)
524 {
525 unsorted_string_list_delete_item(list, i, 0);
526
527 t_string_list_equal(list, expected_list);
528 }
529
530 void test_string_list__unsorted_string_list_delete_item(void)
531 {
532 struct string_list expected_strings = STRING_LIST_INIT_DUP;
533 struct string_list list = STRING_LIST_INIT_DUP;
534
535 t_create_string_list_dup(&expected_strings, 0, "a", "c", "b", NULL);
536 t_create_string_list_dup(&list, 0, "a", "d", "b", "c", NULL);
537 t_string_list_unsorted_string_list_delete_item(&expected_strings, &list, 1);
538
539 t_create_string_list_dup(&expected_strings, 0, NULL);
540 t_create_string_list_dup(&list, 0, "", NULL);
541 t_string_list_unsorted_string_list_delete_item(&expected_strings, &list, 0);
542
543 t_create_string_list_dup(&expected_strings, 0, "a", "d", "c", "b", NULL);
544 t_create_string_list_dup(&list, 0, "a", "d", "c", "b", "d", NULL);
545 t_string_list_unsorted_string_list_delete_item(&expected_strings, &list, 4);
546
547 t_string_list_clear(&expected_strings, 0);
548 t_string_list_clear(&list, 0);
549 }